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");
}
