文章目录

前言

一、多态的概念

二、向上转型和向下转型

2.1 向上转型

2.2 什么是向上转型

2.3 三种常见的向上转型

2.3.1 直接赋值

2.3.2 作为方法的参数

2.3.3 作为方法的返回值

2.4 向下转型（这个了解即可）

三、方法重写

3.1 方法重写的概念

3.2 方法重写的规定

3.3 在IDEA中使用重写的快捷方式

3.4 方法重写中所要注意的细节

四、多态

4.1 什么是多态

4.2 多态产生的前提

五、理解多态含义

六、多态的优缺点

6.1 使用多态的好处

6.2 多态的缺点

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

总结

前言

今天我们将进入到多态的学习，在上一章中我们学习了有关继承的概念，今天我们学习Java的第二个重要特性多态，本节内容也十分重要，我们应该认真学习并且掌握；

一、多态的概念

多态，从语文的层次上来说：一种事务，多种形态；这句话不算对，但也不算错；

但是，我们需要从程序的角度上来介绍：去完成某个行为，当不同的对象去完成时，会产生不同的状态，这就是多态。

举例说明：

比如说，如下图所示：同样是一个打印机，去打印相同的照片；但是，交给彩色打印机打印出来的就是彩色的照片；交给黑白打印机打印出来的就是黑白照片；它们完成的动作都是“打印”；这就是一种多态；

再比如说，如下图所示，去“吃饭”，对于小猫来说，吃的是“猫粮”；但对于小狗来说，吃的确是“狗粮”；他们完成的都是“吃饭”这个行为，但是却“吃出不同的结果来”；这也是一种多态；

总的来说，同一件事情，发生在不同的对象上，会产生不同的结果。

总结：

那么，要想真正了解多态，我们还是需要从三个方面来介绍：

什么是向上转型；
什么叫做方法重写；
了解了前两个，我们才会真正了解什么是多态。

下面我们依次介绍

二、向上转型和向下转型

2.1 向上转型

2.2 什么是向上转型

首先介绍一段平平常常的继承代码：
package Demo1;
class Animal {
    public String name;
    public int age;
 
    public void eat() {
        System.out.println(this.name+"吃饭！");
    }
}
 
class Cat extends Animal {
    public String hair;
    public void mew() {
        System.out.println(this.name+"正在叫!");
    }
}
 
public class TestDemo1 {
 
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.mew();
    }
}
那么，如果现在抛开继承不谈，直接用Animal类 new一个animal对象，可以发现，animal对象访问不了Animal类里面没有的成员变量或成员方法：

接下来，可以来讲一讲向上转型的知识了：

这里的上指的是父类，那么下指的就是子类；

那么，把子类给父类是什么意思呢？
        //即：定义类一个 cat
        //可以用animal来接收
 
        //也就是说，父类的引用 可以用来引用 子类的对象
 
        Cat cat = new Cat();
        Animal animal = cat;
 
        //也就是说，上面的两行代码，可以合并成下面一行代码
        
        Animal animal = new Cat();
   
        //此时，父类的引用 引用了 子类的对象，我们把这个就叫做 向上转型
但是，此时又有一个新的问题；

animal的类型是Animal，那么此时它只能去访问类Animal 的成员变量和方法，去访问子类Cat的成员变量或方法的时候会报错：

【总结】

向上转型，把原来的子类的类型转换成了父类的类型，那么，就只能去访问父类特有的成员方法或者成员变量。

2.3 三种常见的向上转型

2.3.1 直接赋值

所谓直接赋值，就是上面的直接把子类对象给父类进行引用：

        /*
        Cat cat = new Cat();
        Animal animal = cat;
        */
 
 
        Animal animal = new Cat();

2.3.2 作为方法的参数

2.3.3 作为方法的返回值

2.4 向下转型（这个了解即可）

前面已经介绍过向上转型，那么现在来介绍一下向下转型：

不过，现在来执行一下这样的操作：

此时，运行结果：

但是，向下转型不安全（不介意使用向下转型）：

我们还需要做以下修改以保证其安全性：

【注意】

三、方法重写

由上面可知，父类引用引用了子类的对象；但是，在现实生活中，猫是吃猫粮的；

那么，如果想改的话，肯定不可以在父类上面进行修改的；毕竟，可能还有其他的子类来继承父类；

那么，如果想修改的话，就需要在子类里面重新取实现一遍这个方法的：

然后，我们来对比一下实现前后的结果：

没有在子类里面写eat方法：

在子类里面写了eat方法：

这是怎么回事呢？

这就是马上所要介绍的方法重写。

3.1 方法重写的概念

重写，也称为覆盖；

重写，是子类对父类非静态、非private修饰、非final修饰、非构造方法等的实现过程进行重新编写；

重写的好处是：子类可以根据需要，定义特定的属于自己的行为；如上面的猫可以吃猫粮，狗可以吃狗粮。

3.2 方法重写的规定

方法重写满足以下三个条件：

方法的名称相同；
方法的返回值相同；
方法的参数列表相同。

当在子类方法重写以后，那么就会调用的是子类重写的内容。

我们把这个现象叫做动态绑定（这是多态的基础）

在上面所示例中，

在编译的时候，调用的还是父类Animal的eat方法；

但是，在运行的时候，变成了子类Cat自己的eat方法；

因此，动态绑定又称为运行时绑定，

即：在程序运行的时候才知道要调用谁。

当然，有了动态绑定，那肯定也有静态绑定：

在编译期间就已经知道了要调用的是谁，比如说重载。

3.3 在IDEA中使用重写的快捷方式

当然，在使用IDEA编译器的时候，

重写不仅仅可以直接在子类上手敲出来的（上面的就是），而且还可以使用快捷键的方式：

快捷键步骤;

3.4 方法重写中所要注意的细节

1.静态方法（static修饰）是构成不了重写的：

2.private修饰的方法不能进行重写：

3.如果要进行重写的话，那么子类的访问限定修饰符的权限一定大于等于父类的访问限定修饰符：

访问限定符权限大小比较：

private < default < peotected < public

4.被final修饰的方法不可以进行重写：

5.
子类和父类在同一个包中，那么子类可以重写父类的所有方法（除了声明为private和final的方法）；子类和父类不在同一个包，那么子类只能够重写父类的声明为public和protected的非final的方法（即默认权限方法/包访问权限不可以被重写）；

6.重写的方法，可以使用 @Override 注解来显示指定；有了这个注解可以帮助我们进行一些合法性校验；如不小心把方法名字写错了（写成ate），那么此时编译器就会发现父类中没有ate方法，就会编译报错，提示无法构成重写。

四、多态

4.1 什么是多态

类的实现者所写的代码：

class Animal {
 
    public String name;
    public int age;
    public void eat() {
        System.out.println(this.name+"吃饭！父类Animal");
    }
}
 
class Cat extends Animal {
    public String hair;
 
    public void eat(){
        System.out.println(this.name+"吃猫粮！");
    }
    public void mew() {
        System.out.println(this.name+"正在叫!");
    }
}
class Dog extends Animal {
        public void eat(){
            System.out.println(this.name+"吃狗粮！");
    }
}

类的调用者所写的代码：

    public static void function(Animal animal) {
        animal.eat();
    }
 
    public static void main(String[] args) {
        Cat cat = new Cat();
        Dog dog = new Dog();
        function(cat);
        function(dog);
    }

所以运行之后得到的结果不一样：

从上面可以得到，同一个方法，当引用的对象不一样的时候，这个方法所表现出来的行为是不一样的；我们把这种思想就叫做多态。

4.2 多态产生的前提

发生向上转型：父类引用引用子类的对象；
发生重写：父类和子类当中有同名的覆盖方法；
通过父类引用，调用这个重写的方法，此时会发生动态绑定

思想：通过一个引用调用一个方法，由于引用的对象不同，所执行的行为也是不一样的；我们把这种思想就叫做多态的思想。

五、理解多态含义

回顾一下多态：

场景：现在想画一个图形（图形是未知的）：

首先，创建父类：
class Shape {
    //省略了长、宽、高等之类的属性
    public void draw(){
        System.out.println("画图形！！！！！！");
    }
 
}
创建父类Shape只是画父类，但是并没有说明画什么；

现在想画各种各样的图形，那么就可以去重写 Shape类里面的draw方法来满足自己的需求：
class Cycle extends Shape {
    @Override
    public void draw() {
        System.out.println("○");
    }
}
 
class Rect extends Shape {
    @Override
    public void draw() {
        System.out.println("  ⃟ ");
    }
}
 
class Triangle extends Shape {
    @Override
    public void draw() {
        System.out.println("△");
    }
}
前面两段代码都是类的实现者写的；

当有一天作为用户、作为类的调用者想要画出这些图形，那么就可以这样来做：
    public static void drawMap(Shape shape) {
        shape.draw();
    }
    public static void main(String[] args) {
        Cycle cycle = new Cycle();
        Rect rect = new Rect();
        Triangle triangle = new Triangle();
        
        drawMap(cycle);
        drawMap(rect);
        drawMap(triangle);
    }
那么，根据引用的对象不一样，draw方法所表现的行为就不一样；

这个就叫做多态。

代码示例结果：

那么，多态到底有什么好处呢？

——其拓展能力非常强：

如果突然说，现在想要画一朵花：

那么只需要在这样做即可：
class Flower extends Shape {
    @Override
    public void draw() {
        System.out.println("✿");
    }
}
测试类添上这个来测试：
drawMap(new Flower());
代码示例结果：

六、多态的优缺点

6.1 使用多态的好处

（1）能够降低代码的 "圈复杂度" ，避免使用大量的 if-else语句；

说白了，可以简单粗暴的计算一段代码中条件语句和循环语句出现的个数，这个个数就称为 "圈复杂度"；如果一个方法的圈复杂度太高，就需要考虑重构。

（2）可扩展能力强；

就是上面所说的添加了一朵花的示例。

6.2 多态的缺点

代码的运行效率低。

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

 
class B {
    public B(){
        func();
    }
 
    public void func() {
        System.out.println("B.func() ");
    }
}
 
class D extends B {
    D(){
        super();
    }
    @Override
    public void func() {
        System.out.println("D.func() ");
    }
}
 
public class Test {
    public static void main(String[] args) {
        D d = new D();
    }
}
代码示例结果：

【说明】

构造D对象的同时，会调用B的构造方法；
B的构造方法中调用了 func方法，此时会触发动态绑定，会调用到D中的 func；