Java: classe locale e generici, perché avvisare il compilatore?

Question

I nomi local classes vengono utilizzati molto raramente, in genere le classi locali sono anonime. Qualcuno sa perché il codice sottostante genera un avvertimento del compilatore?

public class Stuff<E> { 
    Iterator<E> foo() { 
    class InIterator implements Iterator<E> { 
     @Override public boolean hasNext() { return false; } 
     @Override public E next() { return null; } 
     @Override public void remove() { } 
    } 
    return new InIterator(); 
    } 
} 

L'avviso è in new InIterator() e dice

[unchecked] unchecked conversion 
found : InIterator 
required: java.util.Iterator<E> 

Se la classe, invariata, è in forma anonima, o se si è fatto un membro, l'avviso va via. Tuttavia, come classe locale con nome, richiede una dichiarazione class InIterator<E> implements ... per l'avviso di andare via.

Cosa sta succedendo?

Answer 1

Ora sono convinto che si tratti di un bug javac. Le soluzioni precedenti che aggiungono un parametro generico a InIterator che nasconde o sostituisce E non sono utili, perché precludono l'iteratore dal fare qualcosa di utile, come restituire un elemento di tipo E - Stuff's E.

Tuttavia questo compila con nessun avviso (grazie Jorn per il suggerimento):

public class Stuff<E> { 
    E bar; 
    Iterator<E> foo() { 
    class InIterator<Z> implements Iterator<E> { 
     @Override public boolean hasNext() { return false; } 
     @Override public E next() { return bar; } 
     @Override public void remove() { } 
    } 
    return new InIterator<Void>(); 
    } 
} 

Sicuramente un bug.

Answer 2

Credo che stia accadendo ignorando l'argomento di tipo generico nominando InIterator senza un riferimento al generico nella firma (anche se è presente nell'interfaccia).

Questo rientra nella categoria degli avvisi di compilatore stupidi: hai scritto la classe in modo che il 100% delle istanze InIterator implementa Iterator<E>, ma il compilatore non lo riconosce. (Suppongo che questo dipenda dal compilatore Non vedo l'avviso nel mio compilatore Eclipse, ma so che il compilatore Eclipse gestisce i generici in modo leggermente diverso dal compilatore JDK.)

Io sostengo che questo è meno chiaro, e meno vicino a quello che vuoi dire, ma forse più compilatore amichevole, e, infine, equivalente:

public class Stuff<E> { 
    Iterator<E> foo() { 
    class InIterator<F> implements Iterator<F> { 
     @Override public boolean hasNext() { return false; } 
     @Override public E next() { return null; } 
     @Override public void remove() { } 
    } 
    return new InIterator<E>(); 
    } 
} 

Answer 3

Hmm, nessun avviso qui.

import java.util.Iterator; 

public class Stuff<E> { 
    Iterator<E> foo() { 
     class InIterator implements Iterator<E> { 
      public boolean hasNext() { 
       return false; 
      } 

      public E next() { 
       return null; 
      } 

      public void remove() { 
      } 
     } 
     return new InIterator(); 
    } 

    public static void main(String[] args) { 
     Iterator<String> i = new Stuff<String>().foo(); 
    } 
} 

Answer 4

Sì, sono anche d'accordo che questo dovrebbe essere un bug. Se si "solleva" la classe locale dal metodo in una classe membro, funziona anche bene. E non c'è molta differenza tra i due eccetto diversi ambiti e accesso alle variabili locali.

public class Stuff<E> { 
    class InIterator implements Iterator<E> { 
    @Override public boolean hasNext() { return false; } 
    @Override public E next() { return null; } 
    @Override public void remove() { } 
    } 
    Iterator<E> foo() { 
    return new InIterator(); 
    } 
}