Lambda und Generics: Warum kompiliert sich das?

Question

Dies ist eine verkürzte Probe meines Codes mein Punkt zu beweisen:

public class Tmp { 

    static class X { 
    void setStr(String blah) { 
    } 
    String getStr() { 
     return null; 
    } 
    } 

    public void test() { 
    createCheck(X::getStr, ""); // supposed to compile 
    createCheck(X::getStr, 123); // rather not: int isn't String 
    } 

    private <T, V> BiPredicate<T, String> createCheck(Function<T, V> func, V value) { 
    return new BiPredicate<T, String>() { 

     @Override 
     public boolean test(T t, String ref) { 
     assertThat(func.apply(t)) 
      .as(ref) 
      .isEqualTo(value); 
     return true; 
     } 

    }; 
    } 

} 

IMHO sollte der Compiler, dass V in createCheck()String aus der Getter-Funktion kommen sollte, weshalb es über die sich beschweren sollte int. Oder umgekehrt.

Warum also kompiliert?

Answer 1

Ihre Unterschrift ist:

private <T, V> BiPredicate<T, String> createCheck(Function<T, V> func, V value) { 

Sie haben keine Schranken für T oder V so absolut alle Werte von T oder V würde kompilieren.

Sie zurückkehren ein BiPredicate<T, String> jedoch, so dass die isEqualTo Methode, um die String ref nimmt und vergleicht seine Gleichheit mit dem Object value - dies auch vollkommen legal ist, wie ich glaube, isEqualTo ein Object nimmt das Verhalten von Object.equals zu imitieren.

---

In Ihrem Beispiel:

createCheck(X::getStr, 123); 

V ist einfach Object als dass der engste Typ ist verpflichtet, die String und Integer anwenden können.

---

Hast du vielleicht bedeuten:

private <T> BiPredicate<T, String> createCheck(Function<T, String> func, String value) {