java--多态（详解）

                           欢迎来到权权的博客~欢迎大家对我的博客提出指导

这是我的博客主页：点击

一、概念

通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同 的状态。

二、多态实现的条件

在java中要实现多态，必须要满足如下几个条件，缺一不可：

1. 必须在继承体系下
2. 子类必须要对父类中方法进行重写
3. 通过父类的引用调用重写的方法

三、向上转型和向下转型

3.1 向上转型

三种向上转型的方式：

---

1.直接赋值

  Animals animals=new Dog("小狗",6);

---

2.方法的传参

  public static void func(Animals animal){}public static void main(String[] args) {Dog dog=new Dog("x",6);func(dog);}

---

3.返回值

    public static Animals func2(){Dog dog=new Dog("x",56);return dog;}public static void main(String[] args) {Animals animals=func2();}
}

---

缺点：通过父类的引用不能调用子类的方法

---

3.2 向下转型

向下转型无非就是把一个父类引用放着子类对象，然后强转成对应的子类类型在赋值给子类引用，也就是将父类引用还原成子类对象。

class TestAnimal {public static void main(String[] args) {//向下转型 -> 不安全//instanceof 判断animal引用的对象是不是Dog类型的，如果是则为 true 不是则为 falseAnimal animal = new Dog("王五", 12);if (animal instanceof Dog) {Dog dog = (Dog)animal;dog.eat();}}
}

四、重写和重载

重写(override)：也称为覆盖。重写是子类对父类非静态、非private修饰，非final修饰，非构造方法等的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。

【方法重写的规则】：

子类在重写父类的方法时，一般必须与父类方法原型一致：返回值类型方法名 (参数列表) 要完全一致被重写的方法返回值类型可以不同，但是必须是具有父子关系的。
访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类方法被public修饰，则子类中重写该方法就不能声明为 protected父类被static、private修饰的方法、构造方法都不能被重写。
重写的方法, 可以使用@Override注解来显式指定. 有了这个注解能帮我们进行一些合法性校验. 例如不小心将方法名字拼写错了 (比如写成 aet), 那么此时编译器就会发现父类中没有 aet 方法, 就会编译报错, 提示无法构成重写.

---

---

在子类中对父类的方法进行重写

---

方法重载是一个类的多态性表现,而方法重写是子类与父类的一种多态性表现。

public class TestMethod {
public static void main(String[] args) {
add(1, 2); // 调用add(int, int)
add(1.5, 2.5); // 调用add(double, double)
add(1.5, 2.5, 3.5); // 调用add(double, double, double)
}
public static int add(int x, int y) {
return x + y;
}
public static double add(double x, double y) {
return x + y;
}
public static double add(double x, double y, double z) {
return x + y + z;
}
}

---

【重写和重载的区别】

---

五、理解多态

可以看到animals引用的对象是不一样的，但是调用的是同一个方法，此时表现出的不同现象我们叫做多态。

---

5.1练习：

打印指定不同图案(多态实现)：

public class Drawing {public void draw() {System.out.println("画图");}
}
class DrawCircle extends Drawing {@Overridepublic void draw() {System.out.print("⚪");}
}
class DrawFlower extends Drawing {@Overridepublic void draw() {System.out.print("❀");}
}
class DrawTriangle extends Drawing {@Overridepublic void draw() {System.out.print("▲");}
}

第一种方法：用 for-each语句

class TestDraw {//方法一：使用 循环 + if elsepublic static void draw1() {DrawTriangle triangle = new DrawTriangle();DrawFlower flower = new DrawFlower();DrawCircle circle = new DrawCircle();String[] shapes = {"Triangle", "Flower", "Flower", "Circle", "Flower", "Triangle"};//增强for循环遍历数组for (String s : shapes) {if (s.equals("Triangle")) {triangle.draw();} else if (s.equals("Flower")) {flower.draw();} else if (s.equals("Circle")) {circle.draw();}}}public static void main(String[] args) {draw1();}
}

第二种用多态

class TestDraw {public static void draw2() {Drawing[] shapes = { new DrawTriangle(), new DrawFlower(), new DrawFlower(),new DrawCircle(), new DrawFlower(), new DrawTriangle()};for (Drawing s : shapes) {s.draw();}}public static void main(String[] args) {draw2();}
}

---

多态部分的优点：

可以有效降低代码复杂度，避免出现多个 if else可扩展性更强，如果要新增打印，也更简单

多态的缺点：

属性没有多态性，当父类属性和子类属性同名，通过父类引用只能调用父类自己的成员属性构造方法也没有多态性

5.2避免在构造方法中调用重写的方法：

class A {public A() {func();}public void func() {System.out.println("A.func()");}
}
class B extends A {private int num = 1;@Overridepublic void func() {System.out.println("B.func() " + num);}
}
public class Test {public static void main(String[] args) {A b = new B();}
}

---

可以看到构造 D 对象的同时, 会调用 B 的构造方法。
B 的构造方法中调用了 func 方法, 此时会触发动态绑定, 会调用到 D 中的 func此时 D >对象自身还没有构造, 此时 num 处在未初始化的状态, 值为 0.。
如果具备多态性，num的值应该是1.所以在构造函数内，尽量避免使用实例方法，除了final和private方法。

结论: “用尽量简单的方式使对象进入可工作状态”, 尽量不要在构造器中调用方法(如果这个方法被子类重写, 就会触发动态绑定, 但是此时子类对象还没构造完成), 可能会出现一些隐藏的但是又极难发现的问题。

欧耶！！！我学会啦！！！