Java

Appelez-nous au numéro (+212) 616 374 790 ou écrivez-nous à essaddouki@gmail.com

Demander le soutien en ligne de l'un de nos professeurs, à toute heure et où vous voulez, de 8h à minuit (GMT) Détails

Les classes imbriquées en Java

Chaque classe que vous avez étudiée jusqu'à présent a été stockée dans son propre fichier et le nom du fichier a toujours correspondu au nom de la classe. En Java, vous pouvez créer une classe dans une autre classe et les stocker ensemble. ces classes sont des classes imbriquées. La classe conteneur est la classe de niveau supérieur (externe). Il existe quatre types de classes imbriquées:

  •   classes imbriquées statiques : classe imbriquée statique a accès à toutes les méthodes statiques de la classe de niveau supérieur.
  •   Classes membres non statiques, également appelées classes internes: Ce type de classe nécessite une instance; il a accès à toutes les données et méthodes de la classe de niveau supérieur.
  •   Classes locales: elles sont locales à un bloc.
  •   classes anonymes: Ce sont des classes locales sans identifiant.

La raison la plus courante d'imbriquer une classe dans une autre est que la classe interne n'est utilisée que par la classe de niveau supérieur; en d'autres termes, il s'agit d'une «classe d'assistance» pour la classe de niveau supérieur.
Pouvoir regrouper les classes facilite la compréhension de leur connexion et la maintenance de leur code.

Classes imbriquées statiques

Comme pour les méthodes et variables de classe, une classe imbriquée statique est associée à sa classe externe. Et comme les méthodes de classe statiques, une classe imbriquée statique ne peut pas faire directement référence à des variables d’instance ni à des méthodes définies dans sa classe englobante: elle ne peut les utiliser que via une référence d’objet.

elles sont accessibles en utilisant le nom de la classe englobante (externe).

                                classeExterne.classeStatic
                            

Par exemple, pour créer un objet pour la classe statique imbriquée, utilisez la syntaxe suivante:

                                classeExterne.classeStatic obj= new classeExterne.classeStatic();
                            
Exemple 1 :
                                    public class Test {

                                        static class classeStatic {
                                            public void afficher() {
                                                System.out.println("La classe imbriquée");
                                            }
                                        }
                                    
                                        public static void main(String args[]) {
                                            Test.classeStatic obj = new Test.classeStatic();
                                            obj.afficher();
                                        }
                                    }
                            
La classe imbriquée

Lorsqu’on compile l’exemple ci-dessus, deux fichiers sont produits :

Test.class
Test$classeStatic.class

Classes internes

Les classes internes constituent 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.

La classe interne peut accéder à n’importe quelle variable d’instance privée de la classe externe. Comme toute autre variable d'instance, nous pouvons avoir les modificateurs d'accès private, protected, public et default.

Comme pour une classe, l'interface peut également être imbriquée et avoir des spécificateurs d'accès.

Exemple 2 :
                                    public class Test {

                                        private int val;
                                    
                                        public class classeInterne {
                                            public void afficher() {
                                                val = 2;
                                                System.out.println("La classe interne");
                                                System.out.println("val : " + val);
                                            }
                                        }
                                    
                                        public static void main(String args[]) {
                                            Test obj = new Test();
                                            Test.classeInterne interne = obj.new classeInterne();
                                            interne.afficher();
                                        }
                                    }
                            
La classe interne
val : 2
  nous ne pouvons pas avoir de méthode statique dans une classe interne, car une classe interne est associée implicitement à un objet de sa classe externe; elle ne peut donc pas définir de méthode statique pour elle-même.

Les classes internes locales

Les classes internes locales sont les classes internes définies dans un bloc. Généralement, ce bloc est un corps de méthode. Parfois, ce bloc peut être une boucle for ou une clause if.

Les classes internes locales ne sont membres d'aucune classe englobante. Ils appartiennent au bloc dans lequel elles sont définies, en raison desquels les classes internes locales ne peuvent être associées à aucun modificateur d'accès. Cependant, elles peuvent être marquées comme final ou abstract. Cette classe a accès aux champs de la classe qui l’entoure. La classe interne locale doit être instanciée dans le bloc dans lequel elles sont définies.

Exemple 3 :
                                    public class Test {

                                        private int val;
                                    
                                        public void afficher() {
                                            int s = 3;
                                            class localClass {
                                                private int val;
                                    
                                                public void incrementer() {
                                                    val = s + 20;
                                                    System.out.println("val : " + val);
                                                }
                                            }
                                    
                                            localClass loc = new localClass();
                                            loc.incrementer();
                                        }
                                    
                                        public static void main(String args[]) {
                                            Test obj = new Test();
                                            obj.afficher();
                                        }
                                    }
                            
val : 23
  Remarque !  Une classe locale peut accéder aux variables et paramètres locaux du bloc englobant qui sont effectivement final.

Les classes internes anonymes

Une classe interne anonyme est une classe qui n'a pas de nom et qui est définie dans une autre classe. Vous créez une classe interne anonyme pour enregistrer certains travaux lorsque vous avez besoin d'une classe simple instanciée une seule fois dans un programme.

Vous utilisez l'opérateur new pour créer une classe interne, et créer simultanément une instance de celle-ci. L'instance hérite d'une super-classe ou implémente une interface, mais vous n'utilisez pas les mots-clés extends ou implements lors de la définition de la classe.

Exemple 4 :
                                    interface Forme {
                                        void affiche();
                                    }
                                    
                                    public class Test {
                                    
                                        public static void main(String args[]) {
                                            String msg = "Hello, ";
                                            Forme rectangle = new Forme() {
                                                @Override
                                                public void affiche() {
                                                    System.out.println(msg + "je suis une classe interne anonyme");
                                                }
                                            };
                                    
                                            rectangle.affiche();
                                        }
                                    }
                            
Hello, je suis une classe interne anonyme

Une classe interne anonyme doit implémenter une interface ou hériter d'une autre classe. (Si elle hérite d'une classe, la superclasse doit avoir un constructeur par défaut qui s'exécute lorsque le nouvel objet est créé.) Une classe interne anonyme doit redéfinir toutes les méthodes abstraites contenues dans l'interface ou la superclasse.

Une classe interne anonyme peut accéder aux variables de la méthode dans laquelle elle réside, à condition que les variables soient déclarées avant la définition de la classe anonyme. Toutefois, les variables utilisées doivent être final ou effectivement final. Une variable effectivement final est une variable dont la valeur n'est attribuée qu'une seule fois.

Partager ce cours avec tes amis :

Rédigé par M. ESSADDOUKI

Learning a new programming language is an easy thing, but the most difficult thing is how to design efficient algorithms for real-world problems, so don't be a programmer, be a problems solver.

Cours Similaires :