Java verschachtelte und innere Klasse

Java Nested und Inner Class

In diesem Tutorial lernen Sie die verschachtelte Klasse in Java und ihre Typen anhand von Beispielen kennen.

In Java können Sie eine Klasse innerhalb einer anderen Klasse definieren. Eine solche Klasse ist als nested class bekannt . Zum Beispiel

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

Es gibt zwei Arten von verschachtelten Klassen, die Sie in Java erstellen können.

Nicht statische verschachtelte Klasse (innere Klasse)
Statische verschachtelte Klasse

Empfohlene Lektüre :

Java-Zugriffsmodifikatoren
Statisches Java-Schlüsselwort

Sehen wir uns zuerst nicht-statische verschachtelte Klassen an.

Nicht statische verschachtelte Klasse (innere Klasse)

Eine nicht statische verschachtelte Klasse ist eine Klasse innerhalb einer anderen Klasse. Sie hat Zugriff auf Mitglieder der einschließenden Klasse (äußere Klasse). Es ist allgemein als inner class bekannt .

Seit dem inner class innerhalb der äußeren Klasse existiert, müssen Sie zuerst die äußere Klasse instanziieren, um die innere Klasse zu instanziieren.

Hier ist ein Beispiel dafür, wie Sie innere Klassen in Java deklarieren können.

Beispiel 1:Innere Klasse

class CPU {
    double price;
    // nested class
    class Processor{

        // members of nested class
        double cores;
        String manufacturer;

        double getCache(){
            return 4.3;
        }
    }

    // nested protected class
    protected class RAM{

        // members of protected nested class
        double memory;
        String manufacturer;

        double getClockSpeed(){
            return 5.5;
        }
    }
}

public class Main {
    public static void main(String[] args) {

        // create object of Outer class CPU
        CPU cpu = new CPU();

       // create an object of inner class Processor using outer class
        CPU.Processor processor = cpu.new Processor();

        // create an object of inner class RAM using outer class CPU
        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 äußeren Klasse:CPU . Wir können die innere Klasse als geschützt deklarieren. Daher haben wir die RAM-Klasse als geschützt deklariert.

Innerhalb der Main-Klasse

Wir haben zuerst eine Instanz einer äußeren Klasse CPU erstellt namens cpu .
Mit der Instanz der äußeren Klasse haben wir dann Objekte der inneren Klassen erstellt:
```
CPU.Processor processor = cpu.new Processor;

CPU.RAM ram = cpu.new RAM();
```

Hinweis :Wir verwenden den Punkt (. )-Operator zum Erstellen einer Instanz der inneren Klasse unter Verwendung der äußeren Klasse.

Zugriff auf Mitglieder der äußeren Klasse innerhalb der inneren Klasse

Mit diesem Schlüsselwort können wir auf die Mitglieder der äußeren Klasse zugreifen. Wenn Sie mehr über dieses Schlüsselwort erfahren möchten, besuchen Sie Java this keyword.

Beispiel 2:Zugriff auf Mitglieder

class Car {
    String carName;
    String carType;

    // assign values using constructor
    public Car(String name, String type) {
        this.carName = name;
        this.carType = type;
    }

    // private method
    private String getCarName() {
        return this.carName;
    }

// inner class
    class Engine {
        String engineType;
        void setEngine() {

           // Accessing the carType property of Car
            if(Car.this.carType.equals("4WD")){

                // Invoking method getCarName() of Car
                if(Car.this.getCarName().equals("Crysler")) {
                    this.engineType = "Smaller";
                } else {
                    this.engineType = "Bigger";
                }

            }else{
                this.engineType = "Bigger";
            }
        }
        String getEngineType(){
            return this.engineType;
        }
    }
}

public class Main {
    public static void main(String[] args) {

// create an object of the outer class Car
        Car car1 = new Car("Mazda", "8WD");

        // create an object of inner class using the outer class
        Car.Engine engine = car1.new Engine();
        engine.setEngine();
        System.out.println("Engine Type for 8WD= " + engine.getEngineType());

        Car car2 = new Car("Crysler", "4WD");
        Car.Engine c2engine = car2.new Engine();
        c2engine.setEngine();
        System.out.println("Engine Type for 4WD = " + c2engine.getEngineType());
    }
}

Ausgabe :

Engine Type for 8WD= Bigger
Engine Type for 4WD = Smaller

Im obigen Programm haben wir die innere Klasse namens Engine im Auto der äußeren Klasse . Beachten Sie hier die Zeile,

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

Wir verwenden this Schlüsselwort, um auf carType zuzugreifen Variable der äußeren Klasse. Sie haben vielleicht bemerkt, dass anstelle von this.carType wir haben Car.this.carType verwendet .

Es liegt daran, dass wir den Namen der äußeren Klasse Auto nicht erwähnt hätten , dann this Das Schlüsselwort repräsentiert das Mitglied innerhalb der inneren Klasse.

Ebenso greifen wir auch von der inneren Klasse auf die Methode der äußeren Klasse zu.

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

Es ist wichtig zu beachten, dass, obwohl der getCarName() ist ein private -Methode können wir von der inneren Klasse darauf zugreifen.

Statisch verschachtelte Klasse

In Java können wir auch einen static definieren Klasse innerhalb einer anderen Klasse. Eine solche Klasse ist als static nested class bekannt . Statisch verschachtelte Klassen werden nicht als statische innere Klassen bezeichnet.

Anders als die innere Klasse kann eine statisch verschachtelte Klasse nicht auf die Mitgliedsvariablen der äußeren Klasse zugreifen. Das liegt an der statisch verschachtelten Klasse erfordert nicht, dass Sie eine Instanz der äußeren Klasse erstellen.

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

Hier erstellen wir ein Objekt der statisch verschachtelten Klasse indem Sie einfach den Klassennamen der äußeren Klasse verwenden. Daher kann die äußere Klasse nicht mit OuterClass.this referenziert werden .

Beispiel 3:Statische innere Klasse

class MotherBoard {

   // static nested class
   static class USB{
       int usb2 = 2;
       int usb3 = 1;
       int getTotalPorts(){
           return usb2 + usb3;
       }
   }

}
public class Main {
   public static void main(String[] args) {

       // create an object of the static nested class
       // using the name of the outer class
       MotherBoard.USB usb = new MotherBoard.USB();
       System.out.println("Total Ports = " + usb.getTotalPorts());
   }
}

Ausgabe :

Total Ports = 3

Im obigen Programm haben wir eine statische Klasse namens USB erstellt innerhalb der Klasse MotherBoard . Beachten Sie die Zeile,

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

Hier erstellen wir ein Objekt von USB unter Verwendung des Namens der äußeren Klasse.

Sehen wir uns nun an, was passieren würde, wenn Sie versuchen würden, auf die Mitglieder der äußeren Klasse zuzugreifen:

Beispiel 4:Zugriff auf Mitglieder der äußeren Klasse innerhalb der statischen inneren Klasse

class MotherBoard {
   String model;
   public MotherBoard(String model) {
       this.model = model;
   }

   // static nested class
   static class USB{
       int usb2 = 2;
       int usb3 = 1;
       int getTotalPorts(){
           // accessing the variable model of the outer classs
           if(MotherBoard.this.model.equals("MSI")) {
               return 4;
           }
           else {
               return usb2 + usb3;
           }
       }
   }
}
public class Main {
   public static void main(String[] args) {

       // create an object of the static nested class
       MotherBoard.USB usb = new MotherBoard.USB();
       System.out.println("Total Ports = " + usb.getTotalPorts());
   }
}

Wenn wir versuchen, das Programm auszuführen, erhalten wir eine Fehlermeldung:

error: non-static variable this cannot be referenced from a static context

Dies liegt daran, dass wir das Objekt der äußeren Klasse nicht verwenden, um ein Objekt der inneren Klasse zu erstellen. Daher gibt es keinen Verweis auf die äußere Klasse Motherboard gespeichert in Motherboard.this .

Wichtige Punkte, an die Sie sich erinnern sollten

Java behandelt die innere Klasse als reguläres Mitglied einer Klasse. Sie sind genau wie Methoden und Variablen, die innerhalb einer Klasse deklariert werden.
Da innere Klassen Mitglieder der äußeren Klasse sind, können Sie beliebige Zugriffsmodifikatoren wie private anwenden , protected zu deiner inneren Klasse, was im normalen Unterricht nicht möglich ist.
Da die verschachtelte Klasse ein Mitglied ihrer einschließenden äußeren Klasse ist, können Sie den Punkt (. )-Notation, um auf die verschachtelte Klasse und ihre Mitglieder zuzugreifen.
Die Verwendung der verschachtelten Klasse macht Ihren Code lesbarer und bietet eine bessere Kapselung.
Nicht statische verschachtelte Klassen (innere Klassen) haben Zugriff auf andere Mitglieder der äußeren/einschließenden Klasse, selbst wenn sie als privat deklariert sind.

Java-Kapselung Verschachtelte statische Java-Klasse

Java