Why does Function<Interface, R> not accept a method reference from a subclass?

Let's say I have an interface Animal with the method String getRace() and a subclass Dog. I keep some animals in a List<Animal>.

Now if I wanted to sort that list and passed a Function<Animal, String> into the method to use it together with Comparator.comparing(...) that would work fine. However, if I reference a function from Dog to pass as an argument, the compiler throws the following error:

> The type Zoo.Dog does not define getRace(Zoo.Animal) that is applicable here.

even though it's a subclass of Animal and does define that function.

Here's the code:

import java.util.*;
import java.util.function.*;
import java.util.stream.*;

public class Zoo {

	public interface Animal {

		public String getRace();

	}

	public class Dog implements Animal {

		public String getRace() {
			return "Some race";
		}

	}

	private List<Animal> animals = Arrays.asList(new Animal[] {});

	public void sort(Function<Animal, String> function) {
		animals = animals.stream().sorted(Comparator.comparing(function)).collect(Collectors.toList());
	}

	public static void main(String[] args) {
		Zoo zoo = new Zoo();
		
		// Error: "The type Zoo.Dog does not define getRace(Zoo.Animal) that is applicable here"
		zoo.sort(Dog::getRace);
	}

}

Why is that?

I've found this question, but in that example the classes are in no relation to each other.

Dog::getRace expects a Dog instance, but animals.stream() provides Animal instances.

What should work, I guess, since Dog implements Animal and getRace is declared in Animal:

    zoo.sort(Animal::getRace);

This works:

public static void main (String[] args) {
    Zoo zoo = new Zoo();
    zoo.sort(Animal::getRace);
}

The reason is simple:

To sort a List of Animal using a Comperator, it needs to be a Comperator<Animal>. This means the function you pass into Comperator.comparing needs to
be of a Function<? super Animal,? extends Comperable>. This is not
true for Function<Dog, String>, however it is true for
Function<Animal, String> and Function<Object, String>.

You correctly define your .sort() to take a Function<Animal, String> - but you pass in a member function of Dog - this is essentialla a Function Dog -> String, or Function<Dog,String> in functional interfaces.

In less technical terms: yes, a Dogcan do everything an Animal can. The way around however is not true - a Dog can have a function that not all animals have. Therefore, it's not valid to use a Function<Dog,?> in place of a Function<Animal,?> - but it would be ok the way around.