Was ist ein raw-type und warum sollten wir das nicht nutzen?

Was ist ein raw-Typ?

The Java Language Specification definiert ein raw-Typ wie folgt:

JLS 4.8 Raw-Typen

Einem raw-Typ definiert werden:

• Den Typ der Referenz, das gebildet wird, indem der name einer generischen Typ-Deklaration ohne ein begleitendes argument type Liste.

• Einen array-Typ, dessen Elementtyp ist ein raw-Typ.

• Nicht-static Typ Mitglied des raw-Typ R dass nicht von einer übergeordneten Klasse übernommenen oder superinterface von R.

Hier 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 parametrisierten Typ (JLS 4.5). Es ist üblich, in der Umgangssprache beziehen sich auf diese Art als einfach MyType für die kurze, aber technisch gesehen ist der name MyType<E>.

mt hat ein raw-Typ (und erzeugt Compilerwarnung) durch den ersten Punkt in der obigen definition; inn hat auch eine raw-Typ durch den Dritten Punkt.

MyType.Nested ist nicht ein parametrisierter Typ ist, obwohl er ein Mitglied der Typ von einem parametrisierten Typ MyType<E>, weil es static.

mt1, und mt2 sind beide erklärte mit den tatsächlichen Typ-Parameter, also sind Sie nicht raw-Typen.

---

Was ist so besonders an der raw-Typen?

Im wesentlichen raw-Typen verhält sich genau so, wie Sie waren, bevor generics eingeführt wurden. Das heißt, das folgende ist völlig legal zur compile-Zeit.

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 Prima, aber nehmen wir an, Sie haben auch die folgenden:

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 laufen wir in Probleme zur Laufzeit, weil names enthält etwas, das nicht ein instanceof String.

Vermutlich, wenn Sie wollen names enthalten nur String Sie könnte vielleicht immer noch mit einem rohen Art und manuell überprüfen, jeden add sich selbst, und dann manuell cast zu String jedes Element aus names. Noch besser, ist aber NICHT mit einem raw-Typ und lass den compiler die ganze Arbeit für Sie, die Nutzung der macht von Java generics.

List<String> names = new ArrayList<String>();
names.add("John");
names.add("Mary");
names.add(Boolean.FALSE); //compilation error!

Natürlich, wenn Sie TUN wollen names zu ermöglichen Boolean, dann können Sie deklarieren es als List<Object> names, und würde der obige code kompiliert.

Siehe auch

• Java Tutorials/Generika

---

Wie ein raw-Typ unterscheidet sich von dem verwenden <Object> als Typ-Parameter?

Das folgende ist ein Zitat aus Effektive Java, 2nd Edition, Artikel 23: keine raw-Typen im neuen code:

Nur was ist der Unterschied zwischen dem raw-Typ List und den parametrisierten Typ List<Object>? Grob gesagt, ist das erstere entschieden generischen Typ-Prüfung, während die letzteren ausdrücklich gesagt, der compiler, dass es ist fähig zum halten von Objekten beliebigen Typs. Zwar können Sie ein List<String> um einen parameter vom Typ List, Sie können nicht übergeben Sie es an einen parameter vom Typ List<Object>. Es gibt subtypisierung Regeln für Generika, und List<String> ist ein Subtyp der raw-Typ List, aber nicht von der parametrisierte Typ List<Object>. Als Folge verlieren Sie geben Sicherheit, wenn Sie raw-Typ, wie List, aber nicht, wenn Sie einen parametrisierten Typ wie List<Object>.

Um den Punkt zu illustrieren, betrachten die folgende Methode, die eine List<Object> und fügt ein new Object().

void appendNewObject(List<Object> list) {
   list.add(new Object());
}

Generics in Java invariant. Ein List<String> ist nicht ein List<Object>, also Folgendes erzeugen würde eine compiler-Warnung:

List<String> names = new ArrayList<String>();
appendNewObject(names); //compilation error!

Wenn Sie erklärt hatte, dass appendNewObject zu nehmen, ein raw-Typ List als parameter, dann wird diese zusammenstellen würde, und man würde Sie verlieren deshalb die Art der Sicherheit, die Sie von Generika.

Siehe auch

• Was ist der Unterschied zwischen <E extends Number> und <Number>?
• java generics (nicht) Kovarianz

---

Wie ein raw-Typ unterscheidet sich von dem verwenden <?> als Typ-parameter?

List<Object> , List<String> usw sind alle List<?> ist, so kann es verlockend sein, einfach nur zu sagen, dass Sie nur List statt. Es gibt jedoch einen wichtigen Unterschied: da eine List<E> definiert nur add(E), Sie können nicht fügen Sie einfach jedes beliebige Objekt zu einem List<?>. Auf der anderen Seite, da der raw-Typ List nicht haben, geben Sicherheit, Sie können add nur über alles, was zu einem List.

Betrachten Sie die folgende Variante des vorhergehenden Codeausschnitt:

static void appendNewObject(List<?> list) {
    list.add(new Object()); //compilation error!
}
//...

List<String> names = new ArrayList<String>();
appendNewObject(names); //this part is fine!

Den compiler haben eine wunderbare Arbeit und schützt Sie vor potenziell Verletzung der Typ Invarianz der List<?>! Wenn Sie erklärt hatte, dass die parameter der raw-Typ List list, dann würde der code kompilieren, und Sie würden gegen die Typ-Invarianten von List<String> names.

---

Ein raw type ist die Löschung von dieser Art

Zurück zu JLS 4.8:

Ist es möglich, als eine Art die Löschung von einem parametrisierten Typ oder die Löschung von einem array-Typ, dessen Elementtyp ist ein parametrisierter Typ. So ein Typ genannt wird raw-Typ.

[...]

Den Oberklassen (bzw. superinterfaces) von einem raw-Typ sind die Radierungen der Superklassen (superinterfaces) von keiner der Parametrisierungen des generischen Typs.

Den Typ eines Konstruktors, Instanz, Methode, oder nicht-static Bereich des raw-Typ C ist nicht geerbt von Ihrer Superklassen oder superinterfaces ist der raw-Typ, entspricht der Löschung seiner Art in die generische Deklaration der entsprechenden C.

In einfacheren Worten, wenn ein raw-Typ verwendet wird, werden die Konstruktoren, Methoden einer Instanz und nicht-static Felder sind auch 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 den raw -MyType, getNames wird gelöscht, so dass es gibt ein raw -List!

JLS 4.6 weiterhin erklären die folgenden:

Type erasure auch die Karten die Signatur eines Konstruktors oder der Methode mit einer Signatur, der keine parametrisierten Typen oder Variablen-Typen. Die Löschung eines Konstruktors oder der Methode, Unterschrift s ist eine Signatur, die aus denselben Namen wie s und die Radierungen von all den formalen Parametertypen in s.

Der Rückgabetyp der Methode und die Art Parameter einer generischen Methode oder Konstruktor auch durchmachen Löschung, wenn die Methode oder der Konstruktor der Signatur gelöscht.

Die Löschung der Signatur einer generischen Methode hat keine Typ-Parameter.

Den folgenden bug-report enthält einige Gedanken von Maurizio Cimadamore, einen compiler dev, und Alex Buckley, einer der Autoren der JLS, über das warum diese Art von Verhalten sollte auftreten: https://bugs.openjdk.java.net/browse/JDK-6400189. (Kurz gesagt, es macht die Spezifikation einfacher.)

---

Wenn es unsicher ist, warum ist es erlaubt, ein raw-Typ?

Hier ist ein weiteres Zitat von JLS 4.8:

Die Verwendung von raw-Arten zulässig nur als ein Zugeständnis an die Kompatibilität von legacy-code. Die Verwendung von raw-Typen im code geschrieben, nach der Einführung des genericity in die Java-Programmiersprache, wird dringend abgeraten. Es ist möglich, dass zukünftige Versionen der Programmiersprache Java wird verbieten die Verwendung von raw-Typen.

Effektive Java 2nd Edition auch noch diese hinzufügen:

Gegeben, dass Sie sollten nicht verwenden Sie raw-types, warum die Sprache der Designer, die es Ihnen erlauben? Um Kompatibilität zu gewährleisten.

Die Java-Plattform wurde in seine zweite Dekade, wenn die generics eingeführt wurden, und es gab eine enorme Menge von Java-code bestehen, nicht verwenden Generika. Es wurde als wichtig, dass alle dieser code bleibt legal und kompatibel mit neuen code, der bedeutet, dass Generika verwendet werden. Es mußte sein, um legal zu übergeben Instanzen von parametrisierten Typen, Methoden wurden entwickelt für den Einsatz mit gewöhnlichen Typen, und Umgekehrt. Diese Anforderung, bekannt als migration Kompatibilität, fuhr die Entscheidung zur Unterstützung der raw-Typen.

In der Zusammenfassung, raw-Typen sollten NIE benutzt werden, in die der neue code. Sie sollten immer die Verwendung von parametrisierten Typen.

---

Gibt es keine Ausnahmen?

Leider, weil die Java-generics sind nicht-verdinglicht, es gibt zwei Ausnahmen, bei denen raw-Typen verwendet werden muss, in die der neue code:

• Class-Literale, z.B. List.class, nicht List<String>.class
• instanceof Operanden, z.B. o instanceof Set, nicht o instanceof Set<String>

Siehe auch

• Warum ist Collection<String>.class Illegal?

InformationsquelleAutor polygenelubricants

Einem raw-type ist der name einer generischen Klasse oder interface ohne Typ-Argumente. Zum Beispiel, angesichts der generischen Klasse Box:

public class Box<T> {
    public void set(T t) { /* ... */ }
    //...
}

Zum erstellen eines parametrisierten Typ von Box<T> liefern Sie eine tatsächliche typargument für den formalen Typ-parameter T:

Box<Integer> intBox = new Box<>();

Wenn der tatsächliche Typ-argument weggelassen wird, erstellen Sie eine rohe Art von Box<T>:

Box rawBox = new Box();

Daher Box ist der raw-type des generischen Typs Box<T>. Jedoch, eine nicht-generische Klasse oder ein interface ist nicht ein raw-Typ.

Raw-Typen zeigen, bis in legacy-code, da viele API-Klassen (wie z.B. die Collections-Klassen) wurden nicht generisch vor JDK 5.0. Bei der Verwendung von raw types, Sie im wesentlichen erhalten pre-Generika-Verhalten — eine Box gibt Sie Objects. Für die Abwärtskompatibilität, die Zuweisung eines parametrisierten Typ an seine roh geben darf:

Box<String> stringBox = new Box<>();
Box rawBox = stringBox;               //OK

Aber wenn Sie zuweisen eine raw-Typ, um einen parametrisierten Typ, erhalten Sie eine Warnung:

Box rawBox = new Box();           //rawBox is a raw type of Box<T>
Box<Integer> intBox = rawBox;     //warning: unchecked conversion

Erhalten Sie auch eine Warnung, wenn Sie ein raw geben Sie zum aufrufen von generischen Methoden definiert, die in den entsprechenden generischen Typ:

Box<String> stringBox = new Box<>();
Box rawBox = stringBox;
rawBox.set(8);  //warning: unchecked invocation to set(T)

Die Warnung zeigt, dass die raw-Typen umgehen generischen Typ prüft, verzögern den Fang von unsicherem code zur Laufzeit. Daher sollten Sie vermeiden, mit raw-Typen.

Dem Typ Erasure Abschnitt hat mehr Informationen darüber, wie der Java-compiler verwendet raw-Typen.

Deaktiviert Fehlermeldungen

Wie bereits erwähnt, beim mischen von legacy code mit generischen code, stoßen Sie möglicherweise Warnmeldungen ähnlich der folgenden:

Hinweis: Example.java verwendet, deaktiviert oder unsichere Vorgänge.

Note: Recompile with-Xlint:unchecked for details.

Dies kann passieren, wenn eine ältere API, die arbeitet auf raw-Typen, wie im folgenden Beispiel gezeigt:

public class WarningDemo {
    public static void main(String[] args){
        Box<Integer> bi;
        bi = createBox();
    }

    static Box createBox(){
        return new Box();
    }
}

Der Begriff "deaktiviert" bedeutet, dass der compiler nicht genügend Informationen geben, um alle typüberprüfungen notwendig, um sicherzustellen, geben Sicherheit. Die "unchecked" - Warnung ist deaktiviert, standardmäßig, aber der compiler gibt einen Hinweis. Um zu sehen, alle "unchecked" - Warnungen, recompile with-Xlint:unchecked.

Neukompilierung des vorherigen Beispiels mit -Xlint:unchecked zeigt die folgenden zusätzlichen Informationen:

WarningDemo.java:4: warning: [unchecked] unchecked conversion
found   : Box
required: Box<java.lang.Integer>
        bi = createBox();
                      ^
1 warning

Komplett deaktivieren deaktiviert Warnungen, verwenden Sie den-Xlint:-ungeprüfter Flagge. Die @SuppressWarnings("unchecked") annotation unterdrückt unchecked-Warnungen. Wenn Sie nicht vertraut sind mit der @SuppressWarnings syntax, siehe Anmerkungen.

Original-Quelle: Java Tutorials

InformationsquelleAutor Adelin

Einem "raw" - Datentyp in Java ist eine Klasse, die nicht-generische und beschäftigt sich mit dem "roh" - Objekte, sondern als typsichere generische Typ-Parameter.

Beispielsweise vor den Java-generics zur Verfügung, die Sie verwenden würden, eine collection-Klasse so:

LinkedList list = new LinkedList();
list.add(new MyObject());
MyObject myObject = (MyObject)list.get(0);

Wenn Sie fügen Sie Ihre Objekt auf der Liste, es ist nicht egal, welche Art von Objekt es sich handelt, und, wenn man es von der Liste, müssen Sie explizit casten auf den Typ, den Sie erwarten.

Die Verwendung von Generika, entfernen Sie das "unbekannte" Faktor, da müssen Sie explizit angeben, welche Art von Objekten kann in der Liste:

LinkedList<MyObject> list = new LinkedList<MyObject>();
list.add(new MyObject());
MyObject myObject = list.get(0);

Beachten Sie, dass mit Generika, die Sie nicht haben, um CASTET das Objekt aus der get-Aufruf, die Sammlung ist bereits definiert, nur mit MyObject. Diese Tatsache ist der wichtigste treibende Faktor für Generika. Es ändert sich eine Quelle von runtime-Fehlern, die in etwas, das kann überprüft werden bei der Kompilierung.

InformationsquelleAutor Andy White

Was ist ein raw-type und warum ich oft zu hören, dass Sie nicht verwendet werden sollte im neuen code?

Einem "raw-type" ist die Verwendung einer generischen Klasse ohne Angabe eines argument type(s) für den parametrisierten Typ(en), z.B. mit List statt List<String>. Wenn generics wurden in Java mehrere Klassen aktualisiert wurden, verwenden Generika. Die Verwendung dieser Klasse wie ein "raw type" (ohne Angabe eines Typ-argument) erlaubt, legacy-code noch kompilieren.

"Raw types" verwendet werden, für die rückwärts Kompatibilität. Ihre neue code wird nicht empfohlen, da durch die Verwendung der generischen Klasse mit einem typargument ermöglicht eine stärkere Typisierung, was wiederum verbessern die code-Verständlichkeit und führen zu fangen potenzielle Probleme früher.

Was ist die alternative, wenn wir nicht verwenden können raw-Typen, und wie geht es besser?

Der am günstigsten gelegene alternative ist die Verwendung von generischen Klassen wie vorgesehen - mit einem geeigneten argument Typ (z.B. List<String>). Dies ermöglicht es dem Programmierer, um die Angabe von Typen genauer gesagt, vermittelt mehr Bedeutung für zukünftige maintainer über den Verwendungszweck einer variable oder Datenstruktur, und es ermöglicht dem compiler zu erzwingen, besser Typ-Sicherheit. Diese Vorteile zusammen können der Verbesserung der code-Qualität und verhindern, dass die Einführung von einige coding Fehler.

Beispielsweise für eine Methode, wenn der Programmierer will, um sicherzustellen, eine Liste variable namens 'Namen' enthält nur Zeichenfolgen:

List<String> names = new ArrayList<String>();
names.add("John");          //OK
names.add(new Integer(1));  //compile error

InformationsquelleAutor Bert F

Einen raw-Typ ist die fehlende type-parameter bei der Verwendung von generischen Typen.

Raw-Typ sollte nicht verwendet werden, da könnte es zu einem Laufzeitfehler führen, wie das einsetzen einer double in das, was sein sollte, war ein Set von ints.

Set set = new HashSet();
set.add(3.45); //ok

Beim abrufen der Stoff, aus dem Set Sie nicht wissen, was da raus kommt. Nehmen wir an, dass Sie erwarten, dass es alle ints, sind Sie Gießen es Integer; exception zur Laufzeit, wenn die double 3.45 kommt.

Mit einem type-parameter Hinzugefügt, um Ihre Set erhalten Sie einen compile-Fehler auf einmal. Diese preemptive Fehler können Sie beheben das problem, bevor etwas explodiert während der Laufzeit (und damit die Einsparung von Zeit und Aufwand).

Set<Integer> set = new HashSet<Integer>();
set.add(3.45); //NOT ok.

InformationsquelleAutor Lars Andren

Was sagt, ist, dass Ihre list ist ein List von unespecified Objekte. Das ist, dass Java nicht weiß, welche Art von Gegenständen sind in der Liste. Dann, wenn Sie Durchlaufen die Liste, die Sie haben zu werfen jedes element, um Zugriff auf die Eigenschaften des Elements (in diesem Fall String).

Im Allgemeinen ist es eine bessere Idee einstellen, die Sammlungen, so dass Sie nicht haben, Konvertierung Probleme auftreten, werden Sie nur in der Lage sein, um Elemente hinzuzufügen oder Elemente der parametrisierten Typ und Ihrem editor bieten Ihnen auch den passenden Methoden zu wählen.

private static List<String> list = new ArrayList<String>();

InformationsquelleAutor pakore

Ich diese Seite gefunden nachdem ich einige Beispiel-übungen und mit der exakt gleichen Verwirrung.

============== Ich ging aus dieser code-wie bieten von der Probe ===============

public static void main(String[] args) throws IOException {

    Map wordMap = new HashMap();
    if (args.length > 0) {
        for (int i = 0; i < args.length; i++) {
            countWord(wordMap, args[i]);
        }
    } else {
        getWordFrequency(System.in, wordMap);
    }
    for (Iterator i = wordMap.entrySet().iterator(); i.hasNext();) {
        Map.Entry entry = (Map.Entry) i.next();
        System.out.println(entry.getKey() + " :\t" + entry.getValue());
    }

====================== Dieser code ========================

public static void main(String[] args) throws IOException {
    //replace with TreeMap to get them sorted by name
    Map<String, Integer> wordMap = new HashMap<String, Integer>();
    if (args.length > 0) {
        for (int i = 0; i < args.length; i++) {
            countWord(wordMap, args[i]);
        }
    } else {
        getWordFrequency(System.in, wordMap);
    }
    for (Iterator<Entry<String, Integer>> i = wordMap.entrySet().iterator(); i.hasNext();) {
        Entry<String, Integer> entry =   i.next();
        System.out.println(entry.getKey() + " :\t" + entry.getValue());
    }

}

===============================================================================

Es ist möglicherweise sicherer, aber dauerte 4 Stunden demuddle der Philosophie...

InformationsquelleAutor user2442615

Vermeiden Sie raw-types

Raw-Typen beziehen sich auf die Verwendung eines generischen Typs ohne Angabe eines type-Parameters.

Zum Beispiel,

Einer Liste ist ein raw-Typ, während List<String> ist ein parametrisierter Typ.

Wenn Generika eingeführt wurden in JDK 1.5, raw-Typen wurden beibehalten, nur um die Abwärtskompatibilität mit älteren Versionen von Java. Obwohl die Verwendung von raw types ist immer noch möglich,

Sie vermieden werden sollten,:

• Sie erfordern in der Regel wirft
• Sie sind nicht typsicher, und einige wichtige Arten von Fehler wird nur angezeigt, zur Laufzeit

• Sind Sie weniger ausdrucksstark, und nicht selbst-Dokument in der gleichen Weise wie die parametrisierten Typen
  Beispiel

  import java.util.*;
  
  public final class AvoidRawTypes {
  
  void withRawType() {
  
      //Raw List doesn't self-document, 
      //doesn't state explicitly what it can contain
  
      List stars = Arrays.asList("Arcturus", "Vega", "Altair");
  
      Iterator iter = stars.iterator();
  
      while (iter.hasNext()) {
  
          String star = (String) iter.next(); //cast needed
  
          log(star);
      }
  
  }
  
  void withParameterizedType() {
  
      List < String > stars = Arrays.asList("Spica", "Regulus", "Antares");
  
      for (String star: stars) {
  
          log(star);
      }
  
  }
  
  private void log(Object message) {
  
      System.out.println(Objects.toString(message));
  
  }
  
  }

Referenz: https://docs.oracle.com/javase/tutorial/java/generics/rawTypes.html

InformationsquelleAutor ashish