比较器比较类型推断

Question

Let's say change Comparator.comparing source code from

public static <T, U extends Comparable<? super U>> Comparator<T> comparing(
    Function<? super T, ? extends U> keyExtractor)
{
  Objects.requireNonNull(keyExtractor);
  return (Comparator<T> & Serializable) (c1, c2) -> keyExtractor.apply(c1).compareTo(keyExtractor.apply(c2));
}

to

public static <T, U extends Comparable<? super U>> Comparator<T> comparing(
    Function<T, U> keyExtractor)
{
  Objects.requireNonNull(keyExtractor);
  return (Comparator<T> & Serializable) (c1, c2) -> keyExtractor.apply(c1).compareTo(keyExtractor.apply(c2));
}

And we have the follwing classes

class PhysicalObject {
  double weight;
  public Double getWeight(){
    return weight;  
  }
}
class Car extends PhysicalObject {}

The following statament does not compile

Function<PhysicalObject, Double> weight = p->p.getWeight();

Comparator<Car> c = HypotheticComparators.comparing(weight);

while this compile Comparator<Car> c3_1 = HypotheticComparators.comparing(PhysicalObject::getWeight);

I understand that the first statement can't compile is because the modified comparing function does not have the bounded wildcard ( ? super T ), but why the second statement can compile without any problem ?

Answer 1

With comparing defined as:

Comparator<T> comparing(Function<T, U> keyExtractor) // abbreviated

the statement:

Comparator<Car> c = comparing(weight);

requires argument to be a Function<Car, ?> , but weight is a Function<PhysicalObject, Double> so you get the compile error.

However, when doing

Comparator<Car> c3_1 = comparing(PhysicalObject::getWeight);

the Function<Car, ?> method ? apply(Car t) ? apply(Car t) is adequately implemented by the Double getWeight() of superclass PhysicalObject , since t->getWeight() is a call to that method.

The PhysicalObject::getWeight method reference is like the following lambda:

Comparator<Car> c3_1 = comparing((Car t) -> {
    PhysicalObject p = t;
    return p.getWeight(); // call PhysicalObject::getWeight
});

Or the following anonymous class:

Comparator<Car> c3_1 = comparing(new Function<Car, Double>() {
    @Override
    public Double apply(Car t) {
        PhysicalObject p = t;
        return p.getWeight();
    }
});

The widening conversion from Car to PhysicalObject is allowed in a method reference.

Answer 2

According to the JLS ( §18.2.1: Expression Compatibility Constraints ), this is due to the Reduction stage for exact method references within the chapter on Type Inference, as seen by the image below.

Essentially, the compiler is able to infer that, because Car extends PhysicalObject , it should be able to define a Comparator<Car> with a Function<Car, Double> .

Explicitly passing a Function<PhysicalObject, Double> to create a Comparator<Car> will not work though, as there is not enough information available for the compiler to properly infer it.