Advanced   Java   Services

member interfaces

Eine Klasse kann innere Interfaces enthalten. Wie alle Bestandteile einer Klasse können nested Interfaces alle vier Schutzzustände haben.

// package xxx ;

public class EnclosingClass
{
   public interface PublicInterface
   {
   }

   protected interface ProtectedInterface
   {
   }

   interface PackagePrivateInterface // default oder package private
   {
   }

   private interface PrivateInterface
   {
   }
}

Nested Interfaces sind implizit static. Der Versuch, auf nichtstatische Daten zuzugreifen endet mit einer Fehlermeldung des Compilers:

// package xxx ;

public class EnclosingClass
{
   private static int a = 17;
   private int b = 18;

   protected interface ProtectedInterface
   {
      //int c = b;  // non-static variable b cannot be referenced from a static context
      int d = a ;   // OK, d ist implizit static, final und public
   }
}

Da ein nested Interface immer static ist, kann es wie ein TopLevelInterface verwendet werden und innerhalb und außerhalb der einschließenden Klasse realisiert werden. Letzeres geht natürlich nur dann, wenn das nested Interface nicht private ist.

// package xxx ;

public class EnclosingClass
{
   public interface InnerFace // implizit static
   {
      public void method() ;
   }

   class InnerFaceImpl implements InnerFace // non static member class
   {
      public void method()
      {
      }
   }

}

class InnerFaceImpl implements EnclosingClass.InnerFace
{
   public void method()
   {
   }
}

Das Anlegen von Objekten vom Typ des Interfaces funktioniert wie immer, man analysiere dazu das folgende Beispiel.

public class EnclosingClass
{
   InnerFace inf = new InnerFaceImpl();
   InnerFace inf2 = new InnerFaceImpl2();

   public interface InnerFace
   {
      public void method() ;
   }

   public static class InnerFaceImpl implements InnerFace // static member class
   {
      public void method()
      {
      }
   }

}

class InnerFaceImpl2 implements EnclosingClass.InnerFace
{
   public void method()
   {
   }
}

class CreatingObjects
{
   private EnclosingClass.InnerFace ob1 = new InnerFaceImpl2();
   private EnclosingClass.InnerFace ob2 = new EnclosingClass.InnerFaceImpl();

}

Eigenschaften von Interfaces in Klassen

• Sie sind immer static
  
  
• Sie können public, protected, package private oder private sein
  
  
• Statische äußere Daten können zum Initialisieren der
  
  eigenen inneren Konstanten verwendet werden
  
  
• Implementierungen können innerhalb und außerhalb der umschließenden Klasse erfolgen
  
  
• Äußere Implementierungen sind abhängig vom Schutzzustand
  
  
• Die umschließende Klasse kann das innere Interface nicht implementieren: cyclic inheritance

Innere Interfaces mögen als Exoten erscheinen, nichtsdestotrotz gibt es sie in der API, nicht so häufig wie static nested classes oder non static nested classes, aber eben doch.

Der Compiler speichert jede Klasse bzw. jedes Interface als eigene Datei. Für das einleitende Beispiel erzeugt der Compiler die folgenden Dateien:

• EnclosingClass.class
  
  
• EnclosingClass$PublicInterface.class
  
  
• EnclosingClass$ProtectedInterface.class
  
  
• EnclosingClass$PackagePrivateInterface.class
  
  
• EnclosingClass$PrivateInterface.class