Java - Classes internes

Dans ce chapitre, nous aborderons les classes internes de Java.

Classes imbriquées

En Java, tout comme les méthodes, les variables d'une classe peuvent également avoir une autre classe comme membre. L'écriture d'une classe dans une autre est autorisée en Java. La classe écrite à l'intérieur s'appelle la classe imbriquée , et la classe qui contient la classe interne est appelée la classe externe .

Syntaxe

Voici la syntaxe pour écrire une classe imbriquée. Ici, la classe Outer_Demo est la classe externe et la classe Inner_Demo est la classe imbriquée.

class Outer_Demo {
   class Inner_Demo {
   }
}

Les classes imbriquées sont divisées en deux types −

• Classes imbriquées non statiques − Ce sont les membres non statiques d'une classe.

• Classes imbriquées statiques − Ce sont les membres statiques d'une classe.

Classes internes (classes imbriquées non statiques)

Les classes internes sont un mécanisme de sécurité en Java. Nous savons qu'une classe ne peut pas être associée au modificateur d'accès private , mais si nous avons la classe en tant que membre d'une autre classe, la classe interne peut être rendue privée. Et ceci est également utilisé pour accéder aux membres privés d'une classe.

Les classes internes sont de trois types selon comment et où vous les définissez. Ils sont −

• Classe intérieure
• Classe interne locale à la méthode
• Classe interne anonyme

Classe intérieure

Créer une classe interne est assez simple. Il vous suffit d'écrire une classe dans une classe. Contrairement à une classe, une classe interne peut être privée et une fois que vous avez déclaré une classe interne privée, elle n'est plus accessible à partir d'un objet extérieur à la classe.

Voici le programme pour créer une classe interne et y accéder. Dans l'exemple donné, nous rendons la classe interne privée et accédons à la classe via une méthode.

Exemple

Démo en direct

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();
   }
}

Ici, vous pouvez observer que Outer_Demo est la classe externe, Inner_Demo est la classe interne, display_Inner() est la méthode à l'intérieur de laquelle nous instancions la classe interne, et cette méthode est invoquée depuis le main méthode.

Si vous compilez et exécutez le programme ci-dessus, vous obtiendrez le résultat suivant −

Sortie

This is an inner class.

Accéder aux membres privés

Comme mentionné précédemment, les classes internes sont également utilisées pour accéder aux membres privés d'une classe. Supposons qu'une classe ait des membres privés pour y accéder. Écrivez-y une classe interne, renvoyez les membres privés d'une méthode de la classe interne, par exemple, getValue() , et enfin depuis une autre classe (dont vous souhaitez accéder aux membres privés) appelez la méthode getValue() de la classe interne.

Pour instancier la classe interne, vous devez d'abord instancier la classe externe. Ensuite, en utilisant l'objet de la classe externe, voici la manière dont vous pouvez instancier la classe interne.

Outer_Demo outer = new Outer_Demo();
Outer_Demo.Inner_Demo inner = outer.new Inner_Demo();

Le programme suivant montre comment accéder aux membres privés d'une classe à l'aide de la classe interne.

Exemple

Démo en direct

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());
   }
}

Si vous compilez et exécutez le programme ci-dessus, vous obtiendrez le résultat suivant −

Sortie

This is the getnum method of the inner class: 175

Méthode-classe interne locale

En Java, nous pouvons écrire une classe dans une méthode et ce sera un type local. Comme les variables locales, la portée de la classe interne est restreinte au sein de la méthode.

Une classe interne locale à la méthode peut être instanciée uniquement dans la méthode où la classe interne est définie. Le programme suivant montre comment utiliser une classe interne de méthode locale.

Exemple

Démo en direct

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();	   	   
   }
}

Si vous compilez et exécutez le programme ci-dessus, vous obtiendrez le résultat suivant −

Sortie

This is method inner class 23

Classe interne anonyme

Une classe interne déclarée sans nom de classe est appelée classe interne anonyme . Dans le cas de classes internes anonymes, nous les déclarons et les instancions en même temps. Généralement, ils sont utilisés chaque fois que vous devez remplacer la méthode d'une classe ou d'une interface. La syntaxe d'une classe interne anonyme est la suivante −

Syntaxe

AnonymousInner an_inner = new AnonymousInner() {
   public void my_method() {
      ........
      ........
   }   
};

Le programme suivant montre comment remplacer la méthode d'une classe à l'aide d'une classe interne anonyme.

Exemple

Démo en direct

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();	
   }
}

Si vous compilez et exécutez le programme ci-dessus, vous obtiendrez le résultat suivant −

Sortie

This is an example of anonymous inner class

De la même manière, vous pouvez surcharger les méthodes de la classe concrète ainsi que l'interface à l'aide d'une classe interne anonyme.

Classe interne anonyme comme argument

Généralement, si une méthode accepte un objet d'une interface, une classe abstraite ou une classe concrète, nous pouvons implémenter l'interface, étendre la classe abstraite et transmettre l'objet à la méthode. S'il s'agit d'une classe, nous pouvons la transmettre directement à la méthode.

Mais dans les trois cas, vous pouvez passer une classe interne anonyme à la méthode. Voici la syntaxe de passage d'une classe interne anonyme comme argument de méthode −

obj.my_Method(new My_Class() {
   public void Do() {
      .....
      .....
   }
});

Le programme suivant montre comment passer une classe interne anonyme comme argument de méthode.

Exemple

Démo en direct

// 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";
         }
      });
   }
}

Si vous compilez et exécutez le programme ci-dessus, il vous donne le résultat suivant −

Sortie

Hello, This is an example of anonymous inner class as an argument

Classe imbriquée statique

Une classe interne statique est une classe imbriquée qui est un membre statique de la classe externe. Il est possible d'y accéder sans instancier la classe externe, en utilisant d'autres membres statiques. Tout comme les membres statiques, une classe imbriquée statique n'a pas accès aux variables d'instance et aux méthodes de la classe externe. La syntaxe de la classe imbriquée statique est la suivante −

Syntaxe

class MyOuter {
   static class Nested_Demo {
   }
}

L'instanciation d'une classe imbriquée statique est un peu différente de l'instanciation d'une classe interne. Le programme suivant montre comment utiliser une classe imbriquée statique.

Exemple

Démo en direct

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();
   }
}

Si vous compilez et exécutez le programme ci-dessus, vous obtiendrez le résultat suivant −

Sortie

This is my nested class