【Java基础篇 | 面向对象】—— 聊聊什么是多态（下篇）

个人主页：兜里有颗棉花糖
欢迎点赞👍 收藏✨ 留言✉ 加关注💓本文由兜里有颗棉花糖原创
收录于专栏【JavaSE_primary】
本专栏旨在分享学习JavaSE的一点学习心得，欢迎大家在评论区讨论💌

一、动态绑定和静态绑定

动态绑定

动态绑定（也叫晚绑定或者运行时绑定）：在编译时不能确定方法的行为，需要等到程序运行时才能够确定调用的具体是哪个类中的方法。

什么时候会用到动态绑定：
当一个子类继承自一个父类并重写了父类的方法时，就会涉及到Java的动态绑定。在运行时，实际上调用的是子类重写后的方法，而不是父类的方法。
举个栗子：
解释：子类Dog重写了父类Animal中的eat方法，在main方法中创建了一个Animal类型的引用animal，并将其实例化为Dog对象。最后通过调用它的eat方法，会根据实际对象的类型，动态地绑定到对应的方法上。
代码编译时的确调用的是父类Animal中的eat方法，但是最终运行结果是调用了子类中的eat方法（本质就是因为这里发生了重写，同时这里是通过父类来去调用子类中重写的这个eat方法的）。

动态绑定发生之前必须具备两个条件：

第一：父类和子类中必须存在重写的方法。
第二：通过父类的引用来去调用重写的方法。

静态绑定

静态绑定（也称为早绑定）：在编译时，根据用户所传递参数个数、实参类型等就可以确定具体调用哪个方法。

比如我们之前学过的重载就是很好的一个静态绑定的例子。
举个栗子：

public add(int a,int b,int c) {
	return a + b + c;
}

public void eat(int a,int b) {
    return a + b;
}

二、向上转型和向下转型

向上转型

向上转型：简单来说就是用父类引用来接受子类对象。

向上转型发生的三种时机：直接赋值、传参、返回值。

第一种时机：
直接赋值的方式：Animal animal = new Dog("cc",10);

第二种时机：传参。

第三种时机：返回值。

再来回顾多条的概念：父类引用引用子类对象时，当引用的子类对象的对象类型不一样时，通过父类引用去调用父类和子类重写的方法，此时同一个引用可以呈现出不同的状态，我们把这个思想称之为多态。官方一点：多态是指对象根据其实际的类型来执行不同的操作或表现出不同的行为的能力。

向上转型优点：让代码实现更加灵活。
向上转型缺点：不能调用子类特有的方法而只能调用父类和子类重写的方法。

向下转型

重要的事情放前面：向下转型不是很安全，一般很少用到。

向下转型概念：将一个子类对象经过向上转型之后当成父类方法使用，此时就无法调用子类的特有方法（而只能调用父类和子类重写的方法）；但是有时候可能需要调用子类特有的方法，此时：将父类引用再还原为子类对象即可，即向下转换。

向下转型是非常不安全的，转换失败的话运行时就会抛出异常。所以Java中为了提高向下转型的安全性，引入了 instanceof ，如果该表达式为true，则可以安全转换。
举个栗子：

下面这种方式才是安全的使用方法：

三、多态的优缺点

多态优点：能够降低代码的 “圈复杂度”, 避免使用大量的 if - else
多态缺点：可扩展能力更强

降低代码的 “圈复杂度”，举栗请看如下代码：

class Shape {
    public void draw() {
        System.out.println("什么图形?");
    }
}
class Rect extends Shape{
    @Override
    public void draw() {
        System.out.println("矩形");
    }
}
class Cycle extends Shape{
    @Override
    public void draw() {
        System.out.println("圆形");
    }
}

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

现在我们如果想打印不同的图形，如果基于多态来实现的话，代码如下：

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

如果我们基于多态来进行实现的话，代码只有那么几行，请看：

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

至于多态的拓展能力强这里优点，我们还是拿上面的代码进行举栗：除了上述图形之外，我们还可以添加其它各种各样的图形。

多态缺陷：
1.属性是没有多态性的：方法我们可以进行重写，但是属性是不可进行重写的（当父类和子类都有同名属性的时候，通过父类引用，只能引用父类自己的成员属性）。
2.我们应该避免在构造方法中去调用重写的方法（具体为啥请看下面一小节）。

四、避免在构造方法中去调用重写的方法

我们还是拿代码进行举例，请看：

class B {
    public B() {
        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 对象的同时, 会调用 B 的构造方法。
B 的构造方法中调用了 func 方法, 此时会触发动态绑定, 会调用到 D 中的 func。（由于此时 D 对象自身还没有构造, 所以num 处在未初始化的状态。
所以在构造函数内，尽量避免使用实例方法，除了final和private方法。

在构造方法中调用重写方法可能会导致意想不到的结果。因为在对象初始化时，子类重写的方法可能还没有被执行，所以调用该方法可能会得到父类中的默认实现，而不是子类所期望的行为。

好了，以上就是本文的全部内容啦，就到这里吧。再见啦友友们！！！

在这里插入图片描述