Classes internes Java

En Java, certaines classes peuvent contenir d’autres classes. Ces classes sont appelées classes imbriquées. Les classes définies au sein d’autres classes se répartissent généralement en deux catégories : statiques et non statiques. Les classes non statiques imbriquées sont appelées internes. Les classes imbriquées déclarées statiques sont appelées classes imbriquées statiques. En fait, il n'y a rien de compliqué ici, même si la terminologie semble quelque peu floue et peut parfois dérouter même un développeur de logiciels professionnel.

Classes imbriquées et internes

Ainsi, toutes les classes situées à l’intérieur d’autres classes sont appelées classes imbriquées.

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

Les classes imbriquées qui ne sont pas statiques sont appelées classes internes , et celles qui sont statiques sont appelées classes imbriquées statiques .

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

Ainsi, toutes les classes internes sont imbriquées, mais toutes les classes imbriquées ne sont pas internes. Ce sont les principales définitions. Les classes internes sont une sorte de mécanisme de sécurité en Java. Nous savons qu'une classe ordinaire ne peut pas être associée à un modificateur d'accès privé. Cependant, si notre classe est membre d’une autre classe, alors la classe interne peut être rendue privée. Cette fonctionnalité est également utilisée pour accéder aux membres d’une classe privée.

Exemple de classe interne

Essayons donc de créer une classe et, à l'intérieur, une autre classe. Imaginez une sorte de console de jeu modulaire. Il existe une « box » elle-même, et certains modules peuvent y être connectés. Par exemple, une manette de jeu, un volant, un casque VR, qui, en règle générale, ne fonctionnent pas sans la console elle-même. Ici, nous avons la classe GameConsole. Il a 2 champs et 1 méthode — start() . La différence entre GameCosole et la classe à laquelle nous sommes habitués est qu'elle possède une classe GameController interne .

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

    }

}

À ce stade, vous vous demandez peut-être : pourquoi ne pas rendre ces classes « séparées » ? Il n’est pas nécessaire de les imbriquer. En effet, c'est possible. Il s’agit plutôt de la conception correcte des classes en termes de leur utilisation. Des classes internes sont créées pour mettre en évidence dans le programme une entité inextricablement liée à une autre entité. Une manette ou, par exemple, un casque VR sont des composants de la console. Oui, ils peuvent être achetés séparément de la console, mais ne peuvent pas être utilisés sans celle-ci. Si nous faisions en sorte que toutes ces classes soient des classes publiques séparées, notre programme pourrait avoir, par exemple, le code suivant :

public class Main {

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

Ce qui se passe dans ce cas n'est pas clair, puisque le contrôleur lui-même ne fonctionne pas sans console. Nous avons créé un objet console de jeu. Nous avons créé son sous-objet : le contrôleur de jeu. Et maintenant nous pouvons jouer, il suffit d'appuyer sur les bonnes touches. Les méthodes dont nous avons besoin sont appelées sur les bons objets. Tout est simple et pratique. Dans cet exemple, l'extraction du contrôleur de jeu améliore l'encapsulation (nous masquons les détails des parties de la console à l'intérieur de la classe correspondante) et permet une abstraction plus détaillée. Mais si nous créons, par exemple, un programme qui simule un magasin où vous pouvez acheter séparément un casque ou un contrôleur VR, cet exemple échouera. Là, il est préférable de créer un contrôleur de jeu séparément. Prenons un autre exemple. Nous avons mentionné ci-dessus que nous pouvons rendre la classe interne privée tout en l'appelant depuis la classe externe. Vous trouverez ci-dessous un exemple de telles classes.

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

Ici, OuterClass est la classe externe, InnerClass est la classe interne, display() est la méthode à l'intérieur de laquelle nous créons un objet de la classe interne. Écrivons maintenant une classe de démonstration avec une méthode principale où nous allons invoquer la méthode display() .

public class OuterDemoMain {

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

           outer.display();
       }
}

Si vous exécutez ce programme, vous obtiendrez le résultat suivant :

Classification des classes internes

Les classes internes elles-mêmes ou classes non statiques imbriquées se répartissent en trois groupes.

• Classe interne telle quelle. Juste une classe non statique dans l’autre, comme nous l’avons démontré ci-dessus avec l’exemple GameConsole et GameController .
• La classe interne de méthode locale est une classe à l’intérieur d’une méthode.
• Classe intérieure anonyme.

Méthode localeClasse interne

En Java, vous pouvez écrire une classe dans une méthode et c'est un type local. Comme les variables locales, la portée d’une classe interne est limitée au sein d’une méthode. Une classe interne locale à la méthode ne peut être créée que dans la méthode dans laquelle la classe interne est définie. Montrons comment utiliser la classe interne de la méthode locale.

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

Nous allons maintenant écrire une classe de démonstration avec une méthode principale où nous allons invoquer la méthode external() .

public class OuterDemoMain {


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

Le résultat est :

Classe interne anonyme

Une classe interne déclarée sans nom de classe est appelée classe interne anonyme. Lorsque nous déclarons une classe interne anonyme, nous l’instancions immédiatement. En règle générale, ces classes sont utilisées chaque fois que vous devez remplacer une classe ou une méthode d'interface.

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

Le résultat est ici :

Classe interne anonyme comme argument

Vous pouvez également transmettre une classe interne anonyme comme argument à la méthode. Voici un exemple.

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

Le résultat est ici : Pour renforcer ce que vous avez appris, nous vous proposons de regarder une leçon vidéo de notre cours Java