Java - Innere Klassen

In diesem Kapitel werden wir innere Klassen von Java besprechen.

Verschachtelte Klassen

Genau wie Methoden können in Java auch Variablen einer Klasse eine andere Klasse als Mitglied haben. Das Schreiben einer Klasse innerhalb einer anderen ist in Java erlaubt. Die darin geschriebene Klasse wird verschachtelte Klasse genannt , und die Klasse, die die innere Klasse enthält, wird als äußere Klasse bezeichnet .

Syntax

Es folgt die Syntax zum Schreiben einer verschachtelten Klasse. Hier die Klasse Outer_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 −

• Nicht statische verschachtelte Klassen − Dies sind die nicht statischen Mitglieder einer Klasse.

• Statisch verschachtelte Klassen − Dies sind die statischen Mitglieder einer Klasse.

Innere Klassen (nicht statische verschachtelte Klassen)

Innere Klassen sind ein Sicherheitsmechanismus in Java. Wir wissen, dass eine Klasse nicht mit dem Zugriffsmodifikator private verknüpft werden kann , aber wenn wir die Klasse als Mitglied einer anderen Klasse haben, kann die innere Klasse privat gemacht werden. Und 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, und sobald Sie eine innere Klasse als privat deklariert haben, kann von einem Objekt außerhalb der Klasse nicht mehr darauf zugegriffen werden.

Es folgt das Programm zum Erstellen einer inneren Klasse und zum Zugreifen darauf. Im angegebenen Beispiel machen wir die innere Klasse privat und greifen über eine Methode auf die Klasse zu.

Beispiel

Live-Demo

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 diese Outer_Demo beobachten 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 main aufgerufen Methode.

Wenn Sie das obige Programm kompilieren und ausführen, erhalten Sie das folgende Ergebnis −

Ausgabe

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, sagen wir, getValue() , und schließlich von einer anderen Klasse (von der aus Sie auf die privaten Member zugreifen möchten) rufen Sie die Methode getValue() der inneren Klasse auf.

Um die innere Klasse zu instanziieren, müssen Sie zunächst die äußere Klasse instanziieren. Danach können Sie unter Verwendung 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 man mit inner class.

auf die privaten Mitglieder einer Klasse zugreift

Beispiel

Live-Demo

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 −

Ausgabe

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 wird ein lokaler Typ sein. Wie bei lokalen Variablen ist der Geltungsbereich 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 man eine Methoden-lokale innere Klasse verwendet.

Beispiel

Live-Demo

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 −

Ausgabe

This is method inner class 23

Anonyme innere Klasse

Eine ohne Klassenname deklarierte innere Klasse wird als anonyme innere Klasse bezeichnet . 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 man die Methode einer Klasse mit anonymer innerer Klasse überschreibt.

Beispiel

Live-Demo

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 −

Ausgabe

This is an example of anonymous inner class

Auf die gleiche Weise können Sie die Methoden der konkreten Klasse sowie die Schnittstelle mit 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.

Aber in allen drei Fällen können Sie der Methode 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.

Beispiel

Live-Demo

// 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 −

Ausgabe

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. Es kann darauf zugegriffen werden, ohne die äußere Klasse zu instanziieren, indem andere statische Mitglieder verwendet werden. Genau wie statische Member hat eine statisch verschachtelte Klasse keinen Zugriff auf die Instanzvariablen und Methoden der äußeren Klasse. Die Syntax der statischen verschachtelten Klasse lautet wie folgt:−

Syntax

class MyOuter {
   static class Nested_Demo {
   }
}

Das Instanziieren einer statischen verschachtelten Klasse unterscheidet sich ein wenig vom Instanziieren einer inneren Klasse. Das folgende Programm zeigt, wie eine statisch verschachtelte Klasse verwendet wird.

Beispiel

Live-Demo

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 −

Ausgabe

This is my nested class