Innere Java-Klassen

In Java können einige Klassen andere Klassen enthalten. Solche Klassen werden verschachtelte Klassen genannt. Klassen, die in anderen Klassen definiert sind, lassen sich im Allgemeinen in zwei Kategorien einteilen: statisch und nicht statisch. Verschachtelte nicht statische Klassen werden als innere Klassen bezeichnet. Verschachtelte Klassen, die als statisch deklariert sind, werden als statisch verschachtelte Klassen bezeichnet. Tatsächlich gibt es hier nichts Kompliziertes, obwohl die Terminologie etwas unscharf erscheint und manchmal sogar einen professionellen Softwareentwickler verwirren kann.

Verschachtelte und innere Klassen

Daher werden alle Klassen, die sich innerhalb anderer Klassen befinden, als verschachtelte Klassen bezeichnet.

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

Verschachtelte Klassen, die nicht statisch sind, werden als innere Klassen bezeichnet , und diejenigen, die statisch sind, werden als statische verschachtelte Klassen bezeichnet . Innere Java-Klassen – 1

class OuterClass {
    ...
    static class StaticNestedClass {
        ...
    }
    class InnerClass {
        ...
    }
}

Daher sind alle inneren Klassen verschachtelt, aber nicht alle verschachtelten Klassen sind inner. Dies sind die wichtigsten Definitionen. Innere Klassen sind eine Art Sicherheitsmechanismus in Java. Wir wissen, dass einer gewöhnlichen Klasse kein privater Zugriffsmodifikator zugeordnet werden kann. Wenn unsere Klasse jedoch Mitglied einer anderen Klasse ist, kann die innere Klasse privat gemacht werden. Diese Funktion wird auch für den Zugriff auf private Klassenmitglieder verwendet.

Beispiel für eine innere Klasse

Versuchen wir also, eine Klasse zu erstellen und darin eine weitere Klasse. Stellen Sie sich eine Art modulare Spielekonsole vor. Es gibt eine „Box“ selbst, an die bestimmte Module angeschlossen werden können. Zum Beispiel ein Gamecontroller, ein Lenkrad, ein VR-Helm, die ohne die Konsole selbst in der Regel nicht funktionieren. Hier haben wir die GameConsole-Klasse. Es hat 2 Felder und 1 Methode – start() . Der Unterschied zwischen GameCosole und der Klasse, die wir gewohnt sind, besteht darin, dass sie über eine interne GameController- Klasse verfügt.

public class GameConsole {
    private String model;
    private int weight;

    public void run() {
        System.out.println("Game console is on");
    }


    public class GameController {

        private String color;

        public void start() {
            System.out.println("start button is pressed");
        }

        public void x() {
            System.out.println("x button is pressed");
        }

        public void y() {
            System.out.println("y button is pressed");
        }
        public void a() {
            System.out.println("a button is pressed");
        }

        public void b() {
            System.out.println("b button is pressed");
        }
        public void mover() {
            System.out.println("mover button is pressed");
        }

    }

}

An diesem Punkt fragen Sie sich vielleicht: Warum machen Sie diese Klassen nicht „getrennt“? Es ist nicht notwendig, sie zu verschachteln. Tatsächlich ist es möglich. Vielmehr geht es um die richtige Gestaltung von Klassen hinsichtlich ihrer Verwendung. Innere Klassen werden erstellt, um im Programm eine Entität hervorzuheben, die untrennbar mit einer anderen Entität verbunden ist. Ein Controller oder beispielsweise ein VR-Helm sind Bestandteile der Konsole. Ja, sie können separat von der Konsole gekauft werden, können aber nicht ohne sie verwendet werden. Wenn wir alle diese Klassen zu separaten öffentlichen Klassen machen würden, könnte unser Programm beispielsweise den folgenden Code haben:

public class Main {

   public static void main(String[] args) {
       GameController controller = new GameController();
       controller.x();
   }
}

Was in diesem Fall passiert, ist nicht klar, da der Controller selbst ohne Konsole nicht funktioniert. Wir haben ein Spielekonsolenobjekt erstellt. Wir haben sein Unterobjekt erstellt – den Gamecontroller. Und jetzt können wir spielen, drücken Sie einfach die richtigen Tasten. Die von uns benötigten Methoden werden für die richtigen Objekte aufgerufen. Alles ist einfach und bequem. In diesem Beispiel verbessert das Extrahieren des Gamecontrollers die Kapselung (wir verbergen die Details der Konsolenteile innerhalb der entsprechenden Klasse) und ermöglicht eine detailliertere Abstraktion. Wenn wir jedoch beispielsweise ein Programm erstellen, das ein Geschäft simuliert, in dem Sie einen VR-Helm oder einen VR-Controller separat kaufen können, wird dieses Beispiel scheitern. Da ist es besser, einen Gamecontroller separat zu erstellen. Nehmen wir ein anderes Beispiel. Wir haben oben erwähnt, dass wir die innere Klasse privat machen und sie trotzdem von der äußeren Klasse aus aufrufen können. Nachfolgend finden Sie ein Beispiel für solche Klassen.

class OuterClass {

   // inner class
   private class InnerClass {
       public void print() {
           System.out.println("We are in the inner class...");
       }
   }

   // method of outer class. We are create an inner class from the method of outer one
   void display() {
       InnerClass inner = new InnerClass();
       inner.print();
   }
}

Hier ist die OuterClass die äußere Klasse, die InnerClass die innere Klasse und display() die Methode, in der wir ein Objekt der inneren Klasse erstellen. Schreiben wir nun eine Demo-Klasse mit einer Hauptmethode, in der wir die Methode display() aufrufen .

public class OuterDemoMain {

       public static void main(String args[]) {
           // create an object of the outer class
           OuterDemo outer = new OuterDemo();

           outer.display();
       }
}

Wenn Sie dieses Programm ausführen, erhalten Sie das folgende Ergebnis:

Wir sind in der inneren Klasse...

Klassifizierung innerer Klassen

Die inneren Klassen selbst oder verschachtelte nicht statische Klassen lassen sich in drei Gruppen einteilen.

Innere Klasse wie sie ist. Nur eine nicht statische Klasse innerhalb der anderen, wie wir oben am Beispiel von GameConsole und GameController gezeigt haben .
Methodenlokale innere Klasse ist eine Klasse innerhalb einer Methode.
Anonyme innere Klasse.

Methode lokal Innere Klasse

In Java können Sie eine Klasse innerhalb einer Methode schreiben und es handelt sich dabei um einen lokalen Typ. Wie bei lokalen Variablen ist der Umfang einer inneren Klasse innerhalb einer Methode begrenzt. Eine methodenlokale innere Klasse kann nur innerhalb der Methode erstellt werden, in der die innere Klasse definiert ist. Lassen Sie uns demonstrieren, wie die innere Klasse der lokalen Methode verwendet wird.

public class OuterDemo2 {

   //instance method of the outer class OuterDemo2
   void myMethod() {
       String str = "and it's a value from OuterDemo2 class' myMethod ";

       // method-local inner class
       class methodInnerDemo {
           public void print() {
               System.out.println("Here we've got a method inner class... " );
               System.out.println(str);

           }
       }

       // Access to the inner class
       methodInnerDemo inn = new methodInnerDemo();
       inn.print();
   }
}

Jetzt schreiben wir eine Demo-Klasse mit einer Hauptmethode, in der wir die Methode „outer()“ aufrufen .

public class OuterDemoMain {


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

Die Ausgabe ist:

Hier haben wir eine Methode der inneren Klasse ... und es ist ein Wert aus der OuterDemo2-Klasse „myMethod“.

Anonyme innere Klasse

Eine ohne Klassennamen deklarierte innere Klasse wird als anonyme innere Klasse bezeichnet. Wenn wir eine anonyme innere Klasse deklarieren, instanziieren wir sie sofort. Typischerweise werden solche Klassen immer dann verwendet, wenn Sie eine Klasse oder Schnittstellenmethode überschreiben müssen.

abstract class OuterDemo3 {
   public abstract void method();

}
   class outerClass {

       public static void main(String args[]) {
           OuterDemo3 inner = new OuterDemo3() {
               public void method() {
                   System.out.println("Here we've got an example of an  anonymous inner class");
               }
           };
           inner.method();
       }
   }

Die Ausgabe ist hier:

Hier haben wir ein Beispiel für eine anonyme innere Klasse ...

Anonyme innere Klasse als Argument

Sie können der Methode auch eine anonyme innere Klasse als Argument übergeben. Hier ist ein Beispiel.

interface OuterDemo4 {
       String hello();
   }

   class NewClass {
       // accepts the object of interface
       public void displayMessage(OuterDemo4 myMessage) {
           System.out.println(myMessage.hello());
           System.out.println("example of anonymous inner class as an argument");
       }

       public static void main(String args[]) {
           NewClass newClass = new NewClass();

           //here we pass an anonymous inner class as an argument
           newClass.displayMessage(new OuterDemo4() {
               public String hello() {
                   return "Hello!";
               }
           });
       }
}

Die Ausgabe ist hier:

Hallo! Beispiel einer anonymen inneren Klasse als Argument

Um das Gelernte zu vertiefen, empfehlen wir Ihnen, sich eine Videolektion aus unserem Java-Kurs anzusehen