多态简介

1.静态多态：函数重载和运算符重载属于静态多态，复用函数名
2.动态多态：派生类和虚函数实现运行多态

两者区别：

1.静态多态的函数地址早绑定——编译阶段确定函数地址
2.动态多态函数地址晚绑定——运行阶段确定函数地址

多态满足条件

1.有继承关系
2.子类重写父类中的虚函数

多态使用条件

父类指针或引用指向子类对象
重写：函数返回值类型，函数名，参数列表完全一致称为重写

多态的优点

1.代码组织结构清晰
2.可读性强
3.利于前期和后期的扩展和维护

案例一.计算器

#include<iostream>
using namespace std;

class Calculator
{
public:
	//纯虚函数,抽象类
	virtual int get_Result() = 0;
	int n_A=0;
	int n_B=0;
};
class Addition :public Calculator
{
public:
	int get_Result()
	{
		return n_A + n_B;
	}
};
class Subtraction :public Calculator
{
	int get_Result()
	{
		return n_A - n_B;
	}
};
class Multiplication :public Calculator
{
	int get_Result()
	{
		return n_A * n_B;
	}
};
class Division :public Calculator
{
	int get_Result()
	{
		return n_A / n_B;
	}
};
//测试加法
void test()
{
	Calculator* p = new Addition;
	p->n_A = 100;
	p->n_B = 150;
	cout << "n_A+n_B="
		<< p->get_Result()
		<< endl;
	delete p;
}
//测试减法
void test2()
{
	Calculator* p = new Subtraction;
	p->n_A = 100;
	p->n_B = 150;
	cout << "n_A-n_B="
		<< p->get_Result()
		<< endl;
	delete p;
}
int main()
{
	test();
	test2();
	return 0;
}

案例二.制作饮品

#include<iostream>
using namespace std;
class AbstractDringking
{
public:
	virtual void Boil() = 0;
	virtual void Brew() = 0;
	virtual void PourInCup() = 0;
	virtual void Addmore() = 0;
	virtual void Done() = 0;
	//proceduer
	void Procedure()
	{
		Boil();
		Brew();
		PourInCup();
		Addmore();
		Done();
	}
};
class Coffee :public AbstractDringking
{
public:
	virtual void Boil()
	{
		cout << "Heat the water" << endl;
	}
	virtual void Brew()
	{
		cout << "Brew coffee" << endl;
	}
	virtual void PourInCup()
	{
		cout << "Pour the coffee into the cup" << endl;
	}
	virtual void Addmore()
	{
		cout << "Add milk" << endl;
	}
	virtual void Done()
	{
		cout << "Your coffee is finished" << endl;
	}
};
class Tea :public AbstractDringking
{
public:
	void Boil()
	{
		cout << "Heat the water" << endl;
	}
	void Brew()
	{
		cout << "Brewing tea" << endl;
	}
	void PourInCup()
	{
		cout << "Pour the tea into the cup" << endl;
	}
	void Addmore()
	{
		cout << "Add medlar" << endl;
	}
	void Done()
	{
		cout << "Your tea is finished" << endl;
	}
};

//Business function
void DoWork(AbstractDringking* drink)
{
	drink->Procedure();
	delete drink;
}
void test()
{
	AbstractDringking* p1 = new Coffee;
	DoWork(p1);
	cout << "--------------" << endl;
	AbstractDringking* p2 = new Tea;
	DoWork(p2);
}
int main()
{
	test();
	return 0;
}

多态案例–组装三台电脑

• 电脑零件基类CPU，显卡，内存条
• 不同的厂商，如Intel，Lenovo等；
  • 三个零件基类，CPU，Videocard，Memory；不同厂商生产的零件来实现具体的功能。

#include <iostream>
using namespace std;
//公共零件基类
class CPU
{
public:
	virtual void calculate() = 0;
};
class Videocare
{
public:
	virtual void display() = 0;
};
class Memory
{
public:
	virtual void storage() = 0;
};
//Intel生产的零件
class IntelCPU : public CPU
{
public:
	virtual void calculate()
	{
		cout << "IntelCPU is calculating\n";
	}
};
class IntelVideocard : public Videocare
{
public:
	virtual void display()
	{
		cout << "Intel Videocard is displaying\n";
	}
};
class IntelMemory : public Memory
{
public:
	virtual void storage()
	{
		cout << "Intel Memory is storaging\n";
	}
};
//Lenovo生产的零件
class LenovoCPU : public CPU
{
public:
	virtual void calculate()
	{
		cout << "LenovoCPU is calculating\n";
	}
};
class LenovoVideocard : public Videocare
{
public:
	virtual void display()
	{
		cout << "Lenovo Videocard is displaying\n";
	}
};
class LenovoMemory : public Memory
{
public:
	virtual void storage()
	{
		cout << "Lenovo Memory is storaging\n";
	}
};
//电脑组装
class Computer
{
private:
	CPU* cpu;
	Videocare* vc;
	Memory* memory;
public:
	Computer(CPU* cpu, Videocare* vc, Memory* memory)
	{
		this->cpu = cpu;
		this->vc = vc;
		this->memory = memory;
	}
	~Computer()
	{
		if (cpu != NULL)
		{
			delete cpu;
			cpu = NULL;
		}
		if (cpu != NULL)
		{
			delete cpu;
			cpu = NULL;
		}
		if (cpu != NULL)
		{
			delete cpu;
			cpu = NULL;
		}
	}
	void work()
	{
		cpu->calculate();
		vc->display();
		memory->storage();
	}
};
//组装测试
	//测试Intel零件
void test1()
{
	CPU* intelCpu = new IntelCPU;
	Videocare* intelVc = new IntelVideocard;
	Memory* memory = new IntelMemory;
	Computer computer(intelCpu, intelVc, memory);
	computer.work();
}
	//测试Lenovo零件
void test2()
{
	Computer computer(new LenovoCPU, new LenovoVideocard, new LenovoMemory);
	computer.work();
}
void test3()
{
	Computer computer(new IntelCPU, new IntelVideocard, new LenovoMemory);
	computer.work();
}
int main()
{
	cout << "------------测试1开始-----------\n";
	test1();
	cout << "------------测试2开始-----------\n";
	test2();
	cout << "------------测试3开始-----------\n";
	test3();
	return 0;
}

学了面向对象中的封装、继承、多态，来进入代码演练一番吧~

package p1;

public class TestAnimal {
	public static void main(String[] args) {

    	//多态:父类型的引用存储子类型的对象.

    	//  父类 Animal  子类 Dog
    	Animal a1=new Dog("柯基",3);
    	System.out.println("狗狗的信息："+a1.getName()+"-"+a1.getAge());

    	//  父类 Animal  子类 Cate
    	Animal a2=new Cat("虎斑",3);
    	System.out.println("猫猫的信息："+a2.getName()+"-"+a2.getAge());
	}
}

//父类   动物
class Animal{

	//封装   属性私有化
	private String name;
	private int age;


	//提供无参构造方法
	public Animal(){}

	//提供有参构造方法
	public Animal(String name,int age){
    	this.name=name;
    	this.age=age;
    }


	//set  设置/  get  获取
	public String getName() {
    	return name;
    }

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

	public int getAge() {
    	return age;
    }

	public void setAge(int age) {
    	this.age = age;
	}
}

//子类   狗  ---  继承父类   动物
class Dog extends Animal{

	//提供无参构造方法
 	public Dog() {}

	//提供有参构造方法
	public Dog(String name, int age) {
    	super(name, age);
	}
}

//子类   猫  ---  继承父类   动物
class Cat extends Animal{

	//提供无参构造方法
	public Cat() {}

	//提供有参构造方法
	public Cat(String name, int age) {
    	super(name, age);
	}
}

super的应用?

super应用在子类中使用父类中内容.

super.

a. super. 应用在子类中的构造方法或是成员方法中,代表访问父类中的属性或是成员方法
b. super.属性名      			访问父类中属性
   super.方法名(实参);   		访问父类中成员方法
c. super.应用场景：当子类和父类定义了重名的属性或是成员方法时;
				需要在子类中访问和父类重名内容，则需要利用 super. 区分 父类的属性和方法

注意：

创建每一个子类对象，jvm默认为每一个子类对象创建对应的一个父类对象

super()

a. super()/super(实参); 
   应用在子类的构造方法的第一行语句，代表创建子类对象时；
   告知jvm为子类对象创建对应父类对象时利用父类的哪一个构造方法完成对象的创建
b. super()：代表利用父类无参数的构造方法
   super(实参):代表利用父类有参数的构造方法
c. 注意：super()必须使用在子类构造法的第一行语句
d. 如果子类的构造方法第一行没有指定super()/super(实参)，则默认在第一行添加super()

Jvm默认添加：

super()：子类构造方法第一行没有指定super()/super(实参)，jvm默认添加
this. 访问属性，如果成员变量和局部变量没有冲突时，直接利用 属性名访问成员时，默认 this.属性名
当一个类中没有定义任何构造方法，jvm默认添加公开的无参数的构造方法

super的案例：

// 父类
class A{
	public A(int n){
		System.out.println("A(int n)");
	}
}

// 子类
class B extends A{
	public B(){
		super();
		System.out.println("B()....");
	}
	public B(int n){
		super(n);
		System.out.println("B(int n)...子类有参数构造");
	}
}

分析：
	编译报错，错误原因在子类无参的构造方法第一行super()/super(实参)的应用;
	Jvm默认在第一行添加super()，需要利用父类无参数的构造方法完成父类对象;
	但是父类中只提供了有参数的构造方法，没有无参数的构造方法，编译报错。

super和this的区别：

super访问->代表父类对象，父类的属性、成员方法、构造方法
super. : 应用在子类的构造方法或是成员方法中，访问父类的属性或是成员方法
super(): 应用在子类的构造方法，代表 告知jvm创建父类对象利用父类的哪一个构造方法完成对象


this访问->代表当前对象，自身的属性、成员方法、构造方法
this. ：应用在本类的构造方法或是成员方法中，访问当前对象属性或是成员方法
this(): 应用在本类的构造方法，访问本类的其他构造方法