Il cast è forzato quando si utilizzano i generici in Java

Question

Ho scritto la mia classe Stack (per il codice pertinente, vedere di seguito). Nel metodo next() sono obbligato a trasmettere current.item a Item, ma non so perché. Il tipo di current.item dovrebbe già essere Item e quindi il cast non dovrebbe essere necessario, ma se non lo scrivo, ottengo un errore.

public class Stack<Item> implements Iterable<Item> { 

    private class Node { 
     Item item; 
     Node next; 
    } 

    private Node first= null; 

    public Iterator<Item> iterator() { return new StackIterator(); } 

    private class StackIterator<Item> implements Iterator<Item> { 
    private Node current = first; 

    public Item next(){ 
     Item item = (Item)current.item; 
     current = current.next; 
     return item; 
    } 
    } 
} 

Answer 1

Il digitare il parametro da StackIterator<Item> nasconde il tipo Item, che viene introdotto nella definizione della classe Stack<Item>.

Ecco perché è necessario eseguire un cast (o aggiungere un'annotazione @SuppressWarnings("hiding")).

Al fine di sbarazzarsi di avvertimento, è sufficiente rimuovere il tipo di duplicato:

private class StackIterator implements Iterator<Item> { 

} 

Answer 2

Si stava utilizzando <Item> come un parametro di tipo sia Stack e StackIterator, mentre ciò che si vuole veramente fare è avere StackIterator senza un parametro e solo affermare che implementa Iterator<Item>:

private class StackIterator implements Iterator<Item> { 
     private Node current = first; 

     @Override 
     public Item next() { 
      Item item = current.item; // no need to cast now 
      current = current.next; 
      return item; 
     } 
    } 

Answer 3

Se volete <Item> in StackIterator ad essere dello stesso tipo come il racchiude <Item> associato con Stack, rimuovere la dichiarazione di <Item> in StackIterator.

Se si desidera che il <Item> in StackIterator di essere diverso da quello che racchiude <Item> associato con Stack, ma si vuole essere in grado di accedere alle proprietà del genitore Stack, rinominare <Item> a qualcos'altro.

Answer 4

La classe StackIterator è una classe interna di Stack. Ciò significa in particolare che non è statico. Pertanto conosce già il parametro di tipo Item.

Si sta commettendo l'errore di impostare StackIterator con il proprio parametro tipo Item. Questo ombreggia il parametro di tipo della classe esterna.

Quindi, è sufficiente rimuovere il parametro di tipo da StackIterator:

public class Stack<Item> implements Iterable<Item> { 
    private class Node { 
     Item item; 
     Node next; 
    } 

    private Node first = null; 

    @Override 
    public Iterator<Item> iterator() { return new StackIterator(); } 

    private class StackIterator implements Iterator<Item> { 
     private Node current = Stack.this.first; 

     @Override 
     public Item next() { 
      Item item = this.current.item; 
      this.current = this.current.next; 
      return item; 
     } 
    } 
}