Java Generics - allgemeine Klasse mit generischen Funktionserweiterungs

Question

Ich habe ein einfaches Programm wie folgt aus:

package test; 

public class TestGenericsInheritance { 

    public static void main(String[] args) {} 

    public static abstract class A<Q>{ 

     public void foo2(Q obj){} 
     public abstract <T> void foo(T obj); 
    } 

    public static class C extends A<Object>{ 

     @Override 
     public <T> void foo(T obj) {} 
    } 

    public static class B extends A{ 

     @Override 
     public <T> void foo(T obj) {} 
    } 
} 

wie Sie es absolut nichts sehen. Erstellung dieser Programmdatei auf Java 1.6 und 1.7 mit folgenden Fehlern:

/D:/Projects/.../test/TestGenericsInheritance.java:[24,19] test.TestGenericsInheritance.B is not abstract and do es not override abstract method foo(java.lang.Object) in test.TestGenericsInheritance.A /D:/Projects/.../test/TestGenericsInheritance.java:[27,25] name clash: foo(T) in test.TestGenericsInheritance .B and foo(T) in test.TestGenericsInheritance.A have the same erasure, yet neither overrides the other /D:/Projects/.../test/TestGenericsInheritance.java:[26,9] method does not override or implement a method from a supertype

Klassen C und B ist semantisch identisch, aber Klasse B nicht Methode foo als Implementierung von A # foo nicht erkennt. Um diesen Code konform zu machen Ich habe Methode A # foo in der Klasse B mit folgenden Unterschrift zu implementieren:

public void foo(Object obj) 

Meine Frage ist, warum mein Programm nicht kompiliert? Die generischen Typen Q und T sind vollständig unabhängig, weshalb kann ich die generische Funktion A # foo nur implementieren, wenn ich explizit den generischen Typ Q für die vererbte Klasse A festlege?

Dank

Answer 1

B erweitert die rohe Art A. Da Sie einen unformatierten Typ verwenden, werden alle generischen Informationen gelöscht, nicht nur die Typvariable, die Sie nicht angeben konnten (siehe Section 4.6 of the Java Language Specification). Dies bedeutet, dass A eine Methode void foo(Object obj) hat, während A<SomeType> eine Methode <T> void foo(T obj) hat.

Wenn Sie eine Methode überschreiben, muss sie die gleiche Signatur haben (optional nach dem Typ Löschen der überschriebenen Methode) - interessanterweise kann die überschreibende Methode einen anderen, spezifischeren Rückgabetyp haben. Die Signaturen Ihrer beiden Methoden sind unterschiedlich (Sie müssten in der Überschreibungsmethode Typ löschen). Daher wird Ihr Beispiel nicht kompiliert.

Der Grund Typ Löschung wurde implementiert, wie es ist, ist Abwärtskompatibilität. Die Idee war, dass neuer Code nur Generika verwenden würde und dass nur alter Code rohe Typen verwenden würde. Das Ziel bestand also nicht darin, rohe Typen so komfortabel wie möglich zu gestalten (weil neuer Code sie ohnehin nicht verwenden sollte), sondern um rohe Typen kompatibel zu machen.

Betrachten Sie zum Beispiel die Klasse ArrayList, die in Java 2 (lange vor Generika) eingeführt wurde. Es hatte eine Methode public Object[] toArray(Object[] a). In Java wurden 5 Generika eingeführt, und die Signatur dieser Methode konnte problemlos in public <T> T[] toArray(T[] a) geändert werden (wobei T nicht der Elementtyp ist). Wegen der Art, wie Löschart implementiert wird, für alten Code, der eher ArrayList verwendet (oder unterklassifiziert) als ArrayList<SomeType> blieb die Methodensignatur gleich.