Java - Innere Klassen
In diesem Kapitel werden wir innere Klassen von Java diskutieren.
Verschachtelte Klassen
In Java können ebenso wie Methoden auch Variablen einer Klasse eine andere Klasse als Mitglied haben. Das Schreiben einer Klasse innerhalb einer anderen ist in Java zulässig. Die darin geschriebene Klasse heißtnested classund die Klasse, die die innere Klasse enthält, heißt die outer class.
Syntax
Es folgt die Syntax zum Schreiben einer verschachtelten Klasse. Hier die KlasseOuter_Demo ist die äußere Klasse und die Klasse Inner_Demo ist die verschachtelte Klasse.
class Outer_Demo {
class Inner_Demo {
}
}
Verschachtelte Klassen werden in zwei Typen unterteilt:
Non-static nested classes - Dies sind die nicht statischen Mitglieder einer Klasse.
Static nested classes - Dies sind die statischen Mitglieder einer Klasse.
Innere Klassen (nicht statische verschachtelte Klassen)
Innere Klassen sind ein Sicherheitsmechanismus in Java. Wir wissen, dass dem Zugriffsmodifikator keine Klasse zugeordnet werden kannprivate, aber wenn wir die Klasse als Mitglied einer anderen Klasse haben, kann die innere Klasse privat gemacht werden. Dies wird auch verwendet, um auf die privaten Mitglieder einer Klasse zuzugreifen.
Es gibt drei Arten von inneren Klassen, je nachdem, wie und wo Sie sie definieren. Sie sind -
- Innere Klasse
- Methodenlokale innere Klasse
- Anonyme innere Klasse
Innere Klasse
Das Erstellen einer inneren Klasse ist ganz einfach. Sie müssen nur eine Klasse innerhalb einer Klasse schreiben. Im Gegensatz zu einer Klasse kann eine innere Klasse privat sein. Wenn Sie eine innere Klasse als privat deklarieren, kann von einem Objekt außerhalb der Klasse nicht mehr darauf zugegriffen werden.
Es folgt das Programm zum Erstellen einer inneren Klasse und zum Zugriff darauf. Im angegebenen Beispiel machen wir die innere Klasse privat und greifen über eine Methode auf die Klasse zu.
Example
class Outer_Demo {
int num;
// inner class
private class Inner_Demo {
public void print() {
System.out.println("This is an inner class");
}
}
// Accessing he inner class from the method within
void display_Inner() {
Inner_Demo inner = new Inner_Demo();
inner.print();
}
}
public class My_class {
public static void main(String args[]) {
// Instantiating the outer class
Outer_Demo outer = new Outer_Demo();
// Accessing the display_Inner() method.
outer.display_Inner();
}
}
Hier können Sie das beobachten Outer_Demo ist die äußere Klasse, Inner_Demo ist die innere Klasse, display_Inner() ist die Methode, in der wir die innere Klasse instanziieren, und diese Methode wird von der aufgerufen main Methode.
Wenn Sie das obige Programm kompilieren und ausführen, erhalten Sie das folgende Ergebnis:
Output
This is an inner class.
Zugriff auf die privaten Mitglieder
Wie bereits erwähnt, werden innere Klassen auch verwendet, um auf die privaten Mitglieder einer Klasse zuzugreifen. Angenommen, eine Klasse hat private Mitglieder, um auf sie zuzugreifen. Schreiben Sie eine innere Klasse hinein, geben Sie die privaten Mitglieder von einer Methode innerhalb der inneren Klasse zurück, z.getValue()Rufen Sie schließlich von einer anderen Klasse (von der aus Sie auf die privaten Mitglieder zugreifen möchten) die Methode getValue () der inneren Klasse auf.
Um die innere Klasse zu instanziieren, müssen Sie zunächst die äußere Klasse instanziieren. Anschließend können Sie anhand des Objekts der äußeren Klasse die innere Klasse instanziieren.
Outer_Demo outer = new Outer_Demo();
Outer_Demo.Inner_Demo inner = outer.new Inner_Demo();
Das folgende Programm zeigt, wie Sie mit der inneren Klasse auf die privaten Mitglieder einer Klasse zugreifen.
Example
class Outer_Demo {
// private variable of the outer class
private int num = 175;
// inner class
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[]) {
// Instantiating the outer class
Outer_Demo outer = new Outer_Demo();
// Instantiating the inner class
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 das folgende Ergebnis:
Output
This is the getnum method of the inner class: 175
Methodenlokale innere Klasse
In Java können wir eine Klasse innerhalb einer Methode schreiben, und dies ist ein lokaler Typ. Wie bei lokalen Variablen ist der Umfang der inneren Klasse innerhalb der Methode eingeschränkt.
Eine methodenlokale innere Klasse kann nur innerhalb der Methode instanziiert werden, in der die innere Klasse definiert ist. Das folgende Programm zeigt, wie eine methodenlokale innere Klasse verwendet wird.
Example
public class Outerclass {
// instance method of the outer class
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);
}
} // end of inner class
// Accessing the inner class
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 das folgende Ergebnis:
Output
This is method inner class 23
Anonyme innere Klasse
Eine innere Klasse, die ohne Klassennamen deklariert wurde, wird als bezeichnet anonymous inner class. Bei anonymen inneren Klassen deklarieren und instanziieren wir sie gleichzeitig. Im Allgemeinen werden sie immer dann verwendet, wenn Sie die Methode einer Klasse oder einer Schnittstelle ü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 die Methode einer Klasse mithilfe einer anonymen inneren Klasse überschrieben wird.
Example
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 das folgende Ergebnis:
Output
This is an example of anonymous inner class
Auf die gleiche Weise können Sie die Methoden der konkreten Klasse sowie der Schnittstelle mithilfe einer anonymen inneren Klasse überschreiben.
Anonyme innere Klasse als Argument
Wenn eine Methode ein Objekt einer Schnittstelle, einer abstrakten Klasse oder einer konkreten Klasse akzeptiert, können wir im Allgemeinen die Schnittstelle implementieren, die abstrakte Klasse erweitern und das Objekt an die Methode übergeben. Wenn es sich um eine Klasse handelt, können wir sie direkt an die Methode übergeben.
In allen drei Fällen können Sie der Methode jedoch eine anonyme innere Klasse übergeben. Hier ist die Syntax zum Übergeben einer anonymen inneren Klasse als Methodenargument:
obj.my_Method(new My_Class() {
public void Do() {
.....
.....
}
});
Das folgende Programm zeigt, wie eine anonyme innere Klasse als Methodenargument übergeben wird.
Example
// interface
interface Message {
String greet();
}
public class My_class {
// method which accepts the object of interface Message
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[]) {
// Instantiating the class
My_class obj = new My_class();
// Passing an anonymous inner class as an argument
obj.displayMessage(new Message() {
public String greet() {
return "Hello";
}
});
}
}
Wenn Sie das obige Programm kompilieren und ausführen, erhalten Sie das folgende Ergebnis:
Output
Hello, This is an example of anonymous inner class as an argument
Statisch verschachtelte Klasse
Eine statische innere Klasse ist eine verschachtelte Klasse, die ein statisches Mitglied der äußeren Klasse ist. Auf den Zugriff kann zugegriffen werden, ohne die äußere Klasse mithilfe anderer statischer Elemente zu instanziieren. Genau wie statische Elemente hat eine statisch verschachtelte Klasse keinen Zugriff auf die Instanzvariablen und -methoden der äußeren Klasse. Die Syntax der statisch verschachtelten Klasse lautet wie folgt:
Syntax
class MyOuter {
static class Nested_Demo {
}
}
Das Instanziieren einer statisch verschachtelten Klasse unterscheidet sich ein wenig vom Instanziieren einer inneren Klasse. Das folgende Programm zeigt, wie eine statisch verschachtelte Klasse verwendet wird.
Example
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 das folgende Ergebnis:
Output
This is my nested class