Generici Java: perché l'interfaccia interna non può essere implementata da una superinterfaccia (interna)?

Question

Ho un interfaccia come questa:

public interface SuperInterface { 
    public interface SubInterface { 
     public void get(); 
    } 
    //**More interfaces*/ 

} 

questo metodo nel mio Toolkit, che recupera tutti gli oggetti che sono istanza di una certa classe:

public static <T> ArrayList<T> getSome(ArrayList<Object> objects, Class<T> clazz) { 
    ArrayList<T> result = new ArrayList<T>(); 
    for (Object o : objects) 
     if (clazz.isInstance(o)) 
      result.add(clazz.cast(o)); 
    return result; 
} 

MyClass non è davvero interessante, il suo un vuoto classe che implementa da SuperInterface.SubInterface

E questo pezzo nella principale:

ArrayList<Object> mObjects = new ArrayList<Object>() { 
    { 
     add(new MyClass()); //SuperInterface.SubInterface 
     add(Integer.valueOf(5)); 
     add(new String("Hello")); 
     add(new Object()); 
    } 
}; 
ArrayList<SuperInterface> mSuperInterfaces = Toolkit.getSome(mObjects, SuperInterface.class); //returns a zero-sized list. 
ArrayList<SuperInterface.SubInterface> mSubInterfaces = Toolkit.getSome(mObjects, SuperInterface.SubInterface.class); //returns a one-sized list 

La prima chiamata al metodo non funziona come speravo, il secondo sì. È possibile che il primo funzioni senza esplicitamente inserire le subinterfacce in un file diverso e implementare la superclasse? Perché a quanto pare le sottointerfacce non sono realmente subinterfaces, così ho cercato di rendere la classe di interfaccia come questa:

public class ClassWithInterfaces { 
    public interface Super { } 
    public interface Sub implements Super { /**...*/ } 
} 

Ma a quanto pare non è possibile utilizzare implements in un'interfaccia interna.

La mia domanda è: Perché è che , e c'è un modo per realizzare ciò che voglio raggiungere (interfacce interne in un unico file)? Non ne ho necessariamente bisogno, voglio solo sapere perché non è possibile implementare le interfacce interne (eppure è possibile estendere le classi interne).

Answer 1

Ma a quanto pare non è possibile utilizzare implements in un'interfaccia interna.

Siete alla ricerca di extends piuttosto che implements:

public class ClassWithInterfaces { 
    public interface Super { } 
    public interface Sub extends Super { /**...*/ } 
} 

Questo compila per me, e posso certamente implementare entrambe le interfacce.

Poiché sembra esserci una certa confusione intorno estendentesi vs attuazione, forse la seguente aiuterà a chiarire le cose:

• Un'interfaccia estende un'altra interfaccia.
• Una classe implementa un'interfaccia.
• Una classe estende un'altra classe.

Answer 2

Secondo il linguaggio Java Specification:

• all members of an interface (except methods) are implicitly static
• member interfaces are always implicitly static themselves, by definition

Così qui avete due motivi per cui non si può avere interfacce interne "reali"

anche , come scrive NPE, un'interfaccia non può mai implementare un'altra interfaccia, può solo estenderla. Le classi possono implementare interfacce e/o estendere le classi, le interfacce possono solo estendere le interfacce. Ha perfettamente senso per me.