Résumé de l'utilisation des classes internes Java

1.Qu'est-ce qu'une classe interne ?63;

Une classe définie à l'intérieur d'une classe est appelée classe interne

 public class Out{
 　　class In{ //À ce moment-là, In est une classe interne
 　　} 
}

2.Pourquoi utiliser la classe interne ?63;

1)Renforcement de l'encapsulation, cachez la classe interne dans la classe externe, n'autorise pas d'autres classes à accéder à la classe interne

2)Les classes internes peuvent améliorer la lisibilité et la maintenabilité du code

3.Classification des classes internes

Pour la classification de la classe interne, elle peut être comparée à la classification des variables membres.

Nous pouvons diviser les variables membres en fonction de différents modificateurs ou emplacements de définition differents : variables membres de la classe, variables membres d'instance, variables locales.

Si la classe interne est considérée comme un membre de la classe externe, la classe interne peut utiliser public/par défaut/protected/private, peut également être static.

De la même manière, la classe interne est divisée en fonction des modificateurs utilisés ou des emplacements de définition differents4Classe :

1)Classe interne d'instance : la classe interne n'utilise pas static

2)Classe interne statique : la classe interne utilise static

3)Classe interne locale : définie dans une méthode

4)Classe interne anonyme : peut être utilisée une seule fois, une forme spéciale de la classe interne

3.1Classe interne :

1)Définition : classe interne d'instance, c'est-à-dire sans utiliser static. Cela signifie que la classe interne d'instance appartient à l'objet de la classe externe, pas à la classe externe elle-même (comme un champ).

2)Créer une classe interne d'instance

//Classe externe
class Outter {
 // Classe interne : sans utiliser le mot-clé static
 class Inner {
 }
}
public class InnerDemo1 {
 public static void main(String[] args) {
 // Créer une classe interne d'instance, sans utiliser static, appartient à l'objet de la classe externe, par conséquent, avant de créer une classe interne d'instance, il doit exister un objet de classe externe.
 Outter out = new Outter();
 // Créer un objet de classe interne à travers un objet de classe externe
 Outter.Inner in = out.new Inner();
 }
}

3) Caractéristiques :

a. Comme le processus de création de la classe interne d'instance le montre, lorsqu'il existe un objet de classe interne, il existe également un objet de classe externe.

b. L'instance de la classe interne détient automatiquement une référence à l'instance de l'extérieur, la classe interne peut accéder sans condition à tous les champs et méthodes de l'extérieur.

Attention : lorsque la classe interne de membre possède des variables ou des méthodes portant le même nom que l'extérieur, un phénomène de masquage se produit.

Le code externe ne peut pas accéder directement aux membres de la classe interne, il faut d'abord créer un objet de la classe interne de membre, puis accéder à travers une référence vers cet objet.

//Classe externe
class Outter {
 private String name = "out";
 private Integer age = 17;
 // Classe interne : sans utiliser le mot-clé static
 class Inner {
 private Integer age = 18; // Phénomène de masquage, a masqué l'age de la classe externe
 Inner() {
  // Caractéristiques :1. La classe interne peut accéder directement aux membres de la classe externe
  // 2. Lorsque la classe interne et la classe externe ont des champs ou des méthodes homonymes, un phénomène de masquage se produit
  System.out.println(name + this.age);// Sortie out18
  // Si vous avez besoin d'utiliser l'age de la classe externe à ce moment-là, la syntaxe : age de la classe externe.this
  System.out.println(Outter.this.age);// Sortie17
 }
 }
}

Résumé : En termes simples, il faut regarder l'aire de responsabilité des variables, l'aire de responsabilité des variables des membres de la classe externe est toute la classe externe, et la classe interne dans la classe externe (peut être considérée comme un champ de la classe externe), la classe interne peut naturellement accéder à la classe externe. Et pour que la classe externe accède aux membres de la classe interne, cela peut être compris ainsi : les membres de la classe interne appartiennent à la classe interne, sont valides dans la classe interne. Si la classe interne n'existe pas, les variables de membres de la classe interne n'existent pas non plus, donc la classe externe ne peut pas accéder directement aux membres de la classe interne, il est nécessaire de créer d'abord un objet de la classe interne, puis d'accéder via le pointeur de cet objet.

3.2Classe interne statique

1) Définition : La classe interne utilisée avec le mot-clé static. Par conséquent, cette classe interne appartient à la classe externe elle-même, pas à l'objet de la classe externe

2) Créer une classe interne statique

//Classe externe
class Outter {
 // Classe interne statique : utilisée avec le mot-clé static
 static class Inner {
 }
}
public class InnerDemo2 {
 public static void main(String[] args) {
 // Comme la classe interne statique appartient à la classe externe elle-même, elle peut être accédée directement via le nom de la classe externe (comme un champ)
 Outter.Inner in = new Outter.Inner();
 }
}

3) Caractéristiques :

a. Lors de la création d'une instance de la classe interne, il n'est pas nécessaire de créer une instance de la classe externe.

b. La classe interne statique peut accéder directement aux membres statiques de la classe externe, et pour accéder aux membres d'instance de la classe externe, il est nécessaire de passer par l'instance de la classe externe.

Comprendre simplement : les membres statiques appartiennent à la classe, les membres non statiques appartiennent à l'objet. Si vous souhaitez accéder aux membres d'instance (non statiques) de la classe externe, bien sûr, vous devez d'abord conserver l'objet de la classe externe. Et la création de la classe interne statique n'a pas besoin d'un objet de la classe externe, donc, si vous souhaitez accéder aux membres d'instance de la classe externe, vous devez l'accéder via l'objet de la classe externe.

c. Il est possible de définir des membres statiques et des membres d'instance dans une classe interne statique.

d. Le test peut accéder directement aux membres statiques de la classe interne statique via le nom complet de la classe.

//Classe externe
class Outter {
 static String name = "outter";
 public Integer age = 17;
 // Classe interne statique : utilisée avec le mot-clé static
 static class Inner {
 Inner() {
  // La classe interne statique peut accéder directement aux membres statiques de la classe externe
  System.out.println(name);// Sortie outter
  // Pour accéder aux membres d'instance de la classe externe, il est nécessaire de le faire via une instance de la classe externe.
  System.out.println(new Outter().age);// Sortie 17
 }
 }
}

3.3Classe interne locale (presque jamais utilisée)

1) Définition : une classe interne définie dans une méthode, dont la portée est la méthode actuelle, au même niveau que les variables locales, donc la classe interne locale ne peut être utilisée qu'à l'intérieur de la méthode.

) Attention, les classes internes locales, comme les variables locales à l'intérieur d'une méthode, ne peuvent pas avoir de modificateurs public, protected, private ou static.

public class InnerDemo3 {
 public static void main(String[] args) {
 // Classe interne locale
 class Inner {
 }
 }
}

2) Caractéristiques :

a. Les classes internes locales et les classes internes d'instance ne peuvent pas contenir de membres statiques. (Les classes internes locales appartiennent à une méthode, tandis que les membres statiques appartiennent à la classe)

b. Les classes internes locales et les classes internes d'instance peuvent accéder à tous les membres de la classe externe.

c. Les variables locales auxquelles une classe interne locale accède doivent être marquées final en Java8sont automatiquement ajoutés implicitement avec final (syntaxe sucrée).

Raison : après que la méthode a été appelée et exécutée, le cadre d'appel de la méthode actuelle est détruit, et l'espace des variables locales à l'intérieur de la méthode est détruit. Cependant, l'objet de la classe interne peut toujours être en mémoire, et ne disparaîtra que lorsque plus aucune référence ne lui est faite. Dans ce cas, il peut y avoir une situation où la classe interne doit accéder à une variable locale introuvable. Pour éviter ce problème, nous utilisons le modificateur final pour les variables locales, ce qui les transforme en constantes, restant dans l'espace mémoire, même après que la méthode ait été détruite, la variable locale reste dans la mémoire, et l'objet peut continuer à être détenu.

public class InnerDemo3 {
 public static void main(String[] args) {
 int age = 17;
 final int num = 15;
 // Classe interne locale
 class Inner {
  public void test() {
  // Erreur : Cannot refer to a non-Variable finale age à l'intérieur d'une classe interne définie dans une méthode différente
  System.out.println(age);
  System.out.println(num);// Correct
  }
 }
 }
}

3.4Classe interne anonyme (la plus fréquemment utilisée)

1) Définition : une classe interne anonyme est une classe interne sans nom, adaptée aux classes utilisées une seule fois.

2) Création de la classe interne anonyme :

Les classes internes anonymes n'ont pas de constructeur, mais appelleront le constructeur de la classe parente. En règle générale, les classes internes anonymes sont utilisées pour hériter d'autres classes ou implémenter des interfaces, sans nécessiter l'ajout de méthodes supplémentaires, mais seulement pour implémenter ou redéfinir les méthodes héritées.

Attention : les classes internes anonymes doivent hériter d'une classe parente ou implémenter une interface, mais ne peuvent en hériter ou en implémenter qu'une seule.

//Définir une interface
interface Person {
 public void eat();
}
public class AnonymousDemo {
 public static void main(String[] args) {
 // Utilisation de la classe interne anonyme
 Person p = new Person() {
  public void eat() {
  System.out.println("eat something");
  }
 };
 p.eat();
 }
}

4.résumé

5.questions d'entretien

public class Outer {
 public void someOuterMethod() {
 // Ligne 3
 }
 public class Inner {
 }
 public static void main(String[] argv) {
 Outer o = new Outer();
 // Ligne 8
 }
}
/*
 * Which instantiates an instance of Inner&63;
A. new Inner(); // À la ligne 3
B. new Inner(); // À la ligne 8
C. new o.Inner(); // À la ligne 8
D. new Outer.Inner(); // À la ligne 8
 */

La réponse A.new Inner(); est équivalente à this.new Inner();, un objet de la classe Outer existe déjà.

ligne 8 La manière correcte d'écrire serait : o.new Inner();

Voici la totalité du contenu de cet article. J'espère que le contenu de cet article pourra apporter un certain avantage à votre apprentissage ou à votre travail, et je vous remercie de soutenir le tutoriel 'Néon'.

Déclaration : le contenu de cet article est issu du réseau, propriété des auteurs respectifs, contribué et téléchargé par les utilisateurs d'Internet, le site Web ne détient pas de propriété, n'a pas été édité par l'homme, et n'assume aucune responsabilité juridique. Si vous trouvez du contenu suspect de violation de droits d'auteur, veuillez envoyer un e-mail à : notice#w3Pour signaler une violation, veuillez envoyer un e-mail à notice#w en remplaçant # par @ et fournir des preuves pertinentes. Une fois confirmée, le site supprimera immédiatement le contenu suspect de violation de droits d'auteur.