Java-Generics: Warum kann die innere Schnittstelle nicht von einer (inneren) Superschnittstelle implementiert werden?

Question

Ich habe eine Schnittstelle wie folgt aus:

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

} 

diese Methode in meinem Toolkit, das alle Objekte abruft, die Instanz einer bestimmten Klasse sind:

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 nicht wirklich interessant ist, dessen eine leere Klasse von SuperInterface.SubInterface Implementierung

Und dieses Stück im Haupt:

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 

Der erste Methodenaufruf funktioniert nicht wie ich gehofft habe, der zweite tut. Ist es möglich, dass der erste funktioniert, ohne die Subschnittstellen explizit in eine andere Datei zu setzen und die Superklasse zu implementieren? Da anscheinend die Subinterfaces sind nicht wirklich Subinterfaces, so habe ich versucht, die Interface-Klasse wie folgt zu machen:

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

Aber anscheinend kann man nicht implements in einer inneren Schnittstelle verwenden.

Meine Frage ist: Warum ist das, und gibt es eine Möglichkeit zu erreichen, was ich erreichen möchte (innere Schnittstellen in einer Datei)? Ich brauche es nicht unbedingt, ich möchte nur wissen, warum es nicht möglich ist, in inneren Schnittstellen zu implementieren (es ist jedoch möglich, innere Klassen zu erweitern).

Answer 1

Aber anscheinend können Sie implements in einer inneren Schnittstelle nicht verwenden.

Sie suchen extends statt implements:

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

Das ist für mich kompiliert, und ich kann mit Sicherheit beide Schnittstellen implementieren.

Da es einige Verwirrung sein, um erstreckt vs Umsetzung erscheint, vielleicht wird die folgende klare Dinge aufhelfen:

• Eine Schnittstelle erweitert eine andere Schnittstelle.
• Eine Klasse implementiert eine Schnittstelle.
• Eine Klasse erweitert eine andere Klasse.

Answer 2

Nach der Java Language Specification:

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

So, hier haben Sie zwei Gründe, warum Sie nicht "real" innere Schnittstellen

Auch haben Wie eine NPE schreibt, kann eine Schnittstelle niemals eine andere Schnittstelle implementieren, sie kann sie nur erweitern. Klassen können Schnittstellen implementieren und/oder Klassen erweitern, Schnittstellen können nur Schnittstellen erweitern. Macht für mich Sinn.