Consider the following article from the JLS (§15.13.1)

A method reference expression ending with Identifier is exact if it satisfies all of the following:

• If the method reference expression has the form ReferenceType ::[TypeArguments] Identifier, then ReferenceType does not denote a raw type.
• The type to search has exactly one member method with the name Identifier that is accessible to the class or interface in which the method reference expression appears.
• This method is not variable arity (§8.4.1).
• If this method is generic (§8.4.4), then the method reference expression provides TypeArguments.

Consider the following code snippet:

class Scratch {

  public static void main(String[] args) {
    Scratch.funct(new ImplementingClass()::<Functional1>hitIt);
  }

  public static void funct(Functional1 a){}
  public static void funct(Functional2 a){}
}
interface Functional1 {<T> T hitIt();}
interface Functional2 {<T> T hitIt();}

class ImplementingClass{
  public <T> T hitIt(){return null;}
}

Clearly - this satisfies all the conditions being mentioned for a method reference to be exact.

Not sure why still the method reference is in-exact in this particular case? Am I missing something here from the clause?

Solution :

Based on inputs from @Sweeper @DidierL and @Holger here what I summarized:

1. Both the functional interfaces have the functionType <T> () -> T
2. the method reference …::<Functional1>hitIt substitutes T with Functional1, so the resulting functional signature is () -> Functional1 which does not match <T> () -> T.

CodePudding user response：

First a warning: IANAJL (IANAL for Java