Generics w nadpisanych metodach

Question

Znalazłem interesujący problem; następujące klasy kompiluje:

public class Test { 

    public static void main(String[] args) throws Exception { 
     A a = new A(); 
     B b = new B(); 

     foo(a); 
     foo(b); 
    } 

    private static void foo(A a) { 
     System.out.println("In A"); 
    } 

    private static void foo(B b) { 
     System.out.println("In B"); 
    } 

    private static class A {} 

    private static class B extends A {} 

} 

ale ten się nie powiedzie:

public class Test { 

    public static void main(String[] args) throws Exception { 
     A<String> a = new A<>(); 
     B b = new B(); 

     foo(a); 
     foo(b); 
    } 

    private static void foo(A<String> a) { 
     System.out.println("In A"); 
    } 

    private static void foo(B b) { 
     System.out.println("In B"); 
    } 

    private static class A<T> {} 

    private static class B extends A {} 

} 

z tego błędu:

Test.java:8: error: reference to foo is ambiguous, both method foo(A<String>) in Test and method foo(B) in Test match    
     foo(b);                              
     ^                               
Note: Test.java uses unchecked or unsafe operations.                    
Note: Recompile with -Xlint:unchecked for details.                     
1 error 

bym nie pomyślał, że ze względu na typ skasowaniu, które są zasadniczo identyczny. Czy ktoś wie, co się tutaj dzieje?

Answer 1

Przed świtem rodzajowych, Java miał metod takich jak

public class Collections 

    public void sort(List list) {...}    [1] 

I Kod użytkownik może mieć takie rzeczy jak

public class MyList implements List ...    [2] 

MyList myList = ...; 
Collections.sort(myList);       [3] 

Kiedy rodzajowych dodano do Javy, podjęto decyzję, aby przekształcić exis ting klas i metod do ogólnych, bez łamania jakiegokolwiek kodu za ich pomocą. Jest to wielkie osiągnięcie pod względem trudności, przy ogromnej cenie pozostawienia skomplikowanego i wadliwego języka.

Tak więc [1] został wygenerowany, ale [3] musi nadal kompilować, jak jest, bez konieczności generowania [2].

Hack jest w §15.12.2.3

Ai can be converted by method invocation conversion (§5.3) to Si

zasadniczo mówi, że jeśli typ argument (AI) jest surowy, a następnie skasować typ parametru (SI) również w celu dopasowania.

Powrót do Twojego przykładu, widzimy, dlaczego foo(A<String>) jest uważany za odpowiedni dla .

Jest jednak inne pytanie - czy ma zastosowanie foo(A<String>) na [§15.12.2.2]? Odpowiedź wydaje się być "nie" w liście spec. Ale może to być błąd specyfikacji.

Answer 2

private static class B extends A {} 

Tutaj nie ma argumentów typu dla A. Co prawdopodobnie myśli to

private static class B<T> extends A<T> {} 

Dodatkowo B b = new B() ma <String> argumentu, albo; trzeba zrobić

B<String> b = new B<String>(); 

... I wreszcie

private static void foo(B b) { 
    System.out.println("In B"); 
} 

powinno być coś jak

private static void foo(B<String> b) { 
    System.out.println("In B"); 
} 

W ogóle, jeśli nie jest to typ Foo że posiada ogólną tezę, Foo powinien zasadniczo zawsze mieć argument typu. W tym konkretnym przypadku class B extends A nie miał argumentu typu dla A, a następnie B potrzebował argumentu typu, więc potrzebowałeś argumentu typu wszędzie tam, gdzie wspomniałeś B. (Jeden z głównych wyjątkiem od tej reguły jest instanceof wyrażenia, ale nie ma żadnych tutaj).

Answer 3

Przyczyną jest to, że są mieszanie rodzajowych i surowe typy (B powinny być zadeklarowane jak class B<T> extends A<T> lub class B extends A<SomeType>).

Rzeczywisty powód, dla którego tak się dzieje jest pochowany gdzieś w the JLS, section #15.12.2.7 i po - powodzenia wyartykułować to succintly ;-)