Verschachtelte Klasse

** Verschachtelte Klasse **
** statische Mitgliedsklasse **
** Innere Klasse **
** Nicht statische Mitgliedsklasse **
** Anonyme Klasse **

statische Mitgliedsklasse

Klasse (MyHelper) hängt von einer bestimmten Klasse (MyClass) ab. MyHelper wird nur von MyClass aufgerufen
→ Erwägen Sie die Kombination in einer Java-Datei
** Klasse der obersten Ebene **: Klassen direkt unter nicht verschachtelten Dateien
** Umschließende Klasse **: Klasse mit verschachtelten Klassen
Übergeordnete Klasse X: Umschließende Klasse und Klasse der obersten Ebene
Untergeordnete Klasse Y: Umschließende Klasse von Z und verschachtelte Klasse von X.
Enkelklasse Z: Y verschachtelte Klasse

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

MyHelper ist jedoch ** Paket privat ** und kann von demselben Paket aus frei aufgerufen werden.
→ ** sollte statisch und MyClass privat sein! ** ** **
Wenn Sie eine verschachtelte Klasse unter dem Klassenblock der einschließenden Klasse definieren
** Verschachtelte Klasse ist von außerhalb der umschließenden Klasse unsichtbar **
Der Name der verschachtelten Klasse lautet ** Enclosing Class.Nested Class (MyClass.MyHelper) **
Kann über den Namen der Mitgliedsklasse im Gehäuse aufgerufen werden
import (Paketname) .MyClass.MyHelper;
kann von außerhalb des umschließenden
var h = new MyHelper (); verwendet werden

//MyHelper-Definition unter dem Klassenblock
public class MyClass {
  //Definition der statischen Elementklasse
  //Mitglieder können nicht von außerhalb meiner Klasse gesehen werden
  private static class MyHelper {
    public void show() {
      System.out.println("Nested class is running!");
    }
  }
  public void run() {
    //
    var helper = new MyHelper();
    helper.show();
  }
}

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

MyHelpe ist ein Fehler, der von außerhalb von MyClass nicht sichtbar ist! Nicht statische Elementklasse (= innere Klasse) * Kein statischer Modifikator * ** Innere Klasse **: Gehört zum umschließenden Objekt * ** Statische Elementklasse **: Gehört zur umschließenden Klasse

Merkmale der inneren Klasse
Erfordert ein umschließendes Objekt, um eine innere Klasse zu instanziieren **
Von der inneren Klasse ** Greifen Sie über diese Variable auf das einschließende Klassenmitglied zu **
** Wird zum Verweisen auf das Instanzfeld der einschließenden Klasse verwendet **
Verbrauchen Sie Speicher, da einzelne Instanzen Verweise auf einschließende Objekte enthalten

class MyClass {
  private String str1 = "Beiliegende Instanz";
  private static String str2 = "Beiliegende Klasse";

  private class MyHelper {
    private String str1 = "Verschachtelte Instanz";
    private static final String str2 = "Verschachtelte Klasse";

    public void show() {
      //Die innere Klasse hat einen Verweis auf das umschließende Objekt
      //MyClass.Damit erreichbar
      System.out.println(MyClass.this.str1); //Beiliegende Instanz
      System.out.println(MyClass.str2); //Beiliegende Klasse
    }
  }

  public void run() {
    //Innere Klasseninstanz, die durch Einschließen der Klasseninstanzmethode erstellt wurde
    var helper = new MyHelper();
    helper.show();
    //Greifen Sie vom umschließenden Objekt auf die innere Klasse zu
    System.out.println(helper.str1); //Verschachtelte Instanz
    System.out.println(MyHelper.str2); //Verschachtelte Klasse
  }
}

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

Beispiel einer nicht statischen Elementklasse (innere Klasse)

Wenn Sie eine private innere Klasse deklarieren, können Sie sie von außerhalb des Gehäuses nicht sehen
Nur der Typname ** kann ausgeblendet werden, und es gibt keine Einschränkungen für Instanzreferenzen.

`java:java.util.AbstractList.java`


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

    /*Iterators
Die interne Implementierung der Itr-Klasse muss nicht angezeigt werden
Es wäre schön, wenn der Typ Iteratoren, der die Implementierungsquelle darstellt, von außen gesehen werden könnte.
Der Rückgabewert der Iteratormethode ist der Iterator-Typ
    */
    public Iterator<E> iterator() {
        return new Itr();
    }
//...Unterlassung

    /*Innere Klasse
Implementierte einen Iterator, der auf das private Feld in der Liste zugreift und der Reihe nach auf die untergeordneten Elemente zugreift
Iterator wird separat als Iterator-Implementierungsklasse definiert
    */
    private class Itr implements Iterator<E> {
//...Unterlassung
    }
//...Unterlassung
}

Anonyme Klasse (anonyme Klasse)

** Wird als Container verwendet, um bestimmte Prozesse gemeinsam darzustellen **
Beispiel: Ereignis-Listener
Nicht an anderer Stelle wiederverwendet, da es stark mit einem bestimmten Kontext zusammenhängt (z. B. Benutzerverhalten).
** neue Basisklasse (Argument, ...) {Klassenkörper} **
- new View.OnClickListener(){
Da die anonyme Klasse keinen Namen hat, geben Sie den Namen der Basisklasse / Schnittstelle im neuen Operator an.
Sie können es an die Methode übergeben, wie es ist, an die vorbereitete Listener-Instanz
Hinweis;
Ich kann keinen Konstruktor haben (Initialisierung ist OK)
Nicht vererbbar (implizit endgültig)
Abstrakte Klasse kann nicht deklariert werden

//Registrierung des Ereignis-Listeners
btn.setOnClickListener(
  //Anonyme Klasse(Ereignis-Listener)Definition
  new View.OnClickListener(){
    //btn Klicken Sie hier, um die aktuelle Uhrzeit in txt anzuzeigen
    @Override
    public void onClick(View view){
      TextView txt = findViewById(R.id.txtResult);
      txt.setText(LocalDateTime.now().toString());
    }
  }
);

Lokale Klasse

Methoden, Konstruktoren usw. ** Unter Blöcken definierte Klassen **
Wird verwendet, wenn eine Klasse in einer bestimmten Methode oder einem bestimmten Konstruktor verwendet wird
Anonyme Klasse kann als Ersatz verwendet werden

[Java] Verschachtelte Klasse