Java面向对象特征之三 多态

文章目录
Java面向对象特征之三 多态
1.多态的定义
2.多态的分类
静多态
动多态
3.向上造型
向上造型的好处
4.多态实例演示
5.多态的实现原理
6.多态的深入理解
6.1 静多态（静态绑定，编译期多态）
6.2 动多态（动态绑定，运行时多态）
多态的优点
可替换性
可扩充性
接口性
Java面向对象特征之三 多态
1.多态的定义
多态是同一个行为具有多种不同的表现形式或形态的能力。允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。（发送消息就是函数调用）
比如黑白打印机和彩色打印机，对打印的操作黑白打印机打印的效果是黑白的，彩色打印机打印出来的效果是彩色的；比如学生和老师，学生的工作是学习，老师的工作是授课；再比如对于一只雄鹰和一只猎豹，雄鹰的运动方式是飞翔，猎豹的运动方式是奔跑。
可见，同一行为，通过不同的事物，可以体现出来的不同的形态，这就是多态。

2.多态的分类
静多态
静多态（静态绑定）----编译期多态
静态多态性指的是程序在编译时，系统就能决定调用哪个函数。
如方法重载问题，条件：

相同作用域
函数名相同
参数列表不同

动多态
动多态（动态绑定）----运行期多态
动态多态性指在运行中才能动态确定操作指针所指的对象。
动多态条件：

继承
方法重写
向上造型

在这里我们介绍动多态问题！

3.向上造型
向上造型用一句话来说就是基类的引用 引用 派生类的对象，基接口的引用 引用 实现该接口的类对象

在上述图例中，People类是Student的基类，当People类对象的引用变量引用子类Student类对象时就是向上造型。如下：
People people = new Student();
people引用.出来的方法是父类的方法接口，但是方法的实现却是子类的实现方式。
Java 的多态机制遵循一个原则：当父类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法 。

向上造型的好处
减少重复代码，使代码变得简洁。
提高系统扩展性。

4.多态实例演示
定义一个People类

public class People {
//实例变量
protected String name;
protected int age;

//构造方法
public People(String name,int age) {
    this.name = name;
    this.age = age;
}

//实例方法
public void work() {
    System.out.println("工作");
}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
定义一个Student类继承People类

public class Student extends People{
//实例变量
private int score;
private int stu_id;

//构造方法
    public Student(String name,int age,int score, int stu_id) {
    super(name,age);//调用父类的有参构造函数，初始化从父类继承下来的实例变量
    this.score = score;
    this.stu_id = stu_id;
}
@Override
public void work() {
    System.out.println("学习");
}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
定义一个Teacher类继承People类

public class Teacher extends People{
int tea_id;

public Teacher(String name, int age,int tea_id) {
    super(name, age);
    this.tea_id = tea_id;
}

@Override
public void work() {
    System.out.println("授课");
}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
图示关系：

使用方式：

public class TestDemo {
public static void main(String[] args) {
People p = new Student(“zs”,18,100,19060611);
p.work();

    People p2 = new Teacher("Lisi",27,1911111);
    p2.work();
}

}
1
2
3
4
5
6
7
8
9
运行结果及分析：

通过运行结果我们发现，引用变量p调用的work()是子类Student的方法，引用变量p1调用的work()是子类Teacher的方法。

5.多态的实现原理
多态的实现原理：地址覆盖。
以实例中People p = new Student(“zs”,18,100,19060611);为例
图示：

首先我们在Java堆上创建了一个Student对象，People类的引用变量p指向了Student对象，Student对象中的对象头里有一个Class引用，Class引用里保存着Class对象的地址，Class对象是在类加载阶段产生的，一个类一个Class对象，保存当前类的类信息，比如实例变量、实例方法，用Class对象里的RTTI（Run-Time Type identification）机制，运行时进行类型信息识别，通过Class对象找到方法区中该类的方法表，方法表中有从父类继承下来的方法，还有自己方法，父类People中有一个work（）方法，子类继承了下来保存在了方法表中，子类中也有个work（）方法，对People类中的方法进行了重写，而在方法表中子类的work（）方法地址对父类的work（）方法地址进行了覆盖，所以当People类的引用变量p调用work（）时调用的是子类当中的work（）方法。

6.多态的深入理解
对于面向对象而已，多态分为编译时多态和运行时多态。其中编译时多态是静态的，主要是指方法的重载，它是根据参数列表的不同来区分不同的函数，通过编译之后会变成两个不同的函数，在运行时谈不上多态。而运行时多态是动态的，它是通过动态绑定来实现的，也就是我们所说的多态性。

6.1 静多态（静态绑定，编译期多态）
静多态也称编译时的多态，就是我们所说的方法重载。相同的方法名，根据形参类型个数或类型的不同调用不同的方法。在编译期间就已经确定要调用的方法。

6.2 动多态（动态绑定，运行时多态）
所谓动多态就是指程序中定义的引用变量所引用具体对象类型以及通过该引用变量进行方法调用时在编译期并不确定，而是在程序运行期间才确定，即一个引用变量到底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。因为在程序运行时才确定具体的类，这样，不用修改源程序代码，就可以让引用变量绑定到各种不同的类实现上，从而导致该引用调用的具体方法随之改变，即不修改程序代码就可以改变程序运行时所绑定的具体代码，让程序可以选择多个运行状态，这就是多态性。

多态的优点
可替换性
多态对已存在代码具有可替换性。例如，多态对People类设计，对其他任何人类，如学生，老师也同样具有工作的行为。

可扩充性
多态对代码具有可扩充性。增加新的子类不影响已存在类的多态性、继承性，以及其他特性的运行和操作。实际上新加子类更容易获得多态功能。

接口性
多态是父类通过方法声明，向子类提供了一个共同接口，由子类来完善或者覆盖它而实现的。
————————————————
版权声明：本文为CSDN博主「WYSCODER」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/sheng0113/article/details/121295732