Genéricos de Java con clase e interfaz estática anidada

Question

Quiero usar una clase genérica dentro de una interfaz estática anidada. Mi objetivo es hacer algo como esto:

public class MyClass<T>{ 
    private MyInterface task; 

    public static interface MyInterface{ 
     void aMethod (T item); 
    } 
} 

pero me sale el error: No se puede hacer una referencia estática a la T. tipo no estático Si hago algunos cambios (por debajo) Puedo usar un tipo genérico en el interior una interfaz, pero quiero evitar este método porque es redundante escribir la misma clase 2 veces: una para MyClass y otra para MyInterface.

public class MyClass<T>{ 
    private MyInterface<T> task; 

    public static interface MyInterface<T>{ 
     void aMethod (T item); 
    } 
} 

Thanks.

EDITAR: Quiero hacer esto:

MyClass c = new MyClass<String>(); 
c.setInterface (new MyClass.MyInterface(){ 
    @Override 
    public void aMethod (String s){ 
     ... 
    } 
); 

o

MyClass c = new MyClass<AnotherClass>(); 
c.setInterface (new MyClass.MyInterface(){ 
    @Override 
    public void aMethod (AnotherClass s){ 
     ... 
    } 
); 

Answer 1

Una clase anidada estática o una interfaz anidada (que siempre es estática, por cierto) no tiene ninguna relación con su clase externa (o interfaz) además del anidamiento del espacio de nombres y el acceso a variables privadas.

Por lo tanto, el parámetro de tipo de la clase externa no está disponible dentro de la interfaz anidada en su caso, debe definirlo de nuevo. Para evitar confusiones, recomiendo usar un nombre diferente para este parámetro interno.

(A modo de ejemplo, en la norma API, busque la interfaz Map.Entry<K,V>, anidado dentro de la interfaz Map<K,V>, sin embargo, no tiene acceso a sus parámetros de tipo y tiene que declarar de nuevo.)

Answer 2

No es redundante. Con una interfaz estática:

MyClass.MyInterface<String> myInstance; 

y con una clase innter no estática (una interfaz es siempre estática):

MyClass<String>.MyInterface myInstance; 

A más ejemplo del mundo real:

Map<String, Integer> map = ...; 
for (Map.Entry<String, Integer> entry : map.entrySet()) { 
    ... 
} 

El estática enfoque tiene la ventaja de que puede importar el tipo anidado, y todavía especificar los parámetros de tipo:

class ClassWithAReallyLongName<T> { 
    static interface Entry<T> { 
    } 
} 

y

import my.package.ClassWithAReallyLongName.Entry; 

class Foo { 
    Entry<String> bar; 
} 

aunque uno debe utilizar ese idioma con precaución para no confundir al lector.