Java多态原理

最近在准备面试，顺便复习以下Java最基础的东西
仅作参考

为了更好地理解多态的原理，首先必须对jvm内存模型、Java方法调用等知识有点了解。

0. 什么是多态

多态分为两种，本文着重讲解运行时多态。

1. 编译时多态。也叫做静态多态，指的是方法的重载，在同一个类中，同样的方法签名却有不同的参数。编译时通过静态绑定就能实现。
2. 运行时多态。也叫做动态多态，指的是方法的重写，在具有继承关系的类中，子类重写了父类方法，方法签名和参数都一致，父类引用指向子类实例，该引用调用被重写方法时实际上调用的是子类的方法。需要运行时进行动态绑定实现。

1. jvm内部类信息

在下图可以看到jvm关于方法区中的类信息。

jvm通过类加载器，把类加载进方法区，在方法区维护了类的基本信息，其中就包括了方法信息，而为了能够快速访问具体方法，每个类都有一个方法表，里面存放了指向对应方法的指针。当需要调用某个类的方法时，只需要找到相应偏移量，就能够快速地找到对应的方法。

方法表的构成：

某个类的方法表包含了Object类、祖先类、父类、自身的方法指针。

2. 多态的实现原理

举个例子 A b = new B();,A B是具有继承关系的。示例代码如下：

public class A{
    //对比方法
    public void method1(){
        ...;
    }
    //被子类重写的方法
    public void method2(){
        ...;
    }
}

public class B extend A{
    //对比方法
    public void method3(){
        ...;
    }
    //重写了父类的方法
    @Override
    public void method1(){
        ...;
    }
}

在方法表里是如何的呢？

看下图：

可以看到，重写就是把子类方法的指针替换了方法表里父类对应方法项的值！

那么，具体的调用过程是怎样的呢？

A b = new B();
b.method2();

注意：此处笔者没有深入研究方法调用过程，仅作参考！欢迎同学们在评论区指正23333
首先，通过变量类型A，找到A的类信息，确定A的method方法的偏移量。

然后，通过对象引用，找到堆中B对象，通过B对象，找到B类信息，根据偏移量，调用B类方法表对应的方法！

最终实现了多态！

参考: Java多态的实现机制是什么，写得非常好！.

多态调用原理

本文为「熊二不二」的文章节选
原文链接附于文底

class Base
{
public:
    virtual void Funtest1(int i)
    {
        cout << "Base::Funtest1()" << endl;
    }
    virtual void Funtest2(int i)
    {
        cout << "Base::Funtest2()" << endl;
    }
    int _data;
};

int main()
{
    cout << sizeof(Base) << endl;
    Base b;
    b._data = 10;
    return 0;
}

8？不知道大家有没有问题，反正我是有疑惑了。以前在对象模型（https://blog.csdn.net/qq_39412582/article/details/80808754）时我提到过怎么来求一个类的大小。按照那个方法，这里应该是4才对啊，为什么会是8呢？

通过观察。我们发现这个例子里面和以前不一样，类成员函数变成了虚函数，这是不是引起类大小变化的原因呢？
我们假设就是这样，然后看看内存里是怎么存储的呢？

可以看到它在内存里多了四个字节，那这四个字节的内容到底是什么呢？

是不是有点看不懂，我们假设它是一个地址去看地址里存的东西的时候发现它存的是两个地址。
我假设它是虚函数的地址，我们来验证一下：

typedef void (__stdcall *PVFT)();  //函数指针
int main()
{
    cout << sizeof(Base) << endl;
    Base b;
    b._data = 10;
    PVFT* pVFT = (PVFT*)(*((int*)&b));
    while (*pVFT)
    {
        (*pVFT)();
        pVFT+=1;
    }
    return 0;
}

结果好像和我们的猜想一样，是一件开心的事。然后我给一张图总结一下：

对于派生类的东西我给个链接仔细看，人家总结的超级赞，我偷个懒就不写了，老铁们包容下啊。

派生类虚表：
1.先将基类的虚表中的内容拷贝一份
2.如果派生类对基类中的虚函数进行重写，使用派生类的虚函数替换相同偏移量位置的基类虚函数
3.如果派生类中新增加自己的虚函数，按照其在派生类中的声明次序，放在上述虚函数之后
https://coolshell.cn/articles/12176.html

多态缺陷
●降低了程序运行效率（多态需要去找虚表的地址）
●空间浪费
————————————————
版权声明：本文为CSDN博主「熊二不二」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_39412582/article/details/81628254

对于java中多态概念的理解一直是面试常问的问题，所以今天花了一些时间好好地整理了一下，力求从java虚拟机的角度来分析和理解多态。

一、认识多态

1、方法调用

在Java中，方法调用有两类，动态方法调用与静态方法调用。

（1）静态方法调用是指对于类的静态方法的调用方式，是在编译时刻就已经确定好具体调用方法的情况，是静态绑定的。

（2）动态方法调用需要有方法调用所作用的对象，是在调用的时候才确定具体的调用方法，是动态绑定的。

我们这里所讲的多态就是后者—动态方法调用。

2、多态概念

多态有两种：类内部之间的多态和类之间的多态。我们先看一下标准的概念：

多态是面向对象编程语言的重要特性，它允许基类的指针或引用指向派生类的对象，而在具体访问时实现方法的动态绑定

（1）Java的方法重载（类内部之间的多态）：就是在类中可以创建多个方法，它们具有相同的名字，但可具有不同的参数列表、返回值类型。我们举个例子来解释，就是一对夫妇生了多胞胎，多胞胎之间外观相似，其实是不同的孩子。

（2）Java的方法重写（父类与子类之间的多态）：子类可继承父类中的方法，但有时子类并不想原封不动地继承父类的方法，而是想作一定的修改，这就需要采用方法的重写。重写的参数列表和返回类型均不可修改。我们再举个例子，就是子承父业，但是儿子有自己想法，对父亲得产业进行再投资的过程。

二、代码实现多态

1、类内部之间得多态：方法重载

public class SingleClass {
	//孩子1：
    public String child(){
    	System.out.println("child1");
        return "child1";
    }
    //孩子2：与孩子1参数个数不同
    public String child(String a){
    	System.out.println("child2");
        return "child2";
    }   
    //孩子3：与孩子4参数顺序不同
    public String child(int a,String s){
    	System.out.println("child3");
        return "child3";
    }   
    //孩子4：与孩子3参数顺序不同
    public String child(String s,int a){
    	System.out.println("child4");
        return "child4";
    }   
    public static void main(String[] args){
        //重载方法调用：略
    }
}

从上述代码我们可以看到，在类的内部可以有相同的方法名，但是有唯一的参数列表。当然返回类型和修饰符也可以不同。下面我们再看一下类之间的多态。

2、类之间的多态：方法重写

类之间的多态其实是有两种方式：继承和接口。我们对这两种方式一个一个说明。

（1）继承方式实现多态

对于继承方式我们使用一个例子来解释，比如说父亲可以对自己的房子有处理权，儿子继承父业同样也有处理权。

第一步：定义父类

public class Father {
    public void dealHouse(){
        System.out.println("父亲处置房产"); 
    }	
}

第二步：定义子类（大儿子和小儿子）

//大儿子
public class SonA extends Father {
	@Override
	public void dealHouse() {
		System.out.println("大儿子处置房产"); 
	}
}
//小儿子
public class SonB extends Father {
	@Override
	public void dealHouse() {
		System.out.println("小儿子处置房产"); 
	}
}

第三步：测试

public class Test {
	public static void main(String[] args) {
		Father father=new Father();	
		Father sonA=new SonA();
		Father sonB=new SonB();		
		father.dealHouse();
		sonA.dealHouse();
		sonB.dealHouse();
	}
}
//父亲处置房产
//大儿子处置房产
//小儿子处置房产

（2）接口方式实现多态

接口方式实现继承方式其实跟上面一样，只不过把父类变成了接口而已，其他内容只有微笑的变化，这里就不演示了，在这里只给出父接口的形式。

public interface Father {
    public void dealHouse();
}

到了这基本上就对多态形式的代码实现进行了演示，案例也比较简单，但是这对我们理解多态的思想还不够，我们最主要的还是从虚拟机的角度来分析一下。

三、分析多态

想要深入分析多态，我们需要弄清楚几个问题。

1、jvm内存

在上面的代码中我们其实已经看到了，不管是类内部之间实现的多态，还是类之间实现的多态，这些方法的名字其实都是一样的，那我们的程序在运行的时候，底层虚拟机是如何去区分的呢（java虚拟机实现动态调用）？为此我们还是先从java虚拟机讲起。

其实java虚拟机在执行java程序的时候，并不是直接运行的，他需要一个过程，我们使用一张图来看下：

上面这张图已经很清晰，也就是说，我们的java文件要想运行，需要通过java编译器编译成.class文件，然后通过类装载器讲.class文件装载到JVM中，最后才是执行。而且JVM分了五个区域，那么在代码中定义的那些多态方法存到了哪个地方呢？为此我们还需要对这块内存区域进行一个分析：

我给出了一张java7的运行时数据区划分图，对于每一个区域的基本情况我相信你也能看明白。那么我们的多态方法到底存在了哪呢？没错就是后一个方法区。java堆存的是就是我们建立的一个个实例对象，而方法区存的就是类的类型信息。

而且这个方法区中的类型信息跟在堆中存放的class对象是不同的。在方法区中，这个class的类型信息只有唯一的实例（所以方法区是各个线程共享的内存区域），而在堆中可以有多个该class对象。也就是说方法区的类型信息就是像一个模板，那些class对象就好比通过这些模板创建的一个个实例。

2、通过例子来分析

现在我们拿上面的例子来说明一下多态在java虚拟机中是如何实现的。在测试类中有两行代码：

Father sonA=new SonA();
Father sonB=new SonB();	

当程序运行到Father sonA=new SonA()这里就出现了多态，这是因为编译时看到Father，但是运行时new出来一个SonA类，两种类型还不一样。那么这些代码在运行的时候在内存中是如何保存的呢？

（1）Father sonA是一个引用类型，存在了java栈中的本地方法表中了。

（2）new SonA其实创建了一个实例对象，存储在了java堆中。

（3）SonA的类型数据存在了方法区中

我们在内存中看一下：

reference中存储的就是对象在堆中的实际地址，在堆中存储的对象信息中包含了在方法区中的相应类型数据。流程很简单，我们梳理一下：

第一步：虚拟机通过reference（Father的引用）查询java栈中的本地变量表，得到堆中的对象类型数据的指针，

第二步：通过到对象的指针找到方法区中的对象类型数据

第三步：查询方法表定位到实际类（SonA类）的方法运行。

好了，到第三步我们知道，其实是通过方法表来定位到实际运行的方法的。下面我们再来看看这个方法表是什么。

3、方法表

方法表肯定是存在于方法区中的，它是实现多态的关键所在，这里面保存的就是实例方法的引用，而且是直接引用。java虚拟机在执行程序的时候就是通过这个方法表来确定运行哪一个多态方法的。

我们通过上面的例子，来演示一下父子类在方法表中是如何保存的：

很明显每一个类都会有一个方法表，子类中不同的方法指向不同的类型信息。继承自Object的就指向Object，继承自Father的就指向Father（也就是包含了父类的方法dealHouse）。

可能我们到这就迷糊了，既然子类的dealHouse方法其实是父类Father的，那么为什么会执行子类的dealHouse方法呢？别着急往下看。这是java虚拟机区分多态方法（实现动态调用）的精华所在。

当Son类的方法表会有一个指向Father类dealHouse方法的指针，同时也有一个指向自己dealHouse方法的指针，这时候，新的数据会覆盖原有的数据，也就是说原来指向Father.dealHouse的那个引用会被替换成指向Son.dealHouse的引用（占据原来表中的位置）

注意：

上述讲述的其实是对继承实现的多态的一种分析，对接口实现的，会有着不一样的理解。Java虚拟机 对于接口方法的调用是采用搜索方法表的方式，如，要在Father接口的方法表中找到dealHouse()方法，必须搜索Father的整个方法表。从效率上来说，接口方法的调用总是慢于类方法的调用的。

以上就是对java多态的分析与理解，总结一下就是说，类调用和接口调用两种方式区分不同方法是不一样的，类调用是根据多态方法在方法表中的位移量，而接口调用是根据搜索整个方法表来实现的。

机 对于接口方法的调用是采用搜索方法表的方式，如，要在Father接口的方法表中找到dealHouse()方法，必须搜索Father的整个方法表。从效率上来说，接口方法的调用总是慢于类方法的调用的。

以上就是对java多态的分析与理解，总结一下就是说，类调用和接口调用两种方式区分不同方法是不一样的，类调用是根据多态方法在方法表中的位移量，而接口调用是根据搜索整个方法表来实现的。

欢迎关注微信公众号：java的架构师技术栈。回复关键字获取各种教程资源和新手入门到架构师学习路线。