Che cosa è un raw tipo e perché non dovremmo usare?

Domande:

  • Quali sono le materie tipi in Java, e perché mi capita spesso di sentire che essi non dovrebbero essere utilizzati nel nuovo codice?
  • Qual è l’alternativa se non siamo in grado di utilizzare materie prime tipologie, e come è meglio?
java tutorial di utilizzare ancora il JComboBox che sono le cause di questo avviso. Che versione del componente combobox non causa questo avviso ? docs.oracle.com/javase/tutorial/uiswing/components/…
Nota che il motivo per cui raw tipi di esistere è per la compatibilità con Java 1.4 e precedenti, che non sono generici.

OriginaleL’autore polygenelubricants | 2010-05-05

14 Replies
  1. 640

    Che cosa è un raw tipo?

    La Specifica del Linguaggio Java definisce un raw tipo come segue:

    JLS 4.8 Raw Tipi

    Un raw tipo è definito per essere uno di questi:

    • Il tipo di riferimento che è formata da prendere il nome di una dichiarazione del tipo generico senza accompagnamento di un argomento di tipo lista.

    • Un tipo di matrice il cui elemento è di tipo raw tipo.

    • Nonstatic tipo di membro di un raw tipo R che non è ereditato dalla superclasse o superinterface di R.

    Ecco un esempio:

    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!)
        }
    }

    Qui, MyType<E> è un con parametri di tipo (JLS 4.5). È comune colloquialmente si riferiscono a questo tipo di semplicemente MyType per breve, ma tecnicamente il nome è MyType<E>.

    mt cruda tipo (e genera una compilation di avviso) per il primo punto la definizione di cui sopra; inn anche cruda tipo il terzo punto.

    MyType.Nested non è un tipo parametrizzato, anche se è un tipo di membro di un tipo parametrizzato MyType<E>, perché è static.

    mt1, e mt2 sono dichiarati effettivi parametri di tipo, quindi non sono raw tipi.


    Cosa c’è di così speciale raw tipi?

    Essenzialmente, raw tipi si comporta esattamente come erano prima i generics sono stati introdotti. Che è, il seguente è interamente legale a tempo di compilazione.

    List names = new ArrayList(); //warning: raw type!
    names.add("John");
    names.add("Mary");
    names.add(Boolean.FALSE); //not a compilation error!

    Il codice sopra funziona bene, ma si supponga, inoltre, sono i seguenti:

    for (Object o : names) {
        String name = (String) o;
        System.out.println(name);
    } //throws ClassCastException!
      //   java.lang.Boolean cannot be cast to java.lang.String

    Ora ci troviamo in difficoltà in fase di esecuzione, perché names contiene qualcosa che non è un instanceof String.

    Presumibilmente, se si desidera names per contenere solo String, si potrebbe forse ancora utilizzare un tipo raw e controllare manualmente ogni add di te, e quindi manualmente cast per String ogni elemento da names. Ancora meglio, anche se NON è l’uso di un tipo raw e consentire al compilatore di fare tutto il lavoro per voi, sfruttando la potenza di Java generics.

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

    Naturalmente, se si FARE desidera names per consentire un Boolean, quindi si può dichiarare come List<Object> names, e il codice di cui sopra potrebbe compilare.

    Vedere anche


    Come un raw di tipo diverso dall’utilizzo di <Object> come parametri di tipo?

    La seguente è una citazione da Efficace Java 2 ° Edizione, Voce 23: non utilizzare materie prime tipi nel nuovo codice:

    Solo qual è la differenza tra le materie di tipo List e con parametri di tipo List<Object>? In parole povere, l’ex ha scelto di generico tipo di controllo, mentre il secondo esplicitamente detto il compilatore è in grado di contenere oggetti di qualsiasi tipo. Mentre è possibile passare un List<String> di un parametro di tipo List, si può passare a un parametro di tipo List<Object>. Ci sono sottotipizzazione regole per i generici, e List<String> è un sottotipo di materie prime di tipo List, ma non del tipo parametrizzato List<Object>. Come conseguenza, si perde tipo di sicurezza in caso di uso a crudo, come tipo di List, ma non se si utilizza un tipo parametrizzato come List<Object>.

    Per illustrare il punto, si consideri il seguente metodo, che prende un List<Object> e aggiunge un new Object().

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

    Generics in Java sono in inglese. Un List<String> non è un List<Object>, quindi, il seguente dovrebbe generare un avviso del compilatore:

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

    Se si fosse dichiarato appendNewObject di prendere un raw tipo List come parametro, allora questo sarebbe compilare, e sarebbe quindi di perdere il tipo di sicurezza che si ottiene da generics.

    Vedere anche


    Come un raw di tipo diverso dall’utilizzo di <?> come un parametro di tipo?

    List<Object>, List<String>, ecc sono tutti List<?>, quindi potrebbe essere tentati di dire che sono solo List invece. Tuttavia, c’è una grande differenza: da un List<E> definisce solo add(E), non è possibile aggiungere qualsiasi oggetto arbitrario di un List<?>. D’altra parte, dal momento che il raw tipo List non sono il tipo di sicurezza, è possibile add qualsiasi cosa per un List.

    Considerare la seguente variazione del frammento precedente:

    static void appendNewObject(List<?> list) {
        list.add(new Object()); //compilation error!
    }
    //...
    
    List<String> names = new ArrayList<String>();
    appendNewObject(names); //this part is fine!

    Il compilatore ha fatto un ottimo lavoro di proteggere potenzialmente violare il tipo di invarianza della List<?>! Se si fosse dichiarato il parametro raw tipo List list, il codice compilato, e si sarebbe violare il tipo di invariante di List<String> names.


    Un raw tipo è la cancellazione di quel tipo

    Torna a JLS 4.8:

    È possibile utilizzare come tipo di la cancellazione di un tipo parametrizzato o la cancellazione di una matrice il cui elemento tipo è un tipo parametrizzato. Tale tipo è chiamato un raw tipo.

    […]

    Le superclassi (rispettivamente, superinterfaces) di un raw tipo sono le cancellature di superclassi (superinterfaces) di una qualsiasi delle parametrizzazioni di tipo generico.

    Il tipo di un costruttore, un metodo di istanza, o nonstatic campo di un raw tipo C che non è ereditato dalle sue superclassi o superinterfaces grezzi tipo che corrisponde alla cancellazione del suo tipo nel generica dichiarazione corrispondente alla C.

    In termini più semplici, quando un raw viene utilizzato il tipo, costruttori, metodi di istanza e nonstatic campi sono cancellati anche.

    Prendiamo il seguente esempio:

    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);
        }
    }

    Quando si usa il raw MyType, getNames diventa cancellati, in modo che restituisca un raw List!

    JLS 4.6 continua a spiegare i seguenti:

    Tipo di cancellazione anche le mappe con la firma di un costruttore o di un metodo per una firma che non ha tipi con parametri o variabili di tipo. La cancellazione di un costruttore o di un metodo firma s è una firma, costituito dallo stesso nome s e le cancellature di tutti i parametri formali di tipi di dato in s.

    Il tipo di ritorno di un metodo e il tipo di parametri di un metodo generico o il costruttore, inoltre, sottoposti a cancellazione se il metodo o il costruttore di firma, è stato cancellato.

    La cancellazione della firma di un generico metodo non ha alcun tipo di parametri.

    I seguenti bug report contiene alcuni pensieri da Maurizio Cimadamore, un compilatore dev, e Alex Buckley, uno degli autori della JLS, perché questo tipo di comportamento deve verificarsi: https://bugs.openjdk.java.net/browse/JDK-6400189. (In breve, rende la specifica più semplice.)


    Se è pericoloso, perché è consentito l’utilizzo di un raw tipo?

    Ecco un’altra citazione da JLS 4.8:

    L’impiego di materie prime tipi è consentito solo come una concessione per la compatibilità del codice legacy. L’impiego di materie prime tipi di codice scritto dopo l’introduzione della programmazione generica in linguaggio di programmazione Java è fortemente sconsigliato. È possibile che le future versioni del linguaggio di programmazione Java non consentire l’impiego di materie prime tipi.

    Efficace Java 2 ° Edizione ha anche questo di aggiungere:

    Dato che non si deve utilizzare materie prime tipi, perché la lingua designer consentire loro? Per garantire la compatibilità.

    La piattaforma Java, stava per entrare nella sua seconda decade quando i generics sono stati introdotti, e c’era un’enorme quantità di codice Java in esistenza, che non hanno fatto uso di farmaci generici. Si è ritenuto di fondamentale importanza che tutti questo codice rimane legale e interoperabile con il nuovo codice che fa uso di farmaci generici. Doveva essere consentito il passaggio di istanze di tipi con parametri ai metodi che sono stati progettati per l’utilizzo con i tipi ordinari, e viceversa. Questo requisito, noto come migrazione di compatibilità, ha guidato la decisione di supporto raw tipi.

    In sintesi, tipi di raw non dovrebbe MAI essere utilizzato nel nuovo codice. Si dovrebbe sempre utilizzare parametri di tipi.


    Non ci sono eccezioni?

    Purtroppo, a causa generics Java non sono reified, ci sono due eccezioni in cui raw tipi deve essere utilizzato nel nuovo codice:

    • Classe letterali, ad esempio,List.class, non List<String>.class
    • instanceof operando, ad esempio,o instanceof Set, non o instanceof Set<String>

    Vedere anche

    Cosa vuoi dire che, “generics Java non sono reified”?
    Per la seconda eccezione, la sintassi o instanceof Set<?> è consentito, inoltre, di evitare il raw tipo (anche se è solo superficiale, in questo caso).
    /me Lento e applaude alla fine della risposta
    “Non reified” è un altro modo per dire che si sono cancellati. Il compilatore sa quali sono i parametri generici sono, ma questa informazione non è passato il bytecode generato. I JLS richiede che la classe di valori letterali non hanno nessun tipo di parametri.
    Interessante. Voglio dire ufficialmente è nessuno, perché una classe letterale definito come appena TypeName.class, dove TypeName è una semplice identificatore (jls). Parlando ipoteticamente, credo che potrebbe davvero essere. Forse un indizio, List<String>.class è la variante che il JLS specificamente chiama un errore del compilatore, in modo che se mai aggiungere la lingua mi sarei aspettato che è quello che uso.

    OriginaleL’autore polygenelubricants

  2. 50

    Quali sono le materie tipi in Java, e perché mi capita spesso di sentire che essi non dovrebbero essere utilizzati nel nuovo codice?

    Raw-tipi di storia antica del linguaggio Java. All’inizio c’erano Collections e hanno tenuto Objects niente di più e niente di meno. Ogni operazione sul Collections richiesto calchi di Object per il tipo desiderato.

    List aList = new ArrayList();
    String s = "Hello World!";
    aList.add(s);
    String c = (String)aList.get(0);

    Mentre questo ha lavorato la maggior parte del tempo, gli errori accaduto

    List aNumberList = new ArrayList();
    String one = "1";//Number one
    aNumberList.add(one);
    Integer iOne = (Integer)aNumberList.get(0);//Insert ClassCastException here

    Vecchio typeless collezioni non ha potuto far valere il tipo di sicurezza in modo che il programmatore doveva ricordare ciò che ha memorizzato all’interno di una collezione.

    Farmaci generici dove inventato per ovviare a questa limitazione, lo sviluppatore avrebbe dichiarato la stored tipo una volta il compilatore dovrebbe fare, invece.

    List<String> aNumberList = new ArrayList<String>();
    aNumberList.add("one");
    Integer iOne = aNumberList.get(0);//Compile time error
    String sOne = aNumberList.get(0);//works fine

    Per Il Confronto:

    //Old style collections now known as raw types
    List aList = new ArrayList(); //Could contain anything
    //New style collections with Generics
    List<String> aList = new ArrayList<String>(); //Contains only Strings

    Più complesso il Compareable interfaccia:

    //raw, not type save can compare with Other classes
    class MyCompareAble implements CompareAble
    {
       int id;
       public int compareTo(Object other)
       {return this.id - ((MyCompareAble)other).id;}
    }
    //Generic
    class MyCompareAble implements CompareAble<MyCompareAble>
    {
       int id;
       public int compareTo(MyCompareAble other)
       {return this.id - other.id;}
    }

    Nota che è impossibile attuare il CompareAble interfaccia con compareTo(MyCompareAble) con crudo di tipi.
    Perché non si deve usare:

    • Qualsiasi Object memorizzati in un Collection deve essere lanciato prima di poter essere utilizzato
    • Utilizzo di farmaci generici consente la compilazione, controlli
    • Utilizzo di materie prime tipi è la stessa come la memorizzazione di ogni valore come Object

    Che il compilatore:
    I farmaci generici sono compatibili, usano le stesse classi java raw tipi. La magia accade soprattutto in fase di compilazione.

    List<String> someStrings = new ArrayList<String>();
    someStrings.add("one");
    String one = someStrings.get(0);

    Verrà compilato come:

    List someStrings = new ArrayList();
    someStrings.add("one"); 
    String one = (String)someStrings.get(0);

    Questo è il codice stesso si può scrivere se si è usato il raw direttamente. Pensiero, io non sono sicuro di quello che accade con il CompareAble interfaccia, credo che si crea due compareTo funzioni, uno che prende un MyCompareAble e l’altro l’assunzione di un Object e passando per il primo dopo la fusione.

    Quali sono le alternative a raw tipi: Utilizzare generics

    OriginaleL’autore josefx

  3. 22

    Un raw tipo è il nome di una generica classe o interfaccia, senza alcun tipo di argomenti. Per esempio, data la Casella generica classe:

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

    Per creare un tipo parametrizzato di Box<T>, è fornire un effettivo tipo di argomento per la formale parametro di tipo T:

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

    Se il tipo effettivo argomento viene omesso, si crea un raw tipo di Box<T>:

    Box rawBox = new Box();

    Pertanto, Box grezzi tipo di tipo generico Box<T>. Tuttavia, non generica classe o interfaccia non è un tipo di tipo raw.

    Raw tipi di mostrare fino in codice legacy, perché un sacco di classi di API (come per esempio le Collezioni di classi) non sono state generico prima del JDK 5.0. Quando l’utilizzo di materie prime di vario tipo, essenzialmente ottenere la pre-generics comportamento — un Box ti dà Objects. Per la compatibilità, l’assegnazione di un tipo parametrizzato per la sua cruda tipo è consentito:

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

    Ma se si assegna un raw tipo di un tipo parametrizzato, si ottiene un avvertimento:

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

    Si ottiene anche un messaggio di avviso se si utilizza un raw tipo di invocare metodi generici definito il corrispondente generico, tipo:

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

    L’avviso indica che i raw tipi di bypass generico tipo di controlli, rimandando la cattura di pericolosi codice a runtime. Pertanto, si dovrebbe evitare l’utilizzo di materie prime tipi.

    Il Tipo di Cancellazione sezione ha ulteriori informazioni su come il compilatore Java utilizza raw tipi.

    Deselezionata Messaggi Di Errore

    Come accennato in precedenza, quando la miscelazione di codice legacy con il codice generico, si possono incontrare i messaggi di avviso analogo al seguente:

    Nota: Example.java gli usi non controllato o non sicuri operazioni.

    Nota: Ricompilazione con -Xlint:non controllato per i dettagli.

    Questo può accadere quando si utilizza un vecchio API che opera sul raw tipi, come mostrato nel seguente esempio:

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

    Il termine “unchecked” significa che il compilatore non è sufficiente digitare le informazioni per eseguire tutti i tipi di controlli necessari per garantire la sicurezza del tipo. “Unchecked” l’avviso è disabilitato per impostazione predefinita, se il compilatore dà un suggerimento. Per vedere tutte le “unchecked” avvertimenti, ricompilare con -Xlint:non controllato.

    Ricompilare l’esempio precedente con -Xlint:non controllato rivela le seguenti informazioni aggiuntive:

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

    Per disattivare completamente incontrollato avvisi, utilizzare l’-Xlint:-unchecked bandiera. Il @SuppressWarnings("unchecked") annotazione sopprime deselezionata avvertenze. Se non hai familiarità con il @SuppressWarnings sintassi, vedere le Annotazioni.

    Fonte originale: Java Tutorial

    OriginaleL’autore Adelin

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

    Si deve specificare il tipo di parametro.

    L’avviso informa che i tipi che sono definiti a sostenere generics dovrebbe essere parametrizzata, piuttosto che utilizzando la loro forma grezza.

    List è definito con il supporto di farmaci generici: public class List<E>. Questo permette a molti tipi di operazioni, che vengono controllati in fase di compilazione.

    Ora sostituito da diamante inferenza in Java 7 — private static List<String> list = new ArrayList<>();

    OriginaleL’autore Bozho

  5. 14

    Un “raw” tipo in Java è una classe che non è generico e si occupa di “raw” di Oggetti, piuttosto che di tipo sicuro di parametri di tipo generico.

    Per esempio, prima di Java generics è disponibile, utilizzare una collezione di classe come questo:

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

    Quando si aggiungere l’oggetto alla lista, non importa quale tipo di oggetto, e quando lo si ottiene dall’elenco, è necessario eseguire il cast al tipo che ti aspetti.

    Utilizzo di farmaci generici, è possibile rimuovere il “sconosciuto” fattore, perché è necessario specificare che tipo di oggetti si può andare in lista:

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

    Notare che con i farmaci generici non è necessario eseguire il cast dell’oggetto proveniente dalla chiamata, la collezione pre-definito di lavorare solo con MyObject. Questo fatto è il principale fattore trainante per i generici. Cambia una fonte di errori di runtime in qualcosa che può essere controllato in fase di compilazione.

    Più specificamente, un crudo tipo è quello che si ottiene quando si è sufficiente omettere il tipo di parametri di tipo generico. Raw tipi erano davvero sempre e solo una retro-compatibilità caratteristica, e sono potenzialmente soggetti a rimozione. È possibile ottenere un comportamento simile ? jolly parametri.
    simili ma diversi! Utilizzando ? ancora offre il tipo di sicurezza. Ho coperto nella mia risposta.

    OriginaleL’autore Andy White

  6. 10

    Che cosa è un raw tipo e perché mi capita spesso di sentire che essi non dovrebbero essere utilizzati nel nuovo codice?

    Un “grezzo tipo” è l’uso di una classe generica senza specificare un argomento di tipo(s) per il suo tipo parametrizzato(s), ad esempio utilizzando List invece di List<String>. Quando i farmaci generici sono stati introdotti in Java, alcune classi sono state aggiornate per l’utilizzo dei farmaci generici. Utilizzando questi classe come “raw” (senza specificare il tipo di argomento) ha permesso di codice legacy ancora compilare.

    “Raw” tipi sono utilizzati per la compatibilità all’indietro. Il loro uso nel nuovo codice non è raccomandato in quanto utilizzando la classe generica con un argomento di tipo permette più forte di battitura, che a sua volta può migliorare la comprensibilità del codice e portare alla cattura di potenziali problemi precedenti.

    Qual è l’alternativa se non siamo in grado di utilizzare materie prime tipologie, e come è meglio?

    Preferito alternativa è quella di utilizzare le classi generiche come previsto – con un adeguato tipo di argomento (ad esempio List<String>). Questo permette al programmatore di specificare i tipi più specificamente, trasmette più significato per i futuri manutentori circa la destinazione d’uso di una variabile o di una struttura di dati, e permette al compilatore di applicare meglio il tipo di sicurezza. Questi vantaggi insieme possono migliorare la qualità del codice e aiutare a prevenire l’introduzione di alcuni errori di codifica.

    Per esempio, per un metodo in cui il programmatore vuole assicurare un Elenco variabile chiamata ‘nomi’ contiene solo le Stringhe:

    List<String> names = new ArrayList<String>();
    names.add("John");          //OK
    names.add(new Integer(1));  //compile error
    Ah, quindi la tentazione di copiare polygenelubricants‘s “a crudo tipo” riferimenti da stackoverflow.com/questions/2770111/… nella mia risposta, ma credo che li lascerò per la sua/la sua propria risposta.
    sì, sono stata essenzialmente copia-e-incolla di quel segmento ovunque le persone, utilizzare materie prime tipi di stackoverflow, e, infine, ha deciso di fare solo una domanda per vedere da ora in poi. Spero che sia un buon contributo per la comunità.
    Ho notato – ci ha colpito alcune delle stesse domande 🙂
    questa risposta è molto meglio che il accettato una concisa e semplice
    Infatti. In generale, conciso e semplice, le risposte sono almeno buono come il lungo e accettato.

    OriginaleL’autore Bert F

  7. 10

    Il compilatore voglia di scrivere:

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

    perché in caso contrario, si potrebbe aggiungere qualsiasi tipo che ti piace in list, rendendo la creazione di istanze come new ArrayList<String>() inutile. Generics Java sono una funzionalità in fase di compilazione, in modo un oggetto creato con new ArrayList<String>() sarà lieto di accettare Integer o JFrame elementi se assegnato ad un riferimento di “crudo tipo” List – l’oggetto stesso non sa nulla su che tipo dovrebbe contenere, solo il compilatore.

    OriginaleL’autore Michael Borgwardt

  8. 9

    Qui sto Considerando i diversi casi, attraverso il quale è possibile clearify il concetto

    1. ArrayList<String> arr = new ArrayList<String>();
    2. ArrayList<String> arr = new ArrayList();
    3. ArrayList arr = new ArrayList<String>();

    Caso 1

    ArrayList<String> arr è un ArrayList di riferimento la variabile è di tipo String che fanno riferimento a un ArralyList Oggetto di Tipo String. Significa che si può tenere solo la Stringa del tipo di Oggetto.

    È Stretto per String non un Raw, quindi, non potrà mai generare un messaggio di avviso .

        arr.add("hello");//alone statement will compile successfully and no warning.
    
        arr.add(23);  //prone to compile time error.
         //error: no suitable method found for add(int)

    Caso 2

    In questo caso ArrayList<String> arr è una stretta tipo ma il tuo Oggetto new ArrayList(); è un tipo raw.

        arr.add("hello"); //alone this compile but raise the warning.
        arr.add(23);  //again prone to compile time error.
        //error: no suitable method found for add(int)

    qui arr è una Stretta tipo. Così, aumenteranno il tempo di compilazione di errore durante l’aggiunta di un integer.

    Avviso :- Un Raw Tipo di Oggetto fa riferimento a un Strict tipo a cui fa Riferimento la Variabile di ArrayList.

    Caso 3

    In questo caso ArrayList arr è un raw, ma l’Oggetto new ArrayList<String>(); è una Stretta tipo.

        arr.add("hello");  
        arr.add(23);  //compiles fine but raise the warning.

    Aggiungere qualsiasi tipo di Oggetto in essa, perché arr è un Tipo Raw.

    Avviso :- Un Strict Tipo di Oggetto fa riferimento a un raw tipo di riferimento Variabile.

    OriginaleL’autore Vikrant Kashyap

  9. 8

    Un raw-tipo è la mancanza di un parametro di tipo quando si utilizza un tipo generico.

    Le materie di tipo non deve essere utilizzato perché potrebbe causare errori di runtime, come l’inserimento di un double in quello che doveva essere un Set di ints.

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

    Durante il recupero la roba dalla Set, non sai cosa è venuta fuori. Supponiamo che ci si aspetta di essere tutti ints, si sta casting a Integer; eccezione a runtime quando il double 3.45 arriva.

    Con un parametro di tipo aggiunto al tuo Set, si ottiene un errore di compilazione in una sola volta. Questo preemptive errore ti permette di risolvere il problema prima che qualcosa si fa saltare in aria durante la fase di esecuzione (e quindi di risparmiare tempo e fatica).

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

    OriginaleL’autore Lars Andren

  10. 4

    Quello che sta dicendo è che il vostro list è un List di unespecified oggetti. Che il Java non so che tipo di oggetti sono all’interno dell’elenco. Poi, quando si desidera scorrere la lista per il cast di ogni elemento, per essere in grado di accedere alle proprietà di questo elemento (in questo caso, Stringa).

    In generale è una migliore idea di parametrizzare le collezioni, in modo da non avere problemi di conversione, sarà solo in grado di aggiungere elementi di parametrizzare il tipo e il vostro editor di offrire i giusti metodi per selezionare.

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

    OriginaleL’autore pakore

  11. 4

    tutorial pagina.

    Un raw tipo è il nome di una generica classe o interfaccia, senza alcun tipo di argomenti. Per esempio, data la Casella generica classe:

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

    Per creare un tipo parametrizzato di Dialogo, è la fornitura di un effettivo tipo di argomento per la formale parametro di tipo T:

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

    Se il tipo effettivo argomento viene omesso, si crea un raw tipo di Scatola:

    Box rawBox = new Box();

    OriginaleL’autore Mykhaylo Adamovych

  12. 4

    Ecco un altro caso in cui raw tipi di mordere:

    public class StrangeClass<T> {
      @SuppressWarnings("unchecked")
      public <X> X getSomethingElse() {
        return (X)"Testing something else!";
      }
    
      public static void main(String[] args) {
        final StrangeClass<String> withGeneric    = new StrangeClass<>();
        final StrangeClass         withoutGeneric = new StrangeClass();
        final String               value1,
                                   value2;
    
        //Compiles
        value1 = withGeneric.getSomethingElse();
    
        //Produces compile error:
        //incompatible types: java.lang.Object cannot be converted to java.lang.String
        value2 = withoutGeneric.getSomethingElse();
      }
    }

    Come è stato accennato nella accettato di rispondere, si perde tutto il supporto per i farmaci generici all’interno del codice, di tipo raw. Ogni tipo di parametro è convertito alla sua cancellazione (che nell’esempio di cui sopra è solo Object).

    OriginaleL’autore GuyPaddock

  13. 1

    Ho trovato questa pagina dopo aver fatto qualche esempio di esercizi e di avere esattamente la stessa perplessità.

    ============== Sono andato da questo codice di fornire un esempio ===============

    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());
        }

    ====================== Per Questo codice ========================

    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());
        }
    
    }

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

    Potrebbe essere più sicuro, ma sono volute 4 ore per demuddle la filosofia…

    OriginaleL’autore user2442615

  14. 0

    Raw tipi sono belle quando esprimono ciò che si vuole esprimere.

    Per esempio, un deserialisation funzione può restituire un List, ma non conosce l’elenco del tipo di elemento. Così List è appropriato tipo di ritorno qui.

    Si può usare ? come parametro di tipo
    Sì, ma che è più di tipo e io sono contro a digitare più. 🙂

    OriginaleL’autore Stefan Reich

Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *