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();
}
}
Lorsqu’on compile l’exemple ci-dessus, deux fichiers sont produits :
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();
}
}
val : 2
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();
}
}
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();
}
}
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.
