[Java] Classe imbriquée

Classe imbriquée

• ** Classe imbriquée **
• ** classe de membre statique **
• ** Classe intérieure **
• ** Classe de membre non statique **
• ** Classe anonyme **

classe de membre statique

• La classe (MyHelper) dépend d'une classe spécifique (MyClass), MyHelper est appelée uniquement depuis MyClass
• → Pensez à combiner en un seul fichier .java
• ** Classe de niveau supérieur **: Classes directement sous des fichiers non imbriqués
• ** Classe englobante **: Classe avec des classes imbriquées à l'intérieur
• Classe parent X: classe englobante et classe de niveau supérieur
• Classe enfant Y: classe englobante de Z et classe imbriquée de X
• Classe petit-enfant Z: Classe imbriquée Y

public class MyClass{...}
class MyHelper{...}

• Cependant, MyHelper est ** package private ** et peut être librement accessible à partir du même package.
• → ** doit être statique et MyClass privé! ** **
• Si vous définissez une classe imbriquée sous le bloc de classe de la classe englobante
• ** La classe imbriquée est invisible de l'extérieur de la classe englobante **
• Le nom de la classe imbriquée est ** Classe englobante.Classe imbriquée (MyClass.MyHelper) **
• Peut être appelé par le nom de la classe de membre à l'intérieur du
• import (nom du package) .MyClass.MyHelper;
  peut être utilisé de l'extérieur de l'enveloppe
  var h = new MyHelper ();

//Définition de MyHelper sous le bloc de classe
public class MyClass {
  //Définition de la classe de membre statique
  //Les membres ne peuvent pas être vus de l'extérieur de Ma classe
  private static class MyHelper {
    public void show() {
      System.out.println("Nested class is running!");
    }
  }
  public void run() {
    //MyHelper peut être appelé à l'intérieur du boîtier
    var helper = new MyHelper();
    helper.show();
  }
}

public class NestBasic {
  public static void main(String[] args) {
    var c = new MyClass();
    c.run();
    //MyHelpe est invisible de l'extérieur de MyClass
    // var h = new MyClass.MyHelper(); //Erreur!
  }
}

Classe membre non statique (= classe interne)

• Pas de modificateur statique
• ** Classe intérieure **: appartient à l'objet englobant
• ** classe membre statique **: appartient à la classe englobante
• Caractéristiques de la classe intérieure
• Nécessite un objet englobant pour instancier une classe interne **
• Depuis la classe interne ** Accédez au membre de classe englobant via cette variable **
• ** Utilisé pour référencer le champ d'instance de la classe englobante **
• Consommez de la mémoire car les instances individuelles ont des références à des objets englobants

class MyClass {
  private String str1 = "Instance englobante";
  private static String str2 = "Classe englobante";

  private class MyHelper {
    private String str1 = "Instance imbriquée";
    private static final String str2 = "Classe imbriquée";

    public void show() {
      //La classe interne a une référence à l'objet englobant
      //MyClass.Accessible avec ceci
      System.out.println(MyClass.this.str1); //Instance englobante
      System.out.println(MyClass.str2); //Classe englobante
    }
  }

  public void run() {
    //Instance de classe interne créée en englobant la méthode d'instance de classe
    var helper = new MyHelper();
    helper.show();
    //Accéder à la classe interne à partir de l'objet englobant
    System.out.println(helper.str1); //Instance imbriquée
    System.out.println(MyHelper.str2); //Classe imbriquée
  }
}

public class NestedAccess {
  public static void main(String[] args) {
    var c = new MyClass();
    c.run();
  }
}

Exemple de classe membre non statique (classe interne)

• Si vous déclarez une classe interne privée, vous ne pouvez pas la voir de l'extérieur du
• Seul le nom du type ** peut être masqué et il n'y a aucune restriction sur les références d'instance.

java:java.util.AbstractList.java

package java.util;
import java.util.function.Consumer;
public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {
//...Omission

    /*Iterators
Pas besoin de montrer l'implémentation interne de la classe Itr
Ce serait bien si le type Iterators, qui est la source d'implémentation, pouvait être vu de l'extérieur.
La valeur de retour de la méthode iterator est le type Iterator
    */
    public Iterator<E> iterator() {
        return new Itr();
    }
//...Omission

    /*Classe intérieure
Implémentation d'un itérateur qui accède au champ privé dans la liste et accède aux éléments subordonnés dans l'ordre
Iterator est défini séparément en tant que classe d'implémentation Iterator
    */
    private class Itr implements Iterator<E> {
//...Omission
    }
//...Omission
}

Classe anonyme (classe anonyme)

• ** Utilisé comme conteneur pour représenter collectivement des processus spécifiques **
• ex: écouteur d'événement
• Non réutilisé ailleurs car il est fortement lié à un contexte particulier (tel que le comportement de l'utilisateur)
• ** nouvelle classe de base (argument, ...) {corps de la classe} **
  • new View.OnClickListener(){
• Puisque la classe anonyme n'a pas de nom, spécifiez le nom de la classe / interface de base dans le nouvel opérateur.
• Vous pouvez le transmettre à la méthode tel quel à l'instance d'écouteur préparée
• Remarque;
• Je ne peux pas avoir de constructeur (l'initialisation est OK)
• Non héritable (implicitement définitif)
• La classe abstraite ne peut pas être déclarée

//Inscription des écouteurs d'événements
btn.setOnClickListener(
  //Classe anonyme(Écouteur d'événements)Définition
  new View.OnClickListener(){
    //btn Cliquez pour afficher l'heure actuelle en txt
    @Override
    public void onClick(View view){
      TextView txt = findViewById(R.id.txtResult);
      txt.setText(LocalDateTime.now().toString());
    }
  }
);

Classe locale

• Méthodes, constructeurs, etc. ** Classes définies sous blocs **
• Utilisé lorsqu'une classe est utilisée dans une méthode ou un constructeur spécifique
• La classe anonyme peut être utilisée comme substitut