Ссылка на метод в Java 8

Это потому, что метод getMaxSpeed является методом Function<Car, Integer>.

А именно:

<Car, Integer> Comparator<Car> java.util.Comparator.comparing(
    Function<? super Car, ? extends Integer> keyExtractor
)

Примечание

Чтобы сослаться на getMaxSpeed из экземпляра Car с помощью идиомы ::, вам нужно объявить метод Car с сигнатурой: getMaxSpeed(Car car).

Если вы хотите создать ссылку на метод, который не принимает параметров, например, метод, уже привязанный к экземпляру, вы должны использовать Supplier, а не Function:

Function<Car, Integer> f1 = Car::getMaxSpeed;

Car carx = new Car(42);
Supplier<Integer> f2 = carx::getMaxSpeed; 

В ссылке на метод carX::getMaxSpeed «неявный» this-параметр функции уже привязан к carx, поэтому у вас остается функция без параметров (которую, кстати, нельзя использовать в Comparator), и в Java 8 функция без параметров — это просто Supplier.

Точно так же, если у вас есть метод, который возвращает void, вы получите Comsumer:

Consumer<Integer> f3 = carx::setMaxSpeed;

Функция-член без параметров фактически имеет скрытый параметр, ссылку this. Ссылки на методы формы ClassName::memberFunction всегда используют первый параметр функционального типа для экземпляра класса, то есть скрытый параметр this экземпляра. Итак, в случае с Car.getMaxSpeed() внутри он имеет те же параметры, что и static Integer getMaxSpeed(Car car). Таким образом, Car::getMaxSpeed соответствует функциональному типу Function<Car,Integer>, как и static Integer getMaxSpeed(Car car).

Нечто подобное происходит с функциями-членами, которые принимают один параметр — они соответствуют функциональному типу BiFunction, где первым параметром является экземпляр класса.

Назначение:

Function<Void, Integer> function = carX::getMaxSpeed;

не компилируется, потому что это Supplier<Integer>, а не Function.

Итак, почему это компилируется?:

Comparator.comparing(Car::getMaxSpeed)

Java 8 позволяет указать ссылку на метод экземпляра, которая представляет собой Supplier<U>, вместо ожидаемого Function<T, U>, и компилятор эффективно преобразует метод получения в функцию.

Чтобы выяснить, почему это возможно, давайте посмотрим, как мы вызываем метод получения с помощью отражения:

System.out.println(Car.class.getMethod("getMaxSpeed").invoke(carX)); // "155"

При вызове invoke() в методе экземпляра мы передаем экземпляр в метод invoke() геттера Method - там подразумевается параметр типа экземпляра. Если посмотреть на это таким образом, мы увидим, что под капотом геттер действительно реализован как Function<T, U> через метод invoke().

Давайте подробно рассмотрим Function:

Interface Function<T,R> {

    default <V> Function<T,V>   andThen(Function<? super R,? extends V> after){}

    R   apply(T t);

    default <V> Function<V,R>   compose(Function<? super V,? extends T> before){}

    static <T> Function<T,T>    identity();

}

обратите внимание на R apply(T t); применяет эту функцию к данному аргументу.

Function<Void, Integer> function = Void::?????;
Void voidInstance = null;
function.apply(voidInstance);

Это не имеет смысла. Вы хотите передать Пустоту так, чтобы функция Пустоты применялась?

Несколько наглядных примеров того, что компилируется как функция

обратите внимание, что c->c.getMaxSpeed() и Car::getMaxSpeed синтаксически эквивалентны, если метод является instanceMethod. Для нестатических методов первый аргумент выводится из типа, метод которого используется, и должен быть предоставлен позже (как экземпляр, к которому метод будет выполняться/применяться).

public class Car {

    private int maxSpeed;

    public Car(int maxSpeed) {
        this.maxSpeed = maxSpeed;
    }

    public int getMaxSpeed() {
        return this.maxSpeed;
    }
    public Void setMaxSpeed() {
        this.maxSpeed = 12;
        return null;
    }
    public static int intStaticFunction(Void v) {
        return new Random().nextInt();
    }
    public static Void voidStaticFunction(Void v) {
        return null;
    }
    public static void main(String[] args) {
        final Car carX = new Car(155);
        final Car carY = new Car(140);

        final List<Car> cars = new ArrayList<>();
        cars.add(carX);
        cars.add(carY);

        cars.sort(Comparator.comparing(Car::getMaxSpeed));
        final Function<Car, Integer> function1 = c->c.getMaxSpeed();
        final Function<Car, Integer> function2 = Car::getMaxSpeed;
        final Function<Car, Void> function3 = Car::setMaxSpeed;
        final Function<Void, Void> function4 = n->n;
        final Function<Void, Integer> function5 = n->5;
        final Function<Void, Integer> function6 = Car::intStaticFunction;
        final Function<Void, Void> function7 = Car::voidStaticFunction;
        final Function<Car, Integer> function8 = function1::apply;
        final Function<Car, Integer> function9 = function2::apply;
        System.out.println(function1.apply(carX));
        System.out.println(function2.apply(carX));
        System.out.println(function8.apply(carX));
        System.out.println(function9.apply(carX));
        System.out.println(function3.apply(carX));
        System.out.println(function1.apply(carX));
        System.out.println(function2.apply(carX));
        System.out.println(function8.apply(carX));
        System.out.println(function9.apply(carX));
        System.out.println();
        System.out.println(function4.apply(null));
        System.out.println(function5.apply(null));
        System.out.println(function6.apply(null));
        System.out.println(function7.apply(null));
    }
}