Was ist ein Rohtyp?
Die Java-Sprachspezifikation definiert einen Rohtyp wie folgt:
Ein Rohtyp ist definiert als einer von:
Der Referenztyp, der gebildet wird, indem der Name einer generischen Typdeklaration ohne zugehörige Typargumentliste verwendet wird.
Ein Array-Typ, dessen Elementtyp ein Rohtyp ist.
Ein Nicht- staticMitgliedstyp eines Rohtyps R, der nicht von einer Oberklasse oder Superschnittstelle von geerbt wird R.
Hier ist ein Beispiel zur Veranschaulichung:
public class MyType<E> {
class Inner { }
static class Nested { }
public static void main(String[] args) {
MyType mt; // warning: MyType is a raw type
MyType.Inner inn; // warning: MyType.Inner is a raw type
MyType.Nested nest; // no warning: not parameterized type
MyType<Object> mt1; // no warning: type parameter given
MyType<?> mt2; // no warning: type parameter given (wildcard OK!)
}
}
Hier MyType<E>ist ein parametrisierter Typ ( JLS 4.5 ). Es ist üblich, diesen Typ umgangssprachlich als MyTypekurz zu bezeichnen, aber technisch ist der Name MyType<E>.
mthat einen Rohtyp (und generiert eine Kompilierungswarnung) durch den ersten Aufzählungspunkt in der obigen Definition; innhat auch einen rohen Typ durch den dritten Aufzählungspunkt.
MyType.Nestedist kein parametrisierter Typ, obwohl es sich um einen Elementtyp eines parametrisierten Typs handelt MyType<E>, weil dies der Fall ist static.
mt1und mt2werden beide mit tatsächlichen Typparametern deklariert, sodass es sich nicht um Rohtypen handelt.
Was ist das Besondere an rohen Sorten?
Im Wesentlichen verhalten sich Rohtypen genauso wie vor der Einführung von Generika. Das heißt, Folgendes ist zur Kompilierungszeit völlig legal.
List names = new ArrayList(); // warning: raw type!
names.add("John");
names.add("Mary");
names.add(Boolean.FALSE); // not a compilation error!
Der obige Code läuft einwandfrei, aber nehmen wir an, Sie haben auch Folgendes:
for (Object o : names) {
String name = (String) o;
System.out.println(name);
} // throws ClassCastException!
// java.lang.Boolean cannot be cast to java.lang.String
Jetzt stoßen wir zur Laufzeit auf Probleme, weil sie namesetwas enthalten, das kein ist instanceof String.
Vermutlich , wenn Sie wollen namesnur enthalten String, Sie könnten vielleicht noch eine rohe Art verwenden und manuell jeden überprüfen add sich selbst, und dann manuell geworfen zu Stringjedem Element aus names. Noch besser ist es jedoch , KEINEN Rohtyp zu verwenden und den Compiler die ganze Arbeit für Sie erledigen zu lassen , wobei die Leistung von Java-Generika genutzt wird.
List<String> names = new ArrayList<String>();
names.add("John");
names.add("Mary");
names.add(Boolean.FALSE); // compilation error!
Natürlich, wenn Sie DO wollen namesein erlauben Boolean, dann kann man es erklären , wieList<Object> names , und der obige Code würde kompilieren.
Siehe auch
Wie unterscheidet sich ein Rohtyp von der Verwendung <Object>als Typparameter?
Das Folgende ist ein Zitat aus Effective Java 2nd Edition, Punkt 23: Verwenden Sie keine Rohtypen in neuem Code :
Was ist der Unterschied zwischen dem Rohtyp Listund dem parametrisierten Typ List<Object>? Ersteres hat die generische Typprüfung deaktiviert, während letzteres dem Compiler ausdrücklich mitteilte, dass er Objekte aller Art aufnehmen kann. Während Sie a List<String>an einen Parameter vom Typ übergeben können List, können Sie es nicht an einen Parameter vom Typ übergeben List<Object>. Es gibt Subtypisierungsregeln für Generika und es List<String>handelt sich um einen Subtyp des Rohtyps List, jedoch nicht des parametrisierten Typs List<Object>. Infolgedessen verlieren Sie die Typensicherheit, wenn Sie einen rohen Typ wie verwenden List, aber nicht, wenn Sie einen parametrisierten Typ wie verwendenList<Object> .
Betrachten Sie zur Veranschaulichung des Punktes die folgende Methode, die a nimmt List<Object>und a anfügt new Object().
void appendNewObject(List<Object> list) {
list.add(new Object());
}
Generika in Java sind unveränderlich. A List<String>ist kein a List<Object>, daher würde Folgendes eine Compiler-Warnung generieren:
List<String> names = new ArrayList<String>();
appendNewObject(names); // compilation error!
Wenn Sie deklariert hätten appendNewObject, einen Rohtyp Listals Parameter zu verwenden, würde dies kompiliert, und Sie würden daher die Typensicherheit verlieren, die Sie von Generika erhalten.
Siehe auch
Wie unterscheidet sich ein Rohtyp von der Verwendung <?>als Typparameter?
List<Object>, List<String>Usw. sind alle List<?>, so dass es nur verlockend sein sagen , dass sie gerade sind , Liststatt. Es gibt jedoch einen großen Unterschied: Da nur a List<E>definiert ist add(E), können Sie einem nicht jedes beliebige Objekt hinzufügenList<?> . Auf der anderen Seite, da der Rohtyp Listkeine Typensicherheit hat, können Sie fast addalles zu einem List.
Betrachten Sie die folgende Variation des vorherigen Snippets:
static void appendNewObject(List<?> list) {
list.add(new Object()); // compilation error!
}
//...
List<String> names = new ArrayList<String>();
appendNewObject(names); // this part is fine!
Der Compiler hat Sie wunderbar davor geschützt, die Typinvarianz von List<?>! Wenn Sie den Parameter als Rohtyp deklariert habenList list hätten, würde der Code kompiliert und Sie würden die Typinvariante von verletzen List<String> names.
Ein Rohtyp ist das Löschen dieses Typs
Zurück zu JLS 4.8:
Es ist möglich, die Löschung eines parametrisierten Typs oder die Löschung eines Array-Typs als Typ zu verwenden, dessen Elementtyp ein parametrisierter Typ ist. Ein solcher Typ wird als Rohtyp bezeichnet .
[...]
Die Superklassen (bzw. Superschnittstellen) eines Rohtyps sind die Löschungen der Superklassen (Superschnittstellen) einer der Parametrisierungen des generischen Typs.
Der Typ eines Konstruktors, einer Instanzmethode oder eines Nichtfelds staticeines Rohtyps C, der nicht von seinen Oberklassen oder Superschnittstellen geerbt wird, ist der Rohtyp, der dem Löschen seines Typs in der entsprechenden generischen Deklaration entspricht C.
Einfacher ausgedrückt, wenn ein Roh - Typ verwendet wird, die Konstrukteure, Instanzmethoden und nicht staticsind Felder ebenfalls gelöscht .
Nehmen Sie das folgende Beispiel:
class MyType<E> {
List<String> getNames() {
return Arrays.asList("John", "Mary");
}
public static void main(String[] args) {
MyType rawType = new MyType();
// unchecked warning!
// required: List<String> found: List
List<String> names = rawType.getNames();
// compilation error!
// incompatible types: Object cannot be converted to String
for (String str : rawType.getNames())
System.out.print(str);
}
}
Wenn wir das Raw verwenden MyType, getNameswird es ebenfalls gelöscht, so dass es ein Raw zurückgibt List!
JLS 4.6 erklärt weiterhin Folgendes:
Beim Löschen von Typen wird auch die Signatur eines Konstruktors oder einer Methode einer Signatur zugeordnet, die keine parametrisierten Typen oder Typvariablen enthält. Das Löschen einer Konstruktor- oder Methodensignatur sist eine Signatur, die aus demselben Namen wie sund den Löschungen aller in angegebenen formalen Parametertypen besteht s.
Der Rückgabetyp einer Methode und die Typparameter einer generischen Methode oder eines generischen Konstruktors werden ebenfalls gelöscht, wenn die Signatur der Methode oder des Konstruktors gelöscht wird.
Das Löschen der Signatur einer generischen Methode hat keine Typparameter.
Der folgende Fehlerbericht enthält einige Gedanken von Maurizio Cimadamore, einem Compiler-Entwickler, und Alex Buckley, einem der Autoren des JLS, warum dieses Verhalten auftreten sollte: https://bugs.openjdk.java.net/browse / JDK-6400189 . (Kurz gesagt, dies vereinfacht die Spezifikation.)
Wenn es unsicher ist, warum darf es einen Rohtyp verwenden?
Hier ist ein weiteres Zitat aus JLS 4.8:
Die Verwendung von Rohtypen ist nur als Zugeständnis an die Kompatibilität von Legacy-Code zulässig. Von der Verwendung von Rohtypen in Code, der nach Einführung der Generizität in die Programmiersprache Java geschrieben wurde, wird dringend abgeraten. Es ist möglich, dass zukünftige Versionen der Programmiersprache Java die Verwendung von Rohtypen nicht zulassen.
Effektive Java 2nd Edition hat auch Folgendes hinzuzufügen:
Warum haben die Sprachdesigner sie zugelassen, da Sie keine Rohtypen verwenden sollten? Kompatibilität bieten.
Die Java-Plattform stand kurz vor dem Eintritt in das zweite Jahrzehnt, als Generika eingeführt wurden, und es gab eine enorme Menge an Java-Code, der keine Generika verwendete. Es wurde als kritisch erachtet, dass all dieser Code legal bleibt und mit neuem Code kompatibel ist, der Generika verwendet. Es musste legal sein, Instanzen parametrisierter Typen an Methoden zu übergeben, die für die Verwendung mit normalen Typen entwickelt wurden, und umgekehrt. Diese als Migrationskompatibilität bekannte Anforderung führte zur Entscheidung, Rohtypen zu unterstützen.
Zusammenfassend sollte der Rohtyp NIEMALS in neuem Code verwendet werden. Sie sollten immer parametrisierte Typen verwenden .
Gibt es keine Ausnahmen?
Da Java-Generika nicht reifiziert sind, gibt es leider zwei Ausnahmen, in denen Rohtypen in neuem Code verwendet werden müssen:
- Klassenliterale, zB
List.classnichtList<String>.class
instanceofOperand, zB o instanceof Setnichto instanceof Set<String>
Siehe auch