概念:多态是什么它就相当于区别对待,比如买票这个行为，当普通人买票时，是全价买票；学生买票时，是半价买票；军人买票时是优 先买票。再者就是再举个详细的例子： 最近为了争夺在线支付市场，支付宝年底经常会做诱人的扫红包-支付-给奖励金的活动。那么 大家想想为什么有人扫的红包又大又新鲜8块、10块…，而有人扫的红包都是1毛，5毛…。其实这背后也是 一个多态行为。支付宝首先会分析你的账户数据，比如你是新用户、比如你没有经常支付宝支付等等，那么 你需要被鼓励使用支付宝，那么就你扫码金额 = random()%99；比如你经常使用支付宝支付或者支付宝账户 中常年没钱，那么就不需要太鼓励你去使用支付宝，那么就你扫码金额 = random()%1；总结一下：同样是 扫码动作，不同的用户扫得到的不一样的红包，这也是一种多态行为。ps：支付宝红包问题纯属瞎编，大家 仅供娱乐。

多态的必要条件:继承,重写,杜磊引用指向子类对象

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法

多态的特点:

1:应用程序不必为每一个派生类编写功能调用，只需要对抽象基类进行处理即可。大大提高程序的可复用性。

2:派生类的功能可以被基类的方法或引用变量所调用，这叫向后兼容，可以提高可扩充性和可维护性。

代码如下：

测试类:

package com.ytzl.total;
/*多态*/
public class polymorphic {
    public static void main(String[] args) {
        //使用纯纯的调用来测试
        fathers fathers = new fathers();//调用父类
        Eldestson eldestson = new Eldestson();//调用大儿子类
        youngestson youngestson = new youngestson();//调用小儿子类
        fathers.eat();//正常调用
        eldestson.eat();//正常待用
        youngestson.eat();//正常调用
        System.out.println("\n");
        //使用多态来测试
        fathers eldestson1 = new Eldestson();///子类对象的地址值交给父类的eldestson1来保存
        fathers youngestson1 = new youngestson();//子类对象的地址值交给父类的youngestson1来保存
        eldestson1.eat();//多态调用
        youngestson1.eat();//多态调用
        eldestson1.setMoney(100);//通过多态去赋值
        eldestson1.setName("小明");//通过多态去赋值
        youngestson1.setMoney(50);//通过多态去赋值
        youngestson1.setName("小张");//通过多态去赋值
        eldestson1.money();//通过多态以子类去获取父类方法
        youngestson1.money();//通过多态以子类去获取父类方法
    }
}

父类:

package com.ytzl.total;
/*父类*/
public class fathers {
    private int money;
    private String name;

    public fathers() {
    }

    public fathers(int money, String name) {
        this.money = money;
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }

    public void eat(){
        System.out.println("我是父类,我老了牙坏了不能吃硬的。");
    }
    public void money(){
        System.out.println("父类给了"+name+money+"元");
    }
}

子类一:

package com.ytzl.total;
/*大儿类*/
public class Eldestson extends fathers{

    public void eat(){
        System.out.println("我是大儿子类,我还年轻我胃口好牙好什么都能吃。");
    }
}

子类二:

package com.ytzl.total;
/*小儿子类*/
public class youngestson extends fathers{
    public void eat(){
        System.out.println("我是小儿子类,我还小我牙都没长齐不能吃太硬的。");
    }
}

运行结果如下:

多态调用和普通调用

C++中只有两个调用关系，分为普通调用和多态调用。不满足多态调用就是普通调用。

多态必须构成的两个条件

1. 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写（也就是必须满足重写）
2. 必须通过基类的指针或者引用调用虚函数（指针和引用）

多态调用:跟指向的对象有关，传的对象是谁的，调用的就是谁的。

普通调用:和类型有关。类型是什么调用就是什么，类型是Person的，那么调用的函数就是Person的。 比如下面的例子。

普通调用的例子：

class A {};
class B : public A{};
class Person{
public: 
	virtual B*f(){
		cout << "Person::f()" << endl;
		return new B;
		}
};
class Student: public Person{
public:
	virtual B* f(){
		cout << "Student::f()" << endl;
		return new B;
		}
};
int main ()
{
	Person p;
	p.f();
	Student s;
	p = s;       //派生类赋值给子类
	p.f();
   
    system("pause");
}

结果：

分析：
在这里虽然调用的是虚函数，派生类中也对基类的虚函数进行了重写。但是不是使用基类的指针或引用调用，所以不满足多态调用的条件。
所以在这里是普通调用。只与类型有关，尽管Student对象s赋值给父类对象p，但是普通调用只与类型有关，所以仍然调用p的f()函数

多态调用的例子

class A {};
class B : public A{};
class Person{
public: 
	virtual B*f(){
		cout << "Person::f()" << endl;
		return new B;
		}
};
class Student: public Person{
public:
	virtual B* f(){
		cout << "Student::f()" << endl;
		return new B;
		}
};
int main()
{
	Person p;
	Student s;
	Person* ptr = &p;
	//本来就是Person类的指针，指向Person类的对象，调用的本来就是Person父类的f()函数
	ptr->f() ; 
	
	ptr = &s;
	ptr->f(); //指向的是子类的对象， 调用的是子类的f()的函数
}

结果：

分析：
在这里被调用的是虚函数，且派生类Student里对虚函数f()进行了重写。又是基类的指针对虚函数的调用，所以满足多态调用。
ptr是基类的指针，指向的是派生类的对象， 基类的指针调用虚函数，构成多态调用，只和对象有关。所以调用的是派生类的f()函数。

错误多态调用的例子

值得注意的一点： 必须是基类的指针对虚函数的调用，下面有一个派生类指针对虚函数的调用

class A {};
class B : public A{};
class Person{
public:
	virtual B*f(){
		cout << "Person::f()" << endl;
		return new B;
	}
};
class Student : public Person{
public:
	virtual B* f(){
		cout << "Student::f()" << endl;
		return new B;
	}
};
int main()
{ 
	Student s;
	// 派生类指针指向派生类的对象，调用虚构函数，肯定是调用自己的，因为自己完成了对虚函数的重写
	Student* ps = &s; 
	ps->f();

	cout << endl;

	Person p;
	Person* ptr = &p;  // Person类的指针， 指向Person类的对象，调用的本来就是Person类的虚函数
	ptr->f();
	cout << endl;

	ps = (Student*)ptr;   //将基类Person的指针强转 赋给派生类Student的指针ps
	ps->f();         //派生类的指针调用虚函数， 所以不构成重写， 不满足多态调用。 所以和对象没有关系，只与类型有关系
	system("pause");
}

结果：

分析：
在这里看最后一个输出的Person::f()。
将基类Person的指针强转赋给派生类Student的指针ps。
派生类的指针调用虚函数， 所以不构成重写， 不满足多态调用。 所以和对象没有关系，只与类型有关。 在这里ptr是Person * 类型的，是强转成Student * 类型的， 所以输出的只与类型有关， 输出Person * 的f(). 所以输出的是Person->f()

1.带有虚函数的基类对象模型

我们先看段代码：

#include<iostream>
using namespace std;
class B1
{
	public:
		void func1()
		{}
		int _b;
};
class B2
{
	public:
		virtual void func()
		{}
		int _b;
};
int main()
{
	cout<<"sizeof(B1) = "<<sizeof(B1)<<endl;  
	cout<<"sizeof(B2) = "<<sizeof(B2)<<endl;
	system("pause");
	return 0;
}

运行结果：

可以看出，B2的这个类比B1多了4个字节，而这4个字节就是用来存放虚函数的地址，也就是说，这4个字节的数据是一个指针(地址），这个指针指向的是虚函数地址。看个图就很容易理解。

我们需要注意的是：
1.B2对象的前4个字节存放的是虚表的地址，其后才是B2该对象的成员变量；（虚函数表我们也叫做虚表)。
2.若B2这个类中有多个虚函数，那么其对象大小还是8，因为前4个字节是存放虚函数表的地址，在这个虚函数表（函数指针数组）里面每个元素才是每个虚函数的地址。

2.派生类对象虚函数表如何构建？

上个例子，只是给出了带有虚函数基类的对象模型，那派生类的对象虚函数表应该如何构建？

#include<iostream>
#include<string>
using namespace std;
class Base					//基类
{
public:
	virtual void TestFunc1()
	{
		cout << "Base::TestFunc1()" << endl;
	}
	virtual void TestFunc2()
	{
		cout << "Base::TestFunc2()" << endl;
	}
	virtual void TestFunc3()
	{
		cout << "Base::TestFunc3()" << endl;
	}
	int _b;
};
class Derived : public Base					//派生类
{
public:
	virtual void TestFunc4()
	{
		cout << "Derived::TestFunc4()" << endl;
	}
	virtual void TestFunc1()
	{
		cout << "Derived::TestFunc1()" << endl;
	}

	virtual void TestFunc3()
	{
		cout << "Derived::TestFunc3()" << endl;
	}
	virtual void TestFunc5()
	{
		cout << "Derived::TestFunc5()" << endl;
	}
	int _d;
};
typedef void(*PVFT)();				//声明函数指针，用来调用虚函数

void PrintVFT(Base& b, const string& str)
{
	cout << str << endl;
	/*这里是先将对象的地址取出来再强制类型换，此时再解引用的话，取的值就是对象前四个字节地址里面存放的值，
	这个值就是虚表的地址，即就是函数指针数组的首地址，我们再将这个地址转换成函数指针类型*/
	PVFT* pVFT = (PVFT*)(*(int*)&b)；
		
	while (*pVFT)					//虚表中最后一个元素是空值，打印完循环退出
	{
		(*pVFT)();			// 再解引用就是函数指针数组里面的第一个元素(即就是第一个虚函数地址),再往后一次打印
		++pVFT;
	}
	cout << endl;
}
void TestVirtualFunc(Base& b)
{
	b.TestFunc1();
	b.TestFunc3();
	return;
}
int main()
{
	Base b;
	Derived d;
	// 打印基类与派生类的虚表
	PrintVFT(b, "Base VFT:");
	PrintVFT(d, "Derived VFT:");
	// 传递Base类对象
	TestVirtualFunc(b);
	cout << endl;
	// 传递派生类对象
	TestVirtualFunc(d);
	system("pause");
	return 0;
}

运行结果：

根据结果，我们首先可以看出基类虚函数表是按照声明顺序依此存放，派生类的虚函数表则相应的发生了一些改变。
1.先将基类中的虚表内容拷贝一份到派生类虚表中
2.如果派生类重写了基类中某个虚函数，用派生类自己的虚函数替换虚表中基类的虚函数
3.派生类自己新增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后
其实我们没必要刻意去记这些规则，如果用多态的思想去考虑下的话，这样的规则很合理。对我自己而言，首先派生类继承基类，那么基类有的东西，派生类本来没有的东西继承之后也就具有；其次，若基类和派生类都具有相同的东西，那么在派生类的虚表中，我派生类要保持我自己的特点，所以此时派生类的虚表中存放的是自己的虚函数，这样做的目的很简单，就是为了在多态调用时，会很灵活，根据对象本身自己来调用相应的虚函数，假如派生类中的虚表中存放的是基类的虚函数，那么请问，在多态调用时，不管给基类还是派生类的对象，调用的虚函数都是级基类的虚函数，这样做还会实现多态这个特性吗？最后一点不言而喻，派生类独有的虚函数按照声明顺序加在虚表后面即可。
讨论完基类和派生类对象的虚表之后，我们来看看派生类对象完整的对象模型。

3.单继承的派生类对象模型

对于单继承的派生类的对象模型，其和我们上面介绍的第一个例子一样，前四个字节是虚表的地址，后面就是按顺序存放
接着看一段代码：

#include<iostream>
using namespace std;

class Base
{
public:
	virtual void func1()
	{
		cout << "Base::func1" << endl;
	}

	virtual void func2()
	{
		cout << "Base::func2" << endl;
	}
private:
	int a;
};

class Derive :public Base
{
public:
	virtual void func1()
	{
		cout << "Derive::func1" << endl;
	}

	virtual void func3()
	{
		cout << "Derive::func3" << endl;
	}

	virtual void func4()
	{
		cout << "Derive::func4" << endl;
	}
private:
	int b;
};

typedef void(*VFUNC)();

void PrintVTbale(int* table)
{
	printf("vtable:%p\n", table);
	int i = 0;
	
	for (int i = 0; table[i]!= NULL; ++i) //虚表最后一个元素为空值
	{	
		printf("table[%d]:%p->", i, table[i]);
		VFUNC f = (VFUNC)table[i];	//转为函数指针
		f();	//调用对应的虚函数
	}
	return;
}

运行结果：

根据结果：基类的对象模型和上面第一个例子一样，不再过多讨论。对于单继承的派生类对象模型，在我们清楚了其虚表的构建之后，再其虚函数表地址后面按顺序先存放基类的对象，其次再存放派生类的对象即可。
派生类的对象模型那就是在虚函数指针后面，按顺序先存放基类的成员变量，接着再存放派生类自己成员变量。如下图：

下面我们来看多继承的派生类的对象模型

4.多继承的派生类对象模型

看代码：

#include<iostream>
using namespace std;

class Base1				//基类Base1
{
public:
	virtual void func1()
	{
		cout << "Base1::func1" << endl;
	}
	virtual void func2()
	{
		cout << "Base1::func2" << endl;
	}
private:
	int b1;
};

class Base2				//基类Base2
{	
public:
	virtual void func1()
	{
		cout << "Base2::func1" << endl;
	}
	virtual void func2()
	{
		cout << "Base2::func2" << endl;
	}
private:
	int b2;
};

class Derive : public Base1, public Base2		//派生类
{
public:
	virtual void func1() {
		cout << "Derive::func1" << endl;
	}
	virtual void func3()
	{
		cout << "Derive::func3" << endl;
	}
private:
	int d1;
};

typedef void(*VFUNC)();

void PrintVTbale(int* table)
{
	printf("vtable:%p\n", table);
	for (int i = 0; table[i] != 0; ++i)
	{
		printf("table[%d]:%p->", i, table[i]);
		VFUNC f = (VFUNC)table[i];
		f();
	}
	cout << endl;
}

int main()
{
	Base1 b1;
	Base2 b2;

	Derive d;
	cout << sizeof(d) << endl;		//计算派生类对象的大小

	PrintVTbale((int*)(*(int*)&b1));
	PrintVTbale((int*)(*(int*)&b2));

	PrintVTbale((int*)(*(int*)&d));		//第一个虚表
	PrintVTbale((int*)(*(int*)((char*)&d + sizeof(Base1))));	//第二个虚表
	system("pause");
	return 0;
}

运行结果：

我们注意到；派生类对象的大小是20，对于多继承的派生类对象，如果只有一个虚表，那么它的大小应该是4(虚表指针) + 4(b1)+ 4(b2) + 4(d1) = 16，可是结果不是16，所以派生类对象的虚表应该不止一个。
所以他的对象模型应该如下图这样：

总结以下就是：
1.对于多继承的派生类的对象，其不但继承了基类的对象，也继承了基类的虚函数表指针；
2.派生类继承多个基类，派生类的对象模型其实就相当于将基类的对象模型继承下来了，只不过对于派生类独有的虚函数，那么他的虚函数指针将会按顺序存放在第一个虚表中最后的位置。
3.最后再加上派生类自己成员

至此，对于常见的普通类型多态调用就这些，还有其他继承类型的多态调用，如菱形继承等。
后面会再做总结。

注:文中如有不正之处，欢迎指出，希望和大家共同学习，进步。