[Der Weg zum Java-König] Kapitel 14: Java SE (Objektorientierte Programmierung – Komposition, Polymorphismus)

Ziele dieses Abschnitts

Kombination

Polymorphismus

1. Was ist eine Kombination

Ähnlich wie bei der Vererbung ist die Komposition auch eine Möglichkeit, die Beziehung zwischen Klassen auszudrücken, und sie kann auch den Effekt der Wiederverwendung von Code erzielen, beispielsweise um eine Schule darzustellen:

public class Student { 
 ... 
} 
public class Teacher { 
 ... 
} 
public class School { 
 public Student[] students; 
 public Teacher[] teachers; 
} 

Die Zusammensetzung erfordert keine spezielle Syntax (Schlüsselwörter wie „extends“), sondern stellt lediglich eine Instanz einer Klasse als Feld einer anderen Klasse dar. Dies ist eine der üblichen Arten, wie wir Klassen entwerfen

Kombinatorische Darstellung hat - eine Semantik

Im vorherigen Beispiel können wir verstehen, dass eine Schule mehrere Schüler und Lehrer "enthält".

Vererbung repräsentiert ist - eine Semantik

Im obigen Beispiel „Tiere und Hunde“ können wir nachvollziehen, dass ein Hund auch ein Tier „ist“.

Zweitens, was ist Polymorphismus

Polymorphismus: Wörtliches Verständnis: Eine Sache hat viele Formen (dieser Satz darf dem Interviewer nicht gesagt werden) 

Aufwärtstransformation: 

Upcasting: ein Satz, Elternklassenreferenz, Referenzunterklassenobjekt

class Animal{
    public String name;
    public int age;

    public void eat(){
        System.out.println("eat()");
    }

    public Animal(String name,int age){
        this.name = name;
        this.age = age;
    }
}
class Dag extends Animal {
    public Dag(String name,int age){
        super(name,age);
    }


}
class Bird extends Animal{

    public String wing;

    public void fly(){
        System.out.println(age+"fly");

    }

    public Bird(String name,int age,String wing){
        super(name,age);
        this.wing = wing;
    }

}
public class TestDemo{
    public static void main(String[] args) {
        //Dag dag = new Dag("HAHAH",12);
        //Animal animal = dag;
        Animal animal1 = new Dag("HAHAH",12);
    }

Was passiert, wenn ein Upcast auftritt:

1. Direkte Zuordnung

2. Übergabe der Methodenparameter

3. Die Methode kehrt zurück

Wir haben die Methode der direkten Zuweisung demonstriert.Die anderen beiden Methoden unterscheiden sich nicht wesentlich von der direkten Zuweisung

Methodenparameter:

 Zu diesem Zeitpunkt ist der Typ des formalen Parameters animal Animal (Basisklasse), was tatsächlich der Instanz von Dag (Elternklasse) entspricht.

 Methode gibt zurück:

Dynamische Bindung:

Dynamische Bindung:

Zwei Prämissen:

1, die übergeordnete Klassenreferenz, beziehen sich auf das Objekt der Unterklasse

2. Rufen Sie über diese Elternklassenreferenz die Override-Methode mit dem gleichen Namen der Elternklasse und der Kindklasse auf

Überschreibende Methode gleichen Namens, Begriff: Überschreiben

Umschreiben:

1: Der Methodenname ist derselbe

2: Die Parameterliste ist gleich (Anzahl + Typ)

3: Der Rückgabewert ist gleich

Bei übergeordneten und untergeordneten Klassen muss überschrieben werden

Die dynamische Bindung ist die Grundlage des Polymorphismus

// Animal.java 
public class Animal { 
 protected String name; 
 public Animal(String name) { 
 this.name = name; 
 } 
 public void eat(String food) { 
 System.out.println("我是一只小动物"); 
 System.out.println(this.name + "正在吃" + food); 
 } 
} 
// Bird.java 
public class Bird extends Animal { 
 public Bird(String name) { 
 super(name); 
 } 
 public void eat(String food) { 
 System.out.println("我是一只小鸟"); 
 System.out.println(this.name + "正在吃" + food); 
 } 
} 
// Test.java 
public class Test { 
 public static void main(String[] args) { 
 Animal animal1 = new Animal("圆圆"); 
 animal1.eat("谷子"); 
 Animal animal2 = new Bird("扁扁"); 
 animal2.eat("谷子"); 
 } 
} 
// 执行结果
我是一只小动物
圆圆正在吃谷子
我是一只小鸟
扁扁正在吃谷子

An dieser Stelle fanden wir:

Obwohl sowohl animal1 als auch animal2 Referenzen des Typs Animal sind, zeigt animal1 auf eine Instanz des Typs Animal und animal2 auf eine Instanz des Typs Bird.

Rufen Sie die eat-Methode für animal1 bzw. animal2 auf und stellen Sie fest, dass animal1.eat() tatsächlich die Methode der übergeordneten Klasse aufruft, während animal2.eat() tatsächlich die Methode der Unterklasse aufruft

Daher hängt es in Java beim Aufruf einer Methode einer Klasse davon ab, welcher Codeabschnitt ausgeführt wird (ist es der Code der Methode der übergeordneten Klasse oder der Code der Methode der untergeordneten Klasse), ob die Referenz auf die übergeordnete Klasse zeigt Objekt oder das Unterklassenobjekt. Dieser Prozess wird zur Laufzeit des Programms (nicht zur Kompilierzeit) bestimmt, daher wird er als dynamisches Binden bezeichnet

Vorsichtsmaßnahmen:

1. Die Methode darf nicht statisch sein

2. Der Zugriffsmodifikator der Unterklasse muss größer oder gleich dem Zugriffsmodifikator der Elternklasse sein

3. Die private Methode kann nicht überschrieben werden

4. Die durch final modifizierte Methode kann nicht überschrieben werden

Außerdem können Sie für überschriebene Methoden die Annotation @Override verwenden, um sie explizit anzugeben

// Bird.java 
public class Bird extends Animal { 
 @Override 
 private void eat(String food) { 
 ... 
 } 
} 

Diese Anmerkung kann uns dabei helfen, einige Legalitätsprüfungen durchzuführen. Wenn beispielsweise der Methodenname falsch geschrieben ist (z. B. aet), stellt der Compiler fest, dass es keine aet-Methode in der übergeordneten Klasse gibt, und kompiliert einen Fehler mit der Aufforderung Cannot stellen das Überschreiben dar. Wir empfehlen, explizit die Annotation @Override hinzuzufügen, wenn Methoden im Code überschrieben werden

Zusammenfassen:

Lassen Sie uns zuerst kurz das Konzept des Polymorphismus verstehen, und dann werden wir das Verständnis und Verständnis des Polymorphismus durch Code vertiefen, damit jeder das Grammatikwissen des Polymorphismus vollständig erfassen kann.