Java中的多态

1. 多态的概念

通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态.
比如：
在对于吃饭这件事，猫吃猫粮，狗吃狗粮，不同的对象去完成时，会产生不同的状态。
总的来说：同一件事情，发生在不同对象身上，就会产生不同的结果。

2. 多态实现条件

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

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

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

当类的调用者在编写 eat 这个方法的时候, 参数类型为 Animal (父类), 此时在该方法内部并不知道, 也不关注当前的animal 引用指向的是哪个类型(哪个子类)的实例. 此时 a这个引用调用 eat方法可能会有多种不同的表现(和 animals引用的实例相关), 这种行为就称为多态.

3. 重写

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

【方法重写的规则】：
子类在重写父类的方法时，一般必须与父类方法原型一致：

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

【重写和重载的区别】：

静态绑定：也称为前期绑定(早绑定)，即在编译时，根据用户所传递实参类型就确定了具体调用那个方法。典型代表函数重载。
动态绑定：也称为后期绑定(晚绑定)，即在编译时，不能确定方法的行为，需要等到程序运行时，才能够确定具体调用那个类的方法。

4. 向上转移和向下转型

4.1 向上转型

向上转型：实际就是创建一个子类对象，将其当成父类对象来使用。
语法格式：父类类型 对象名 = new 子类类型()

 Animal animal = new Cat("小喵",2);

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

使用情况：
1.直接赋值

 Animal animal = new Cat("小喵",2);//直接赋值：子类对象赋值给父类对象

2.方法传参

public class Test {
    public static void test(Animals animals){//形参为父类型引用，可以接收任意子类的对象
        animals.eat();
    }
    public static void main(String[] args) {
        Animals cat=new Cat("小喵",2);
        test(cat);//Cat类传递给Animals类
    }
}

3.方法返回

public class Test {
                  //返回任意子类对象
    public static Animals test(Animals animals){
        return new Cat("小喵",1);//从Cat类返回到Animals类，向上转型
    }
    public static void main(String[] args) {
        Animals cat=new Cat("小喵",2);
        test(cat);
    }
}

向上转型的优点：让代码实现更简单灵活。
向上转型的缺陷：不能调用到子类特有的方法。

4.2 向下转型

将一个子类对象经过向上转型之后当成父类方法使用，再无法调用子类的方法，但有时候可能需要调用子类特有的方法，此时：将父类引用再还原为子类对象即可，即向下转换。

通过下列代码我们来研究：

class Animals {
    String name;
    int age;
    public void eat(){
        System.out.println("name+“吃饭！”");
    }
}
class Dog extends Animals{
    public Dog(String name, int age) {
        super();
        this.name=name;
        this.age=age;
    }
    @Override
    public void eat() {
        super.eat();
        System.out.println(name+"吃狗粮！");
    }
    public void bark(){
        System.out.println(name+"汪汪叫！");
    }
}
class Cat extends Animals {
    public Cat(String name, int age) {
        super();
        this.name=name;
        this.age=age;
    }
    @Override
    public void eat() {
        super.eat();
        System.out.println(name + "吃喵粮");
    }

    public void mew() {
        System.out.println(name+"喵喵叫！");
    }
}
public class TestAnimals {
    public static void main(String[] args) {
        Dog dog1=new Dog("小狗",1);
        Animals animals=dog1;
        Dog dog2=(Dog)animals; // animal本来指向的就是狗，因此将animal还原为狗也是安全的
        dog1.bark();//ok
        Cat cat =(Cat) animals; // 现在要强制还原为猫，无法正常还原，运行时抛出异常
        cat.mew();
    }
}

向下转型用的比较少，而且不安全，万一转换失败，运行时就会抛异常。Java中为了提高向下转型的安全性，引入
了instanceof，如果该表达式为true，则可以安全转换。

public class TestAnimals {
    public static void main(String[] args) {
        Dog dog1=new Dog("小狗",1);
        Animals animals=dog1;
        Dog dog2=(Dog)animals;
        if(animals instanceof Cat){
            Cat cat = (Cat)animals;
            cat.mew();
        }
        if(animals instanceof Dog){
            dog2 = (Dog)animals;
            dog2.bark();
        }
    }
}

5. 多态的优缺点

测试下列代码：

class Shape {
    //属性....
    public void draw() {
        System.out.println("画图形！");
    }
}
class Rect extends Shape{
    @Override
    public void draw() {
        System.out.println("♦");
    }
}
class Flower extends Shape{
    @Override
    public void draw() {
        System.out.println("❀");
    }
}
class Cycle extends Shape{
    @Override
    public void draw() {
        System.out.println("●");
    }
}
public class Test1 {
    public static void main(String[] args) {
        Shape shape1=new Cycle();
        shape1.draw();
        Shape shape2=new Rect();
        shape2.draw();
        Shape shape3=new Flower();
        shape3.draw();
    }
}

优点：

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()};//向上转型为Shape类
    for (Shape shape : shapes) {
        shape.draw();
    }
}

2. 可扩展能力更强
   如果要新增一种新的形状, 使用多态的方式代码改动成本也比较低.

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

对于类的调用者来说(drawShapes方法), 只要创建一个新类的实例就可以了, 改动成本很低.
而对于不用多态的情况, 就要把 drawShapes 中的 if - else 进行一定的修改, 改动成本更高.

缺点 :

• 代码的运行效率降低
• 属性没有多态性当父类和子类都有同名属性的时候，通过父类引用，只能引用父类自己的成员属性
• 构造方法没有多态性

6. 避免在构造方法中调用重写的方法

测试下列代码：

class B {
    public B() {
        // do nothing
        func();
    }
    public void func() {
        System.out.println("B.func()");
    }
 }
class D extends B {
    private int num = 1;
    @Override
    public void func() {
        System.out.println("D.func() " + num);
    }
 }
public class Test {
    public static void main(String[] args) {
        D d = new D();
        d.func();
    }
 }

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

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