Java Inner Classes erklärt: Design, Syntax und praktische Anwendungen

Verschachtelte Klassen (Nested Classes)

In Java können, genau wie Methoden, auch Variablen einer Klasse eine andere Klasse als Member haben. Das Schreiben einer Klasse innerhalb einer anderen ist in Java erlaubt. Die Klasse, die innerhalb geschrieben wird, nennt man nested class (verschachtelte Klasse), und die Klasse, die die innere Klasse enthält, nennt man outer class (äußere Klasse).

Syntax

Folgend ist die Syntax, um eine verschachtelte Klasse zu schreiben. Hier ist die Klasse Outer_Demo die äußere Klasse und die Klasse Inner_Demo die verschachtelte Klasse.

class Outer_Demo {
    class Inner_Demo {
    }
}

Verschachtelte Klassen werden in zwei Typen unterteilt:

• Non-static nested classes (nicht-statische verschachtelte Klassen) – Dies sind die nicht-statischen Member einer Klasse.
• Static nested classes (statische verschachtelte Klassen) – Dies sind die statischen Member einer Klasse.

Inner Classes (Nicht-statische verschachtelte Klassen)

Inner Classes sind ein Sicherheitsmechanismus in Java. Wir wissen, dass eine Klasse nicht mit dem Zugriffsmodifizierer private assoziiert werden kann, aber wenn wir die Klasse als Member einer anderen Klasse haben, dann kann die innere Klasse private gemacht werden. Und dies wird auch verwendet, um auf die privaten Member einer Klasse zuzugreifen.

Inner Classes sind von drei Typen, abhängig davon, wie und wo Sie sie definieren:

• Inner Class (Mitgliedsklasse)
• Method-local Inner Class (lokal in einer Methode)
• Anonymous Inner Class (anonyme innere Klasse)

Inner Class (Mitgliedsklasse)

Das Erstellen einer inneren Klasse ist ziemlich einfach. Sie müssen lediglich eine Klasse innerhalb einer Klasse schreiben. Im Gegensatz zu einer Klasse kann eine innere Klasse private sein, und sobald Sie eine innere Klasse als private deklarieren, kann sie nicht von einem Objekt außerhalb der Klasse aufgerufen werden.

Das folgende Programm erstellt eine innere Klasse und greift darauf zu. Im gegebenen Beispiel machen wir die innere Klasse private und greifen über eine Methode auf die Klasse zu.

Beispiel

class Outer_Demo {
    int num;

    // innere Klasse
    private class Inner_Demo {
        public void print() {
            System.out.println("This is an inner class");
        }
    }

    // Auf die innere Klasse aus der Methode heraus zugreifen
    void display_Inner() {
        Inner_Demo inner = new Inner_Demo();
        inner.print();
    }
}

public class My_class {
    public static void main(String args[]) {
        // Äußere Klasse instanziieren
        Outer_Demo outer = new Outer_Demo();
        // display_Inner()-Methode aufrufen
        outer.display_Inner();
    }
}

Man kann beobachten, dass Outer_Demo die äußere Klasse ist, Inner_Demo die innere Klasse, display_Inner() die Methode, in der wir die innere Klasse instanziieren, und diese Methode wird von der main-Methode aufgerufen.

Wenn Sie das obige Programm kompilieren und ausführen, erhalten Sie folgendes Ergebnis:

This is an inner class.

Zugriff auf private Member

Wie bereits erwähnt, werden innere Klassen auch verwendet, um auf die privaten Member einer Klasse zuzugreifen. Angenommen, eine Klasse hat private Member, auf die zugegriffen werden soll. Schreiben Sie eine innere Klasse hinein, geben Sie die privaten Member von einer Methode innerhalb der inneren Klasse zurück, sagen wir getValue(), und rufen Sie schließlich von einer anderen Klasse (von der aus Sie auf die privaten Member zugreifen möchten) die getValue()-Methode der inneren Klasse auf.

Um die innere Klasse zu instanziieren, müssen Sie zunächst die äußere Klasse instanziieren. Danach können Sie die innere Klasse mithilfe des Objekts der äußeren Klasse wie folgt instanziieren:

Outer_Demo outer = new Outer_Demo();
Outer_Demo.Inner_Demo inner = outer.new Inner_Demo();

Das folgende Programm zeigt, wie man mit einer inneren Klasse auf die privaten Member einer Klasse zugreift.

Beispiel

class Outer_Demo {
    // private Variable der äußeren Klasse
    private int num = 175;

    // innere Klasse
    public class Inner_Demo {
        public int getNum() {
            System.out.println("This is the getnum method of the inner class");
            return num;
        }
    }
}

public class My_class2 {
    public static void main(String args[]) {
        // Äußere Klasse instanziieren
        Outer_Demo outer = new Outer_Demo();
        // Innere Klasse instanziieren
        Outer_Demo.Inner_Demo inner = outer.new Inner_Demo();
        System.out.println(inner.getNum());
    }
}

Wenn Sie das obige Programm kompilieren und ausführen, erhalten Sie folgendes Ergebnis:

This is the getnum method of the inner class: 175

Method-local Inner Class (In Methode lokal)

In Java können wir eine Klasse innerhalb einer Methode schreiben, und dies wird ein lokaler Typ sein. Wie lokale Variablen ist der Gültigkeitsbereich der inneren Klasse auf die Methode beschränkt.

Eine method-local inner class kann nur innerhalb der Methode instanziiert werden, in der die innere Klasse definiert ist. Das folgende Programm zeigt, wie man eine method-local inner class verwendet.

Beispiel

public class Outerclass {
    // Instanzmethode der äußeren Klasse
    void my_Method() {
        int num = 23;

        // method-local inner class
        class MethodInner_Demo {
            public void print() {
                System.out.println("This is method inner class " + num);
            }
        }
        // Ende der inneren Klasse

        // Auf die innere Klasse zugreifen
        MethodInner_Demo inner = new MethodInner_Demo();
        inner.print();
    }

    public static void main(String args[]) {
        Outerclass outer = new Outerclass();
        outer.my_Method();
    }
}

Wenn Sie das obige Programm kompilieren und ausführen, erhalten Sie folgendes Ergebnis:

This is method inner class 23

Anonymous Inner Class (Anonyme innere Klasse)

Eine innere Klasse, die ohne Klassennamen deklariert wird, ist als anonyme innere Klasse bekannt. Bei anonymen inneren Klassen deklarieren und instanziieren wir sie gleichzeitig. Im Allgemeinen werden sie immer dann verwendet, wenn Sie die Methode einer Klasse oder eines Interfaces überschreiben müssen. Die Syntax einer anonymen inneren Klasse lautet wie folgt:

Syntax

AnonymousInner an_inner = new AnonymousInner() {
    public void my_method() {
        ........
        ........
    }
};

Das folgende Programm zeigt, wie man die Methode einer Klasse mithilfe einer anonymen inneren Klasse überschreibt.

Beispiel

abstract class AnonymousInner {
    public abstract void mymethod();
}

public class Outer_class {
    public static void main(String args[]) {
        AnonymousInner inner = new AnonymousInner() {
            public void mymethod() {
                System.out.println("This is an example of anonymous inner class");
            }
        };
        inner.mymethod();
    }
}

Wenn Sie das obige Programm kompilieren und ausführen, erhalten Sie folgendes Ergebnis:

This is an example of anonymous inner class

Auf die gleiche Weise können Sie die Methoden einer konkreten Klasse sowie eines Interfaces mithilfe einer anonymen inneren Klasse überschreiben.

Anonymous Inner Class als Argument

Im Allgemeinen, wenn eine Methode ein Objekt eines Interfaces, einer abstrakten Klasse oder einer konkreten Klasse akzeptiert, können wir das Interface implementieren, die abstrakte Klasse erweitern und das Objekt an die Methode übergeben. Wenn es eine Klasse ist, können wir sie direkt an die Methode übergeben.

Aber in allen drei Fällen können Sie eine anonyme innere Klasse an die Methode übergeben. Hier ist die Syntax für die Übergabe einer anonymen inneren Klasse als Methodenargument:

obj.my_Method(new My_Class() {
    public void Do() {
        .....
        .....
    }
});

Das folgende Programm zeigt, wie man eine anonyme innere Klasse als Methodenargument übergibt.

Beispiel

// Interface
interface Message {
    String greet();
}

public class My_class {
    // Methode, die Objekt des Interface Message akzeptiert
    public void displayMessage(Message m) {
        System.out.println(m.greet() + ", This is an example of anonymous inner class as an argument");
    }

    public static void main(String args[]) {
        // Klasse instanziieren
        My_class obj = new My_class();

        // Anonyme innere Klasse als Argument übergeben
        obj.displayMessage(new Message() {
            public String greet() {
                return "Hello";
            }
        });
    }
}

Wenn Sie das obige Programm kompilieren und ausführen, erhalten Sie folgendes Ergebnis:

Hello, This is an example of anonymous inner class as an argument

Static Nested Class (Statische verschachtelte Klasse)

Eine statische innere Klasse ist eine verschachtelte Klasse, die ein statisches Mitglied der äußeren Klasse ist. Sie kann ohne Instanziierung der äußeren Klasse aufgerufen werden, indem andere statische Member verwendet werden. Genau wie statische Member hat eine statische verschachtelte Klasse keinen Zugriff auf die Instanzvariablen und Methoden der äußeren Klasse. Die Syntax einer statischen verschachtelten Klasse lautet wie folgt:

Syntax

class MyOuter {
    static class Nested_Demo {
    }
}

Das Instanziieren einer statischen verschachtelten Klasse unterscheidet sich etwas von der Instanziierung einer inneren Klasse. Das folgende Programm zeigt, wie man eine statische verschachtelte Klasse verwendet.

Beispiel

public class Outer {
    static class Nested_Demo {
        public void my_method() {
            System.out.println("This is my nested class");
        }
    }

    public static void main(String args[]) {
        Outer.Nested_Demo nested = new Outer.Nested_Demo();
        nested.my_method();
    }
}

Wenn Sie das obige Programm kompilieren und ausführen, erhalten Sie folgendes Ergebnis:

This is my nested class