Java Verkettete und interne Klassen

In this tutorial, you will learn about nested classes in Java and their types through examples.

In Java, you can define a class within another class. Such a class is called nested class (嵌套类). For example,

class OuterClass {
　　　　//　...
　　　　class NestedClass {
　　　　　　　　//　...
　　　　}
}

Sie können mit Java zwei Arten von verschachtelten Klassen erstellen.

• Nicht statische verschachtelte Klasse (interne Klasse)

• Statische verpackte Klasse

Relevantes Lesen:

• Java Zugriffsmodifikatoren

• Java Statische Schlüsselwörter

Lassen Sie uns zunächst die nicht statische verschachtelte Klasse betrachten.

Nicht statische verschachtelte Klasse (interne Klasse)

Nicht statische verschachtelte Klasse ist eine Klasse in einer anderen Klasse. Sie hat das Recht, auf die Mitglieder der umschlossenen Klasse (externen Klasse) zuzugreifen. Es wird normalerweise als inner class (interne Klasse) bezeichnet.

Da die interne Klasse in der externen Klasse existiert, muss die externe Klasse zuerst instanziert werden, um die interne Klasse zu instanziieren.

Dies ist ein Beispiel dafür, wie man eine interne Klasse in Java deklariert.

Beispiel1：Internationale Klasse

class CPU {
　　　　double price;
　　　　//　Verschachtelte Klasse
　　　　class Processor{
　　　　　　　　//Mitglieder der verschachtelten Klasse
　　　　　　　　double cores;
　　　　　　　　String manufacturer;
　　　　　　　　double getCache(){
　　　　　　　　　　　　return　4.3;
　　　　　　　　}
　　　　}
　　　　//Verschachtelte geschützte Klasse
　　　　protected class RAM{
　　　　　　　　//Mitglieder der geschützten verschachtelten Klasse
　　　　　　　　double memory;
　　　　　　　　String manufacturer;
　　　　　　　　double getClockSpeed(){
　　　　　　　　　　　　return　5.5;
　　　　　　　　}
　　　　}
}
public class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//Erstellen Sie ein Beispiel für die externe Klasse CPU
　　　　　　　　CPU cpu = new CPU();
　　　　　　　//Verwenden Sie das Beispiel der externen Klasse, um ein Objekt der internen Klasse Processor zu erstellen
　　　　　　　　CPU.Processor processor = cpu.new Processor();
　　　　　　　　//Verwenden Sie das Beispiel der externen Klasse CPU, um ein Objekt der internen Klasse RAM zu erstellen
　　　　　　　　CPU.RAM ram = cpu.new RAM();
　　　　　　　　System.out.println("Processor Cache = ");　+　processor.getCache());
　　　　　　　　System.out.println("Ram Clock speed = ");　+　ram.getClockSpeed());
　　　　}
}

Ausgabe:

Processor Cache =　4.3
Ram Clock speed =　5.5

Im obigen Programm gibt es zwei verschachtelte Klassen: Processor und RAM innerhalb der externen Klasse CPU:. Wir können die interne Klasse als geschützt deklarieren. Daher wurde die Klasse RAM als geschützt deklariert.

Innerhalb der Klasse Main

• Wir erstellen zunächst ein Beispiel für die externe Klasse CPU mit dem Namen cpu.

• Dann, verwenden Sie das Beispiel der externen Klasse, um ein Objekt der internen Klasse zu erstellen:　

  CPU.Processor processor = cpu.new Processor();
  CPU.RAM ram = cpu.new RAM();

Achtung：Wir verwenden den Punkt-Operator (.) zur Erstellung eines Beispiels für die interne Klasse der externen Klasse.

Zugriff auf die Mitglieder der externen Klasse in der internen Klasse

Wir können das this-Schlüsselwort verwenden, um die Mitglieder der externen Klasse zu erreichen. Wenn Sie dieses Schlüsselwort verstehen möchten, besuchen Sie bitteJava this-Schlüsselwort。}}　

Beispiel2：Zugriff auf Mitgliedsstand

class Car {
　　　　String carName;
　　　　String carType;
　　　　//Wertzuweisung durch Konstruktor
　　　　public Car(String name, String type) {
　　　　　　　　this.carName = name;
　　　　　　　　this.carType = type;
　　　　}
　　　　//　private Methode
　　　　private String getCarName() {
　　　　　　　　return this.carName;
　　　　}
　　　　//innere Klasse
　　　　class Engine {
　　　　　　　　String engineType;
　　　　　　　　void setEngine() {
　　　　　　　　　　　//Zugriff auf das Attribut 'carType' von Car
　　　　　　　　　　　　if(Car.this.carType.equals("4WD");
　　　　　　　　　　　　　　　　//Aufruf der Methode getCarName() von Car
　　　　　　　　　　　　　　　　if(Car.this.getCarName().equals("Crysler")) {
　　　　　　　　　　　　　　　　　　　　this.engineType = "Kleiner";
　　　　　　　　　　　　　　　　} else {
　　　　　　　　　　　　　　　　　　　　this.engineType = "Großer";
　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　}
　　　　　　　　　　　　　　　　this.engineType = "Großer";
　　　　　　　　　　　　}
　　　　　　　　}
　　　　　　　　String getEngineType(){
　　　　　　　　　　　　return this.engineType;
　　　　　　　　}
　　　　}
}
public class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//Erstellen eines Objekts der externen Klasse 'Car'
　　　　　　　　Car car1　= new Car("Mazda", "8WD");
　　　　　　　　//Erstellen eines Objekts der inneren Klasse durch die externe Klasse
　　　　　　　　Car.Engine engine = car1.new Engine();
　　　　　　　　engine.setEngine();
　　　　　　　　System.out.println("8WD Motorart = "　+　engine.getEngineType());
　　　　　　　　Car car2　= new Car("Crysler", "4WD");
　　　　　　　　Car.Engine c2engine = car2.new Engine();
　　　　　　　　c2engine.setEngine();
　　　　　　　　System.out.println("4WD Motorart = "　+　c2engine.getEngineType());
　　　　}
}

Ausgabe:

8WD Motorart = Großer
4WD Motorart = Kleiner

Im obigen Programm haben wir in der externen Klasse 'Car' eine innere Klasse namens 'Engine'. Beachten Sie diese Zeile,

if(Car.this.carType.equals("4WD")) { ... }

Wir verwenden das Schlüsselwort 'this', um auf die Variable 'carType' der externen Klasse 'Car' zuzugreifen. Sie haben wahrscheinlich bemerkt, dass 'Car.this.carType' anstelle von 'this.carType' verwendet wird.

Dies liegt daran, dass der Schlüsselwort 'this' im Falle, dass der Name der externen Klasse 'Car' nicht erwähnt wird, den Mitgliedsstand der inneren Klasse darstellt.

Genauso erreichen wir auch Methoden der externen Klasse aus der inneren Klasse.

if (Car.this.getCarName().equals("Crysler") {...

Zu beachten ist, dass obwohl getCarName() ein privates Methode ist, wir es dennoch aus der inneren Klasse erreichen können.

Statische verpackte Klasse

In Java können wir auch eine statische (static) Klasse in einer anderen Klasse definieren. Diese Klasse wird als statische verpackte Klasse (static nested class) bezeichnet. Eine statische verpackte Klasse wird nicht als statische innere Klasse bezeichnet.

Im Gegensatz zur inneren Klasse kann die statische verpackte Klasse keine Mitglieder der externen Klasse zugreifen. Dies liegt daran, dassStatische verpackte KlasseEs ist nicht erforderlich, eine Instanz der externen Klasse zu erstellen.

OuterClass.NestedClass obj = new OuterClass.NestedClass();

Hier erstellen wir ein Objekt, indem wir den Namen der externen Klasse verwenden:Statische verpackte Klasse. Das bedeutet, dass man die externe Klasse nicht mit OuterClass.this referenzieren kann.

Beispiel3: Statische innere Klasse

class MotherBoard {
　　　//Statische verpackte Klasse
　　　static class USB{
　　　　　　　int usb2　=　2;
　　　　　　　int usb3　=　1;
　　　　　　　int getTotalPorts(){
　　　　　　　　　　　return usb2　+　usb3;
　　　　　　　}
　　　}
}
public class Main {
　　　public static void main(String[] args) {
　　　　　　　//Erstellen Sie ein Objekt einer statischen verpackten Klasse
　　　　　　　//Verwenden Sie den Namen der externen Klasse
　　　　　　　MotherBoard.USB usb = new MotherBoard.USB();
　　　　　　　System.out.println("GesamtPorts = ");　+　usb.getTotalPorts());
　　　}
}

Ausgabe:

GesamtPorts =　3

Im obigen Programm erstellen wir in der Klasse MotherBoard eine statische Klasse namens USB. Beachten Sie diese Zeile:

MotherBoard.USB usb = new MotherBoard.USB();

Hier erstellen wir ein USB-Objekt durch Verwendung des Namens der externen Klasse.

Nun, lassen Sie uns sehen, was passiert, wenn wir versuchen, die Mitglieder der externen Klasse zu erreichen:

Beispiel4: Zugriff auf die Mitglieder der externen Klasse innerhalb einer statischen inneren Klasse

class MotherBoard {
　　　String model;
　　　public MotherBoard(String model) {
　　　　　　　this.model = model;
　　　}
　　　//Statische verpackte Klasse
　　　static class USB{
　　　　　　　int usb2　=　2;
　　　　　　　int usb3　=　1;
　　　　　　　int getTotalPorts(){
　　　　　　　　　　　//Zugriff auf die Variable model der externen Klasse
　　　　　　　　　　　if(MotherBoard.this.model.equals("MSI")) {
　　　　　　　　　　　　　　　return　4;
　　　　　　　　　　　}
　　　　　　　　　　　else {
　　　　　　　　　　　　　　　return usb2　+　usb3;
　　　　　　　　　　　}
　　　　　　　}
　　　}
}
public class Main {
　　　public static void main(String[] args) {
　　　　　　　//Erstellen Sie ein Objekt einer statischen verpackten Klasse
　　　　　　　MotherBoard.USB usb = new MotherBoard.USB();
　　　　　　　System.out.println("GesamtPorts = ");　+　usb.getTotalPorts());
　　　}
}

Wenn wir versuchen, das Programm auszuführen, tritt ein Fehler auf:

error: non-static variable this kann nicht aus einem statischen Kontext referenziert werden

Dies liegt daran, dass wir keine Objekte der äußeren Klasse verwenden, um Objekte der eingebetteten Klasse zu erstellen. Daher gibt es keine Referenz, die im Motherboard.this-Objekt gespeichert ist, das die äußere Klasse Motherboard ist.

Zu beachtende Punkte

• Java betrachtet eingebettete Klassen als reguläre Klassenmitglieder. Sie sind so, als wären sie Methoden und Variablen in der Klasse deklariert.

• Da die interne Klasse ein Mitglied der äußeren Klasse ist, können auf die interne Klasse alle Zugriffsmodifikatoren (wie private, protected) angewendet werden, was in einer normalen Klasse nicht möglich ist.

• Da die eingebettete Klasse ein Mitglied der äußeren Klasse ist, können Sie den Punkt (.)-Notation verwenden, um auf die eingebettete Klasse und ihre Mitglieder zuzugreifen.

• Durch die Verwendung eingebetteter Klassen wird Ihr Code lesbarer und besser verpackt.

• Nicht statische eingebettete Klassen (Innerklassen) können auf das Äußere zugreifen/Andere Mitglieder der geschlossenen Klasse, selbst wenn sie als privat deklariert sind, sind ebenfalls geschützt.