Java的多态

什么是多态？

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

需要理解：

向上转型

---

向上转型：实际就是创建一个子类对象，将其当成父类对象来使用。

语法格式：父类类型 对象名 = new 子类类型()

Animal animal = new Cat("元宝",2);

animal是父类类型，但可以引用一个子类对象，因为是从小范围向大范围的转换。

• 向上转型的优点：让代码实现更简单灵活。

• 向上转型的缺陷：不能调用到子类特有的方法。

---

向下转型

---

将一个子类对象经过向上转型之后当成父类方法使用，再无法调用子类的方法，但有时候可能需要调用子类特有的

方法，此时：将父类引用再还原为子类对象即可，即向下转换。

public class TestAnimal {
 public static void main(String[] args) {
   Cat cat = new Cat("元宝",2);
   Dog dog = new Dog("小七", 1);
// 向上转型
   Animal animal = cat;
   animal.eat();
   animal = dog;
   animal.eat();
// 向上转型
// 程序可以通过编程，但运行时抛出异常---因为：animal实际指向的是狗
// 现在要强制还原为猫，无法正常还原，运行时抛出：ClassCastException
   cat = (Cat)animal;
   cat.mew();
// animal本来指向的就是狗，因此将animal还原为狗也是安全的
   dog = (Dog)animal;
   dog.bark();
 }
}

 if(animal instanceof Cat){
  cat = (Cat)animal;
  cat.mew();
}
  if(animal instanceof Dog){
  dog = (Dog)animal;
  dog.bark();
}

方法的重写和重载区别

---

重写：@override                                                重载：@overload

1.方法名称相同                                                1.方法名称相同

2.参数列表相同【个数，顺序，类型】           2.参数列表不同【个数，顺序，类型】

3.返回值类型相同                                            3.返回值没有要求

（注：被private修饰的方法不能重写；

被static修饰方法不能重写；

子类的访问修饰限定符一定要大于等于父类的访问修饰限定符；

被final修饰的方法不能被重写）

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

1. 必须在继承体系下

1. 子类必须要对父类中方法进行重写

1. 通过父类的引用调用重写的方法

多态体现：在代码运行时，当传递不同类对象时，会调用对应类中的方法。

多态的优点

【使用多态的好处】

1. 能够降低代码的"圈复杂度", 避免使用大量的if - else

public static void drawShapes() {
  Rect rect = new Rect();
  Cycle cycle = new Cycle();
  Flower flower = new Flower();
  String[] shapes = {"cycle", "rect", "cycle", "rect", "flower"};
 
  for (String shape : shapes) {
   if (shape.equals("cycle")) {
     cycle.draw();
    } else if (shape.equals("rect")) {
   rect.draw();
    } else if (shape.equals("flower")) {
  flower.draw();
  }
 }
}

 如果使用使用多态, 则不必写这么多的 if - else 分支语句, 代码更简单

 public static void drawShapes() {
// 我们创建了一个 Shape 对象的数组.
  Shape[] shapes = {new Cycle(), new Rect(), new Cycle(),
  new Rect(), new Flower()};
  for (Shape shape : shapes) {
    shape.draw();
  }
}

1. 可扩展能力更强

如果要新增一种新的形状, 使用多态的方式代码改动成本也比较低

class Triangle extends Shape {
  @Override
  public void draw() {
    System.out.println("△");
  }
}

对于类的调用者来说(drawShapes方法), 只要创建一个新类的实例就可以了, 改动成本很低.

而对于不用多态的情况, 就要把 drawShapes 中的 if - else 进行一定的修改, 改动成本更高.

多态缺陷：代码的运行效率降低。

1. 属性没有多态性

当父类和子类都有同名属性的时候，通过父类引用，只能引用父类自己的成员属性