Static Member Classes

Statische Element-Klasse (static member class)

Deklaration einer statischen Klasse innerhalb einer Klasse
Hat Zugriff auf statische Variablen und statische Methoden der äußeren Klasse
Hat keinen Zugriff auf Instanzvariablen und nicht-statische Methoden der äußeren Klasse

public class Outer {
    static class Inner { }
}

Stellt nur eine besondere Form der Paketierung dar (Name der Klasse ist Outer.Inner statt nur Inner)
Verhält sich ansonsten wie eine toplevel Klasse
Objekte können einfach erzeugt werden
Outer.Inner ref = new Outer.Inner();
Können Instanzvariablen und nicht-statische Methoden enthalten
Können statische Variablen und statische Methoden enthalten

Die einfachste Variante der statischen Klassen ist die statsiche Element-Klasse. Hierbei handelt es sich um eine geschachtelte Klasse, die mit dem Modifier static gekennzeichnet ist.

Die Besonderheit dieser Art von geschachtelter Klasse besteht darin, dass sie nur auf statische Eigenschaften der umgebenden Klasse zugreifen darf. Hier allerdings auch, wenn diese private sind. Der Hintergrund hierfür wird klarer, wenn später die nichtstatischen Element-Klassen eingeführt werden. An dieser Stelle kann man nur erklären, dass die statische Elementklasse ohne Objekt der äußeren Klasse existiert (sie ist statisch) und somit keine Möglichkeit hat, auf (nichtstatische) Attribute oder Methoden zuzugreifen.

Technisch gesehen führt die statische Elementklasse nur zu einer besonderen Form der Namensgebung: Durch das Schachteln muss der Namen der äußeren Klasse vor den Namen der inneren gesetzt werden. Eine Klasse B, die statisch in eine Klasse A geschachtelt wurde, heißt dann also A.B statt nur B. Ansonsten verhält sie sich aber wie jede normale Klasse.

Beispiel: Static Member Class

public class StaticMember {

    public static class InnereKlasse {
        public String toString() {
            return "Ich bin innen";
        }
    }

    public String toString() {
        return "Ich bin außen";
    }
}

StaticMember aeussere = new StaticMember();
StaticMember.InnereKlasse innere = new StaticMember.InnereKlasse();
System.out.println(aeussere); // -> "Ich bin außen"
System.out.println(innere);   // -> "Ich bin innen"

Das Beispiel zeigt eine statische Element-Klasse InnereKlasse, die in die Klasse StaticMember geschachtelt wurde. Man sieht bei der Deklaration der Referenzvariable innere und der Objekterzeugung, dass der Name der geschachtelten Klasse tatsächlich aus dem Namen der äußeren und dem Namen der geschachtelten Klasse besteht.

Zugriff auf private Bestandteile

public class PrivaterZugriff {
    private static int a = 5;
    static class InnereKlasse {
        private static int b = 7;
        private static void innen() {
            b = a;
            aussen2();
        }
    }

    private static void aussen1() {
        InnereKlasse.innen();
    }

    private static void aussen2() {
        InnereKlasse.b = 17;
    }
}

Dieses Beispiel zeigt, dass die geschachtelte Klasse problemlos auf das private, statische Attribut a der äußere Klasse zugreifen kann. Umgekehrt kann aber die äußere Klasse genauso die privaten Methoden und Attribute der geschachtelten Klasse benutzen.

Beispiel: Static Member Class

public class Outer {
    private static final int CONSTANT = 15;

    public static class Inner {
        public static final double PI = 3.14159265;
        public int doSomething(int i) {
            return i * CONSTANT;
        }
    }
}

public class UseOuter {
    public static void main(String[] args) {
        Outer.Inner inner = new Outer.Inner();
        inner.doSomething(15);
        double a = 2 * Outer.Inner.PI * 5.0 * 5.0;
    }
}

Zugriff auf private Bestandteile

public class Zugriff {
    static class Inner1 {
        private int i;
        private void doIt(Inner2 inner2) {
            inner2.k++;
        }
    }
    static class Inner2 {
        private int k;
        private void doIt(Inner1 inner1) {
            inner1.i++;
        }
    }
    public void doIt(Inner1 i1, Inner2 i2) {
        i1.i = i2.k;
        i1.doIt(i2);
    }
}

Dieses Beispiel zeigt, dass man zum einen mehrere statische Element-Klassen in einer einzigen umgebenden Klasse haben kann und zum anderen, dass die statischen Element-Klassen untereinander auf die privaten Attribute der anderen zugreifen können. Da es sich in diesem Beispiel bei i und k nicht um statische Attribute handelt, ist allerdings ein Objekt vom Typ der Element-Klasse notwendig, das jeweils als Parameter an die Methoden übergeben wird.