[Java] Vererbung

Was ist Vererbung?

• ** Übernimm die Mitglieder der ursprünglichen Klasse und definiere eine neue Klasse **
• ** Basisklasse ** (Superklasse, übergeordnete Klasse): Vererbungsquelle
• ** Abgeleitete Klasse ** (Unterklasse, untergeordnete Klasse): Vererbte Klasse
• Ein Mechanismus, um gemeinsame Teile von Funktionen auszuschneiden und nur die Unterschiede zu schreiben
• cf: ** Delegation **: Schneiden Sie eine bestimmte Rolle als andere Klasse aus und speichern Sie diese Instanz als Feld

Verwendung der Vererbung

• class Abgeleitete Klasse erweitert Basisklasse {}
• Wenn nicht angegeben, bedeutet dies, dass die Object-Klasse geerbt wird.
• Suche nach dem gewünschten Mitglied in der aktuellen Klasse. ** Wenn es nicht existiert, rufe das in der Oberklasse definierte Mitglied auf! ** **.
• Methoden sowohl in der Basisklasse als auch in der abgeleiteten Klasse rufen vorzugsweise die abgeleitete Klasse auf
• Hinweis:
• ** Nur eine Basisklasse in Java ** (Mehrfachnachfolgegenehmigung nicht möglich)
• ** In der Basisklasse definierte Mitglieder können in der abgeleiteten Klasse nicht gelöscht werden **
• = Abgeleitete Klasse ** enthält alle Eigenschaften der Basisklasse **

Person.java

public class Person {
  public String name;
  public int age;

  public String show() {
    return String.format("%s（%d).", this.name, this.age);
  }
}

BusinessPerson.java

//Erstellen Sie eine BusinessPerson-Klasse, die Person erbt
public class BusinessPerson extends Person {
  //Arbeitsmethodendefinition, die für die abgeleitete Klasse eindeutig ist
  public String work() {
    return String.format("%d Jahr alt%s funktioniert heute gut.", this.age, this.name);
  }
}

public class InheritBasic {
  public static void main(String[] args) {
    //Nur Geschäftsperson anrufen
    var bp = new BusinessPerson();
    bp.name = "Ichiro Sato";
    bp.age = 30;
    //Die show-Methode kann wie ein Mitglied der bp-Klasse aufgerufen werden!
    System.out.println(bp.show()); //Ich bin Ichiro Sato (30 Jahre alt).
    System.out.println(bp.work());  //Ichiro Sato, 30 Jahre alt, arbeitet heute gut.
  }
}

• Punkte
• Verwenden Sie die Vererbung, wenn die übergeordneten und untergeordneten Klassen eine ** is-a-Beziehung ** haben. * is-a：SubClass is a SuperClass * Person⊃BusinessPerson
• Beziehung, in der die Geschäftsperson in Person enthalten ist
• Abgeleitete Klassen sind ** spezialisiert ** auf Basisklassen
• Basisklasse ist ** Verallgemeinerung ** der abgeleiteten Klasse

Feldverschleierung

• Die Vererbung hängt vom Mitglied ab
• ** Override **: Methode möglich
• ** Versteckt **: Felder, verschachtelte Klassen / Schnittstellen möglich

versteckt

• ** Wenn das gleichnamige Feld in der Basisklasse in der abgeleiteten Klasse definiert ist **, ist das Feld in der Basisklasse nicht sichtbar.
• Auch wenn der Datentyp unterschiedlich ist ** Wenn der Name gleich ist, wird er ausgeblendet **
• Auf ausgeblendete Felder kann mit der reservierten Variablen ** super ** zugegriffen werden
• Hinweis: Auf Basisklassenfelder kann nicht zugegriffen werden, wenn sie privat sind

Person.java

import java.time.ZonedDateTime;
public class Person {
  public String name;
  public ZonedDateTime birth = ZonedDateTime.now();
}

BusinessPerson.java

import java.time.LocalDateTime;
public class BusinessPerson extends Person {
  //Verstecke das Geburtsfeld der Basisklasse
  public LocalDateTime birth = LocalDateTime.now();
  public void show() {
    //Greifen Sie auf versteckte Felder zu
    System.out.println(super.birth);
  }
}

public class HideBasic {

  public static void main(String[] args) {
    var bp = new BusinessPerson();
    //BusinessPerson.Geburt zeigen
    System.out.println(bp.birth); 
    bp.show();
    //Person.Geburtsfeld anzeigen
    Person p = new BusinessPerson();
    System.out.println(p.birth);
  }
}

Methodenüberschreibung

• Überschreiben (neu definieren) Sie die in der Basisklasse definierte Methode mit der abgeleiteten Klasse
• Sie sehen nicht nur den Namen (im Gegensatz zur Verschleierung)
• ** Methodenname **: Genaue Übereinstimmung
• ** Formales Argument **: Datentyp / Nummernübereinstimmung
• Die Basis (CharSequence s) kann nicht von den abgeleiteten (String s) überschrieben werden.
• ** Rückgabewert **: Typübereinstimmung / abgeleiteter Typ
• ** Zugriffsmodifikator **: Loser als Match / Base-Typ
• öffentlich> geschützt> nicht spezifiziert> privat
• privat kann nicht überschrieben werden
• ** throw-Klausel (Ausnahme) **: Match / abgeleiteter Typ
• → ** @Override Annotation ** ist OK
• ** Erklären Sie explizit, dass Sie eine Methode der Basisklasse überschreiben **

public class Person {
  public String name;
  public int age;

  public String show() {
    return String.format("%s（%d).", this.name, this.age);
  }
}

public class BusinessPerson extends Person {
  public BusinessPerson() {}
  //Überschreiben Sie die gleichnamige show-Methode in der Basisklasse
  @Override
  public String show() {
    return String.format("Von Büroangestellten%s（%d).", this.name, this.age);
  }

  public String work() {
    return String.format("%d Jahr alt%s funktioniert heute gut.", this.age, this.name);
  }
}

Basisklassenreferenz (super)

• Der Methodenaufruf von super ist ** der Beginn der Methodendefinition der abgeleiteten Klasse **

//Erben Sie die BusinessPerson-Klasse
public class EliteBusinessPerson extends BusinessPerson {
  @Override 
  //Rufen Sie die Arbeitsmethode der Basisklasse auf und fügen Sie Ihre eigene Verarbeitung hinzu

  public String work() {
    //Rufen Sie die Super-Methode am Anfang der abgeleiteten Klasse auf
    var result = super.work();
    return String.format("%s Immer lächeln!", result);
  }
}

public class InheritBaseCall {
  public static void main(String[] args) {
    var ebp = new EliteBusinessPerson();
    ebp.name = "Yamada Taro";
    ebp.age = 35;
    System.out.println(ebp.work()); //Der 35-jährige Taro Yamada arbeitet heute gut. Immer lächeln!
  }
}

Abgeleiteter Klassenkonstruktor

• ** Konstruktoren werden nicht wie Methoden vererbt **
• In der geerbten Klasse ** wird der Konstruktor in der Reihenfolge von der oberen Klasse aufgerufen, und schließlich wird der Konstruktor der aktuellen Klasse aufgerufen **
• Die Basisklasseninitialisierung basiert auf dem Klassenkonstruktor
• Die Initialisierung abgeleiteter Klassen ist ein abgeleiteter Klassenkonstruktor
• 1. Initialisieren Sie alle Felder mit den angegebenen Werten
• 2. Ausführung des Basisklasseninitialisierungsblocks
• 3. Ausführung des Basisklassenkonstruktors
• 4. Abgeleitete Ausführung des Klasseninitialisierungsblocks
• 5. Ausführung des Konstruktors der abgeleiteten Klasse

MyParent.java

public class MyParent {
  public MyParent() {
    System.out.println("Ich bin ein Elternteil.");
  }
}

MyChild.java

public class MyChild extends MyParent {
  public MyChild() {
    System.out.println("Ich bin ein Kind.");
  }
}

public class InheritConstruct {
  public static void main(String[] args) {
    var c = new MyChild(); //Ich bin ein Elternteil. Ich bin ein Kind.
  }
}

• In der Oberschicht wird implizit nur der Konstruktor ohne Argumente aufgerufen **
• Wenn Sie einen Konstruktor explizit definieren (= mit einem Argument), wird der Standardkonstruktor nicht automatisch generiert.
• → Rufe den Konstruktor mit Argumenten mit ** super vom Konstruktor der abgeleiteten Klasse auf **
• ** Rufen Sie unbedingt ** am Anfang des ** Konstruktors ** auf

//Oberschicht (Konstruktor mit Argument)
public class MyParent {
  public MyParent(String name) {
    System.out.printf("%ist der Elternteil von s.\n", name);
  }
}

public class MyChild extends MyParent {
  public MyChild(String name) {
    //Rufen Sie einen argumentlosen Konstruktor einer höheren Klasse von einem abgeleiteten Klassenkonstruktor auf
    super(name);
    //Konstruktoren werden in der Reihenfolge Basisklasse → abgeleitete Klasse aufgerufen
    System.out.printf("Vom Kind%s.\n", name); //Ich bin Taro Yamadas Eltern.\n Ich bin ein Kind von Taro Yamada.
  }
}

public class InheritConstruct {
  public static void main(String[] args) {
    var c = new MyChild("Yamada Taro");
  }
}

Keine Vererbung / Überschreibung

• Die Implementierung und Änderung vererbbarer Klassen sollte auch die Auswirkungen auf abgeleitete Klassen berücksichtigen
• Für Klassen / Methoden, die keine Vererbung / Überschreibung annehmen, ** mit endgültigem Modifikator verbieten **

public class Person {
  String name;
  int age;
  public Person() {}
  //Show-Methode nicht überschreiben
  public final String show() {
    return String.format("%s（%d).", this.name, this.age);
  }
}

//Keine Vererbung der BusinessPerson-Klasse
public final class BusinessPerson extends Person {
  public String intro() {
    return "Ich bin Büroangestellter.";
  }
}

Konvertierung des Referenztyptyps

• ** Typen haben eine Vererbungs- / Implementierungsbeziehung **

Upcast

• ** Konvertierung von abgeleiteter Klasse in Basisklasse **
• Konvertieren Sie den BusinessPerson-Typ in den Personentyp
• Abgeleitete Klasse enthält alle Mitglieder der Basisklasse
• Abgeleitete Klasseninstanzen sind als Basisklasseninstanzen verfügbar
• ** In diesem Fall ist der Konvertierungstyp Person und der Objekttyp BusinessPerson ** (* Variablentyp / Objekttyp * Referenz später beschrieben)

//Upcast
public class CastUp {
  public static void main(String[] args) {
    //Konvertieren Sie, indem Sie ein BusinessPerson-Objekt einer Variablen der Basisklasse Personentyp zuweisen
    Person bp = new BusinessPerson();
    bp.name = "Yamada Taro";
    bp.age = 20;
    System.out.println(bp.show());
  }
}

Niedergeschlagen

• ** Konvertierung von Basisklasse in abgeleitete Klasse **
• Personentyp in Geschäftspersonentyp konvertieren
• Die Basisklasse kann sich nicht immer als abgeleitete Klasse verhalten
• ** Explizite Typkonvertierung in Cast-Syntax erforderlich **
• Person p = new BusinessPerson();
• BusinessPerson bp = (BusinessPerson)p;

Variablentyp / Objekttyp

• Show-Methode der Personenklasse in Business Person überschreiben
• Der folgende Code kann jedoch die Arbeitsmethode der BusinessPerson-Klasse nicht aufrufen.
• Variable p ist eine Variable vom Typ Person
• Variable p ** kann Arbeitsmethode nicht aufrufen **
• Der Objekttyp (Entität) der Variablen p ist BusinessPerson
• ** Die BusinessPerson-Show-Methode heißt **

BusinessPerson.java

public class BusinessPerson extends Person {
  public BusinessPerson() {}

  @Override
  public String show() {
    return String.format("Von Büroangestellten%s（%d).", this.name, this.age);
  }

  public String work() {
    return String.format("%d Jahr alt%s funktioniert.", this.age, this.name);
  }
}

public class TypeDifference {

  public static void main(String[] args) {
    Person p = new BusinessPerson();
    p.name = "Yamada Taro";
    p.age = 30;
    // System.out.println(p.work()); //Error
    System.out.println(p.show()); //Ich bin Taro Yamada (30 Jahre alt), ein Büroangestellter.
  }
}

• Mit anderen Worten,
• Cast ersetzt ** Variablentyp **
• Konvertieren Sie den BusinessPerson-Variablentyp in den Personenvariablentyp
• ** Objekttyp (Entität) ändert sich auch bei Umwandlung nicht **
• ** Die aufzurufende Methode wird durch den Objekttyp bestimmt **
• Person kann sich nicht als Geschäftsperson verhalten

Ausblenden von Klassenmethoden / Feldern

• Klassenmethoden werden mit class name.method name (...) aufgerufen
• Variablentyp / Objekttyp existiert nicht
• Da die Methode der angegebenen Klasse immer aufgerufen wird ** Es gibt kein Überschreibungskonzept **
• Die Feldauswahl hängt vom Variablentyp ab

public class HideBasic {
  public static void main(String[] args) {
    var bp = new BusinessPerson();
    System.out.println(bp.birth);
    bp.show();
    //Die Variable p ist vom Typ Person
    Person p = new BusinessPerson();
    //Das Geburtsfeld der Person-Klasse ist vom Typ ZonedDateTime
    System.out.println(p.birth); //ZonedDateTime-Typ
  }
}

Typurteil

• Objekttypprüfung beim Downcasting erforderlich **
• Zum Beispiel so etwas. .. ..
• BusinessPerson / Student ist eine von einer Person abgeleitete Klasse * Person p = new BusinessPerson(); //OK * BusinessPerson bp = (BusinessPerson)p; //OK * Student st = (Student)p; //NG
• Die Entität (Objekttyp) der Variablen p ist BusinessPerson
• Zur Kompilierungszeit kenne ich nur die Vererbungsbeziehung zwischen Person und BusinessPerson / Student. ** Ich erhalte keinen Kompilierungsfehler, aber zur Laufzeit einen Fehler! ** **.
• → ** Verwenden Sie den Operator "instanceof" **
• True, wenn der in der Variablen gespeicherte Objekttyp in den angegebenen Typ konvertiert werden kann

//Typprüfung
if(p instanceof Student){
    Student st = (Student)p;
    //Verarbeitung beim Gießen ist korrekt
}

Typerfassung

• Holen Sie sich den Objekttyp mit der Methode "getClass"
• Holen Sie sich den Objekttyp unabhängig vom Variablentyp

public class Main {
    public static void main(String[] args) {
    Person p1 = new Person();
    System.out.println(p1.getClass()); //class Person
    Person p2 = new BusinessPerson();
    System.out.println(p2.getClass()); //class BusinessPerson
  }
}

Transfer

• Die Vererbung ist eng mit Basis- / abgeleiteten Klassen gekoppelt
• Wann wird die Vererbung verwendet?
• ** Basis / abgeleitete Klasse ist eine Beziehung **
• ** Rifkov-Substitutionsprinzip **: Das Zuweisen einer Instanz der abgeleiteten Klasse zu einer Variablen in der Basisklasse beeinträchtigt nicht die Gültigkeit des Codes
• ** Annahme einer Erweiterung, Dokumentation dieser Tatsache **
• Beispiele für unangemessene Vererbung

import java.util.Random;

public class Roulette extends Random {
//Roulette-Obergrenze
private int bound;

  public Roulette(int bound) {
    this.bound = bound;
  }
  //Holen Sie sich den Wert als Obergrenze des gebundenen Feldes und generieren Sie eine Zufallszahl
  @Override
  public int nextInt() {
    return nextInt(this.bound);
  }
  //Andere unnötige Methoden sind deaktiviert (entgegen Rifkovs Ersetzungsprinzip)
  @Override
  public boolean nextBoolean() {
    throw new UnsupportedOperationException();
  }

  @Override
  public long nextLong() {
    throw new UnsupportedOperationException();
  }
}

import java.util.Random;

public class RouletteClient {
  public static void main(String[] args) {
    Random rou = new Roulette(10);
    System.out.println(rou.nextBoolean()); //UnsupportedOperationException
  }
}

• ** Importieren Sie bei der Delegierung ein Objekt mit der Funktion, die Sie als Feld der aktuellen Klasse wiederverwenden möchten **
• Delegierung ist ** eine dynamische Beziehung zwischen Instanzen **
• Halten Sie ein zufälliges Objekt im Zufallsfeld der Roulette-Klasse ** und verwenden Sie gegebenenfalls die Methode der zufälligen Klasse **
• ** hat eine Beziehung **
• Verdienst:
• ** Lose Beziehungen zwischen Klassen **
• Da öffentliche Mitglieder verwendet werden ** Es hängt nicht von der internen Implementierung ab **
• Die Beziehung ist nicht festgelegt, da die Instanz im Feld gehalten wird
• ** Der Erwerber kann später geändert werden **
• ** Die Verarbeitung kann an mehrere Klassen delegiert werden **
• ** Der Erwerber kann für jede Instanz geändert werden **

import java.util.Random;

public class Roulette {
  private int bound;
  //Halten Sie das obige Objekt im Feld
  private Random random = new Random();

  public Roulette(int bound) {
    this.bound = bound;
  }
  //Delegieren Sie die Verarbeitung nach Bedarf
  public int nextInt() {
    return this.random.nextInt(this.bound);
  }
}