【JavaSE】面向对象三大特性之多态

多态的概念

多态可以理解为一个对象在某些时刻可以代表不同的对象，指的是对象的多种形态。所以在某些时刻，通过这个对象去实现行为时，会出现不同的状态。

向上转型

多态要发生，那么就要满足三种情况：

1、有继承关系
2、向上转型
3、子类必须对父类中方法进行重写，通过父类引用调用重写方法

下面我们先来看看向上转型

理论上我们在创建变量时，两边的数据类型要相同 ，但是我们来看看我们这个代码 Animal animal = new Cat();此时我们两边的数据类型并不相同，前面是父类Animal类后面new了一个Cat类，因为猫是动物的，把子类对象Cat转化为Animal是合理的，我们称为向上转型。那么此时使用animal去访问Animal和Cat的成员方法的时候会发生什么呢？

class Animal {
    public String name;
    public int age;

    public Animal() {

    }

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void eat() {
        System.out.println(name + "吃饭");
    }
}

class Cat extends Animal {

    public Cat() {
        super();
    }

    public Cat(String name, int age) {
        super(name, age);
    }
    
    public void miaomiao() {
        System.out.println("喵喵");
    }

    @Override
    public void eat() {
        System.out.println(name + "吃猫粮");
    }
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

当我们使用向上转型去访问子类特有的方法时会报错，所以我们说当发生了向上转型后，父类的引用只能访问自己的成员，不可以访问到子类特有的成员。

重写之动态绑定与重载之静态绑定

我们讲了要发生多态的三种条件的两条了，现在就剩下子类必须对父类中方法进行重写，通过父类引用调用重写方法这个条件了，这个条件该怎么理解呢？什么是重写呢？下面我们就来讲讲：
重写顾名思义，就是将父类中的方法在子类中重新写一边，方法的参数、返回值、方法名都不变，将方法内部的方法实现进行重新编写。那重写有什么意义呢？让我们举个例子：还是猫猫类和动物类



此时我们通过向上转型了创建了一个对象，通过这个对象去访问这个eat方法，会发生什么事呢？

我们发现跟我们所想的不一样，难道animal.eat();不应该是调用父类的eat();方法嘛？我们通过看看底层的代码逻辑：

编译时调用父类方法，而在运行时又变为子类的eat();方法了，我们称这样的过程为动态绑定，这也是多态的体现，假如现在又有一个狗狗类，狗狗类继承动物类，也重写了eat();方法我们向上转型创建一个狗狗对象，调用eat();方法，这时我们又会运行狗狗类的eat();方法，这样就解释了多态的概念在某些时刻，通过这个对象去实现行为时，会出现不同的状态。

重写与重载的区别

有动态绑定那么有没有静态绑定呢？当然是有的，在之前我们提到过重载概念，他在我们编译的时候就已经知道该调用什么方法了，我们称这样的方式为静态绑定。那么重写与重载有什么区别呢？

重写的注意事项总结

重写时有一些值得我们注意的地方：

1、父类中static private final修饰的方法，都不可以被重写
2、子类重写父类方法时，必须与父类方法一致，方法名、返回值类型、参数
3、访问权限不能比父类中被重写的方法的访问权限低。例如父类中方法被public修饰重写时就不能用protected

不安全的向下转型

如果大家可以理解向上转型，那么大家也一定可以理解向下转型：

为什么说向下转型是不安全的呢？因为向上转型：猫猫类属于动物类，向上转型符合逻辑，但是动物类都是猫猫类嘛？不是吧，所以会出现问题，我们在代码中看一看：

class Animal {
    public String name;
    public int age;

    public Animal() {

    }

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void eat() {
        System.out.println(name + "吃饭");
    }
}



class Cat extends Animal {

    public Cat() {
        super();
    }

    public Cat(String name, int age) {
        super(name, age);
    }


    @Override
    public void eat() {
        System.out.println(name + "吃猫粮");
    }
}



class Dog extends Animal {

    public Dog() {
        super();
    }

    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println(name + "吃狗粮");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

编译之后我们发现报错了，抛出了一个异常，这种情况我们可以使用instanceof进行判断：


这样就好了，以上就是向下转型的不安全性，在实际的开发中我们也很少会用到。

多态的优点和注意事项

优点

多态可以降低代码的圈复杂度，圈复杂度简单粗暴的理解为一段代码中if else出现的次数。我们来看这样一段代码：

我们希望打印多个形状，我们就可以创建一个父类Shape数组，里面的元素为子类对象，这时会发生向上转型，我们遍历数组，调用draw方法就可以打印对应的图形，如果我们没有多态，那么我们还需要使用if else进行判断，再去调用对应的对象的方法，十分麻烦。而且如果我们希望增加一个新的形状，也十分简单，只需要增加一个子类就可以了。

缺点和注意事项

1、属性没有多态：当父类和子类都有同名属性的时候，通过父类引用，只能引用父类自己的成员属性
2、构造方法没有多态性

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

所以：用尽量简单的方式使对象进入工作状态，尽量不要在构造器中调用方法，可能会出现一些隐藏的但又极难发现的问题。