【C/C++学院】（9）继承/多态 专题讲座

1.继承

面向对象中的继承指类之间的父子关系  

1、子类拥有父类的所有成员变量和成员函数

2、子类就是一种特殊的父类

3、子类对象可以当作父类对象使用（赋值兼容性原则）

4、子类可以拥有父类没有的方法和属性

继承中的构造和析构

//类的继承方式对子类对外访问属性影响

//1 看调用语句，这句话是写在子类的内部、外部 //2 看子类如何从父类继承 （public、protected、private） //3 看父类中的访问级别（public、protected、private）

C++中子类对外访问属性表   总结：不同的继承方式可能改变继承成员的访问属性 练习：public继承不会改变父类对外访问属性；private继承会改变父类对外访问属性为private；protected继承会部分改变父类对外访问属性。

继承模型

在子类对象构造的时，需要调用父类构造函数对其继承得来的成员进行初始化 在子类对象析构的时，需要调用父类析构函数对其继承得来的成员进行清理

继承与组合混搭情况下，构造和析构调用原则 

原则： 先构造父类，再构造成员变量、最后构造自己

  先析构自己，在析构成员变量、最后析构父类

//子类对象如何初始化父类成员
//继承中的构造和析构 
//继承和组合混搭情况下，构造函数、析构函数调用顺序研究

#include <iostream>

using namespace std;

class Object
{
public:
	Object(const char* s)
	{
		cout<<"Object()"<<" "<<s<<endl;
	}
	~Object()
	{
		cout<<"~Object()"<<endl;
	}
};

class Parent : public Object
{
public:
	Parent(const char* s) : Object(s)
	{
		cout<<"Parent()"<<" "<<s<<endl;
	}
	~Parent()
	{
		cout<<"~Parent()"<<endl;
	}
};

class Child : public Parent
{
protected:
	Object o1;
	Object o2;
public:
	Child() : o2("o2"), o1("o1"), Parent("Parameter from Child!")
	{
		cout<<"Child()"<<endl;
	}
	~Child()
	{
		cout<<"~Child()"<<endl;
	}
};

void run05()
{
	Child child;
}

int main05(int argc, char *argv[])
{
	cout<<"demo05_extend_construct_destory.cpp"<<endl;
	run05();

	system("pause");
	return 0;
}

继承中的构造和析构；先调用基类的构造，然后调用派生类的构造

继承关系；

重名成员； 类名：：成员

子类中的静态成员；

多继承   class C ：public A, public B

虚基类 virtual

2.多态

函数重写；

virtual

应用案例：英雄打怪，场景模拟

#include <iostream>
using namespace std;
class Hero{
public:
    virtual int AttackPower()//这里加上virtual关键字，形成多态
    {
        return 10;//英雄的攻击力为10
    }
};
class Enemy
{
public:
    int DestoryPower()
    {
        return 15;//敌人的防御力为15
    }
};
class HeroSuper : public Hero{
public:
    int AttackPower()
    {
        return 20;//超级英雄的攻击力为20
    }
};
//-个对象pk的场景
void ObjPk(Hero *h, Enemy *e)
{
    if (h->AttackPower()>e->DestoryPower())
    {
        printf("英雄赢了\n");
    }
    else
    {
        printf("英雄shu了\n");
    }
}
void main()
{
    Hero h1;
    Enemy e1;
    HeroSuper hs;
    ObjPk(&h1, &e1);
    ObjPk(&hs, &e1);
    system("pause");
} 

面向对象的三大概念：

封装： 突破了c函数的概念

继承： 可以使用原来的代码， 代码复用

多态： 比代码复用更高了一个层次， 可以调用未来的代码。

多态成立的三个条件：

1.要有继承

2.有有函数重写（虚） virtual关键字、

3.要有父类指针（父类引用）或者是指向子类对象。

#include <iostream>
using namespace std;

class Hero{
public:
	virtual int AttackPower()//这里加上virtual关键字，形成多态
	{
		return 10;//英雄的攻击力为10
	}
};

class Enemy
{
public:
	int DestoryPower()
	{
		return 15;//敌人的防御力为15
	}
};

class HeroSuper : public Hero{
public:
	int AttackPower()
	{
		return 20;//超级英雄的攻击力为20
	}
};
//若干年后，重新定义了一个英雄
class HeroAfter : public Hero{
public:
	int AttackPower()
	{
		return 40;//超级英雄的攻击力为40
	}
};

//-个对象pk的场景
void ObjPk(Hero *h, Enemy *e)
{
	if (h->AttackPower()>e->DestoryPower())
	{
		printf("英雄赢了\n");
	}
	else
	{
		printf("英雄shu了\n");
	}
}
//面向对象的三大概念：
//封装： 突破了c函数的概念
//继承： 可以使用原来的代码， 代码复用
//多态： 比代码复用更高了一个层次， 可以调用未来的代码。
void main()
{
	Hero h1;
	Enemy e1;
	HeroSuper hs;

	ObjPk(&h1, &e1);
	ObjPk(&hs, &e1);
	/*******若干年后后*************/
	HeroAfter hf;
	ObjPk(&hf, &e1);

	system("pause");
}