Was ist Polymorphismus? ? Im wahrsten Sinne des Wortes werden mehrere Formen verstanden, dh Objekte verschiedener Klassen rufen dieselbe Methode auf. Es kann auch verstanden werden, dass Objekte verschiedener Klassen nach demselben Verhalten unterschiedliche Zustände erzeugen.
Um Polymorphismus zu verstehen, müssen wir die beiden Schlüsselpunkte der Aufwärtstransformation und des Umschreibens verstehen und dann das Konzept des Polymorphismus tiefgreifend verstehen. Nachdem wir die Aufwärtstransformation und das Umschreiben gelesen haben, werden wir uns mit dem Konzept des Polymorphismus befassen, und Sie werden es plötzlich tun erleuchtet und wurde viel erleuchteter. Denn die Bedingungen für Polymorphismus sind Aufwärtstransformation, Umschreiben und Vererbung.
Zuallererst ist die Prämisse des Polymorphismus Vererbung. Da es sich um Vererbung handelt, muss eine Beziehung zwischen der übergeordneten Klasse und der Unterklasse bestehen.
Erinnern wir uns daran, wie man Unterklassenobjekte und übergeordnete Klassenobjekte erstellt.
class Animal{
public String name;//名字
public int age;
public void eat() {
System.out.println("我要吃饭！！！");
}
public void sleep() {
System.out.println("我要睡觉！！！");
}
}
class Cat extends Animal{
public void mew() {
System.out.println("喵喵喵！！！");
}
}
public class TestDemo1 {
public static void main(String[] args) {
Cat cat =new Cat();//实例化子类对象
cat.name="mimi";
Animal animal = new Animal();//实例化父类对象
animal.eat();
}
}Die Cat-Klasse wird hier erstellt und erbt dann die Animal-Klasse. Wir können Methoden und Eigenschaften aufrufen, indem wir die Objekte Cat und Animal instanziieren.
Was ist dann Aufwärtstransformation? ? ?
Ursprünglich bezieht sich die Referenz des Unterklassenobjekts auf das Objekt der Unterklasse, aber jetzt bezieht sich die Referenz der übergeordneten Klasse auf das Unterklassenobjekt. Dies ist eine Aufwärtstransformation.
Lassen Sie uns den Code verwenden, um zu verstehen:
Dies ist eine Aufwärtstransformation, um Methoden aufzurufen.
Dann werden wir feststellen, dass wir sie verwenden können Diese Referenz dient dazu, die Methoden und Eigenschaften einer Klasse aufzurufen, aber Methoden und Eigenschaften von Unterklassen können nicht aufgerufen werden. Warum also? ? Der Grund dafür ist, dass die übergeordnete Klasse diese Methode in der Unterklasse nicht hat und daher nicht aufgerufen werden kann. Zusammenfassung: Während der Aufwärtstransformation verweist die übergeordnete Klassenreferenz auf das Unterklassenobjekt. Diese übergeordnete Klassenreferenz kann nur die Attribute und Methoden der übergeordneten Klasse aufrufen, nicht jedoch die Unterklasse.
Die erste: direkte Zuweisung
Das heißt, so wie wir es oben geschrieben haben:
Animal animal1 = new Cat();//父类对象的引用 引用子类对象--->向上转型 Animal animal2 = new Dog();
Die zweite: als Methodenparameter:
Die dritte ist wie folgt Rückgabewert:
Kehren wir zum gedruckten Ergebnis zurück.
Aber was ist, wenn ich die Methode der Elternklasse ändere und sage, dass ich Katzenfutter essen möchte? Das Ergebnis ist keine Überraschung, dass Mimi Katzenfutter essen möchte.
Aber es wird ein Problem geben, wenn ich eine Hundeklasse erstelle und dann die Eat-Methode aufrufe, müssen Hunde dann auch Katzenfutter essen? Dies führt zu Problemen, dann können wir eine Essmethode in die Unterklasse schreiben.
class Animal{
public String name;//名字
public int age;
public void eat() {
System.out.println(this.name+"要吃饭！！！");
}
}
class Dog extends Animal{
public void dark() {
System.out.println("汪汪汪！！！");
}
public void eat() {
System.out.println(this.name+"吃狗粮！！！");
}
}
class Cat extends Animal{
public void mew() {
System.out.println("喵喵喵！！！");
}
public void eat() {
System.out.println(this.name+"吃猫粮！！！");
}
}
public class TestDemo1 {
public static void main(String[] args) {
//语法形式 : 父类 变量 = new 子类();
Animal animal1 = new Cat();//父类对象的引用 引用子类对象--->向上转型
Animal animal2 = new Dog();//父类对象的引用 引用子类对象--->向上转型
animal1.name = "小猫";//访问父类属性
animal2.name = "小狗";//访问父类属性
animal1.eat();
animal2.eat();
// animal.mew();//访问子类特有的方法
}
}Zu diesem Zeitpunkt wird eine Hundeklasse erstellt und dann werden in den beiden Unterklassen zwei Essmethoden erstellt.
Wir stellten fest, dass es zu diesem Zeitpunkt sehr klar war, den gewünschten Effekt zu erzielen.
Aber wir sollten noch einmal darüber nachdenken: Warum die Eat-Methode der Unterklasse anstelle der übergeordneten Klasse aufrufen?
Die dynamische Bindung findet zu diesem Zeitpunkt tatsächlich statt. Wir können uns die Bytecode-Datei ansehen und das Powershell-Fenster öffnen. Wir alle wissen, dass wir ein Programm zuerst kompilieren müssen Führen Sie es dann beim Kompilieren aus, indem Sie die Eat-Methode von Animal aufrufen. Dies ist das, was wir als Laufzeitbindung oder dynamische Bindung bezeichnen.
Da es also eine dynamische Bindung gibt, muss es auch eine statische Bindung geben. 
Methodenüberladung
Wir haben bereits etwas über Methodenüberladung gelernt. Methodenüberladung bedeutet, dass der Methodenname derselbe ist, der Rückgabewert nicht erforderlich ist und die Parameterliste unterschiedlich ist. Das Umschreiben der Methode, das wir heute gelernt haben, bedeutet, dass der Rückgabewert derselbe ist, der Methodenname derselbe ist und die Parameterliste dieselbe ist. Dies wird als Methodenumschreiben bezeichnet, kann aber auch als Methodenüberschreiben bezeichnet werden. 
Wir können auch Umschreibungen mit einem Klick generieren
有几个注意事项：
不能重写被private修饰的方法。
不能重写被final修饰的方法。
子类的方法的访问权限一定要大于等于父类的访问权限。
重写的方法, 可以使用 @Override 注解来显式指定. 有了这个注解能帮我们进行一些合法性校验. 例如不小心将方法名字拼写错了 (比如写成eat）, 那么此时编译器就会发现父类中没有 aet 方法, 就会编译报错, 提示无法构成重写.
被static修饰的方法也不能被重写
总结方法重写的注意事项：
被private，final修饰的方法不能被重写。
被staitc修饰的方法也不能被重写。
@override 可以检查你重写的方法名是否正确，最好要加上。
方法重写一定满足方法名相同，参数列表相同，返回值相同。
对比方法重写与方法重载：
最后：重写不是进行在原来基础的修改，而是在原来基础上进行迭代和更新。
场景：画一个图形
class Shape{//创建一个图形类---->作为多种图形的父类
public int length;//图形的长
public int wide;//图形的宽
public int height;//图形的高
public void draw() {
System.out.println("我要画一个图形！！！");
}
}
class rectangle extends Shape{//长方形
@Override
public void draw() {
System.out.println("我要画一个长方形！！！");
}
}
class square extends Shape{
@Override
public void draw() {
System.out.println("我要画一个正方形！！！");
}
}
class circular extends Shape{
@Override
public void draw() {
System.out.println("我要画一个圆形！！！");
}
}
public class TestDemo1 {
public static void method(Shape shape) {
shape.draw();
}
public static void main(String[] args) {
Shape shape1 = new circular();
Shape shape2 = new rectangle();
Shape shape3 = new square();
method(shape1);
method(shape2);
method(shape3);
}
}创建一个Shape(父类)，然后创建三个子类分别是square ,circular,rectangle,利用父类引用这三个子类，接着调用method方法。
这就是多态，不同的对象，调用同一个方法最后结果产生出不同的状态。
我们再来总结多态产生的条件：
要在继承体系下
子类要对父类的方法进行重写
通过父类的引用调用重写的方法
也就是 在继承体系下 进行向上转型 和 方法重写
优点：
能够降低代码的 "圈复杂度", 避免使用大量的 if - else
如果使用多态, 则不必写这么多的 if - else 分支语句, 代码更简单.
可扩展能力更强
缺点：
代码的运行效率降低
还有一个重要点就是不要在构造方法中调用重写方法
Das obige ist der detaillierte Inhalt vonJava-objektorientierte polymorphe Instanzanalyse. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
