复习重难点-继承和派生1

灰太狼 2022-05-28 05:45 213阅读 0赞

## 3.1继承概念 ##

面向对象程序设计有4个主要特点：**抽象、封装、继承和多态性**。我们已经讲解了类和对象，了解了面向对象程序设计的两个重要特征一数据抽象与封装，已经能够设计出基于对象的程序，这是面向对象程序设计的基础。

要较好地进行面向对象程序设计，还必须了解面向对象程序设计另外两个重要特征——继承性和多态性。本章主要介绍有关继承的知识，多态性将在后续章节中讲解。

继承性是面向对象程序设计最重要的特征，可以说，如果没有掌握继承性，就等于没有掌握类和对象的精华，就是没有掌握面向对象程序设计的真谛。

### 3.1.1类之间的关系 ###

has-A，uses-A 和 is-A

has-A   包含关系，用以描述一个类由多个“部件类”构成。实现has-A关系用类成员表示，即一个类中的数据成员是另一种已经定义的类。

uses-A  一个类部分地使用另一个类。通过类之间成员函数的相互联系，定义友员或对象参数传递实现。

is-A   机制称为“继承”。关系具有传递性,不具有对称性。

### 3.1.2继承关系举例 ###

万事万物中皆有继承，是重要的现象

两个案例：1）植物继承图；2）程序员继承图

![70][]

### 3.1.3 继承相关概念 ###

![70 1][]

### 3.1.4 派生类的定义 ###

![70 2][]

注意：C++中的继承方式（public、private、protected）会影响子类的对外访问属性。

### 3.1.5 继承重要说明 ###

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

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

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

3、子类对象可以当作父类对象使用

## 3.2派生类的访问控制 ##

派生类继承了基类的全部成员变量和成员方法（除了构造和析构之外的成员方法），但是这些成员的访问属性，在派生过程中是可以调整的。

### 3.2.1单个类的访问控制 ###

1、类成员访问级别（public、private、protected）

2、思考：类成员的访问级别只有public和private是否足够？

### 3.2.2不同的继承方式会改变继承成员的访问属性 ###

**1）C++中的继承方式会影响子类的对外访问属性**

public继承：父类成员在子类中保持原有访问级别

private继承：父类成员在子类中变为private成员

protected继承：父类中public成员会变成protected

父类中protected成员仍然为protected

父类中private成员仍然为private

2）**private成员在子类中依然存在，但是却无法访问到。不论何种方式继承基类，派生类都不能直接使用基类的私有成员。**

**3）C++中子类对外访问属性表**

<table> 
 <tbody> 
 <tr> 
 <td>&nbsp;</td> 
 <td colspan="4">父类成员访问级别</td> 
 </tr> 
 <tr> 
 <td>继 承 方 式</td> 
 <td>&nbsp;</td> 
 <td>public</td> 
 <td>proteced</td> 
 <td>private</td> 
 </tr> 
 <tr> 
 <td>public</td> 
 <td>public</td> 
 <td>proteced</td> 
 <td>private</td> 
 </tr> 
 <tr> 
 <td>proteced</td> 
 <td>proteced</td> 
 <td>proteced</td> 
 <td>private</td> 
 </tr> 
 <tr> 
 <td>private</td> 
 <td>private</td> 
 <td>private</td> 
 <td>Private</td> 
 </tr> 
 </tbody> 
</table>

** **

**4）继承中的访问控制**

//demo_01继承的基本语法
 #include <iostream>
 using namespace std;
 
 class parent
 {
 public:
 	void print()
 	{
 		cout << "a:" << a << "b:" << b << endl;
 	}
 	int b;
 
 private:
 	int a;
 };
 //public继承：父类成员在子类中保持原有访问级别
 //private继承：父类成员在子类中变为private成员
 //protected继承：父类中public成员会变成protected
 //父类中protected成员仍然为protected
 //父类中private成员仍然为private
 
 class Child:public parent
 {
 public:
 
 
 private:
 	int c;
 };
 
 int main()
 {
 	Child c1;
 
 	//c1.a = 1;//为基类的
 	c1.b = 3;
 	//c1.c = 1;成员 "Child::c" 不可访问
 
 
 	system("pause");
 	return 0;
 }

**demo\_02单个类的访问控制.cpp**

#include <iostream>
 using namespace std;
 /*
 C++中的继承方式（public、private、protected）会影响子类的对外访问属性
 判断某一句话，能否被访问
 1）看调用语句，这句话写在子类的内部、外部
 2）看子类如何从父类继承（public、private、protected）
 3）看父类中的访问级别（public、private、protected）
 */
 
 //public 修饰的成员变量 在类的内部、外部都能使用
 class Parent1
 {
 public:
 	int a;//老爹的名字
 protected:
 	int b;//老爹的银行卡密码 仅仅允许家族人内部知道，外面人不给知道==>protected在公用继承后，在类的内部能使用，外部不能被使用，protected在protected继承后，还是protected,protected在private继承后private
 private:
 	int c;//相当于 老爹的情人
 };
 
 class Child1:public Parent1
 {
 public:
 	void UseVar()
 	{
 		a = 0;	//ok			public 在子类中，类外都能访问
 		b = 0;	//ok		protected:在子类中能访问，但是在类外不能访问
 		//c = 0; //err		private:在子类中,在类外都不能访问
 	
 	}
 protected:
 private:
 
 };
 //公用继承
 int main0201()
 {
 	Child1 c1;
 	c1.a = 0;	 //ok			public 在子类中，类外都能访问
 	//c1.b = 0;	 //err		protected:在子类中能访问，但是在类外不能访问
 	//c1.c = 0;	 //err		private:在子类中,在类外都不能访问
 
 }
 
 //protected: 修饰的成员变量方法,在类的内部使用 ,在继承的子类中可用 ;其他 类的外部不能被使用
 //protected 关键字修饰的成员变量和成员函数，是为了在家族中使用，是为了继承
 /*
 protected继承：父类中public成员会变成protected
 父类中protected成员仍然为protected
 父类中private成员仍然为private
 
 
 */
 class Child2 :protected Parent1
 {
 	void UseVar()
 	{
 		a = 0;	//ok		父类中public成员会变成protected：	 在子类中能访问，类外不能访问
 		b = 0;	//ok		父类中protected成员仍然为protected: 在子类中能访问，但是在类外不能访问
 		//c = 0; //err		父类中private成员仍然为private: 在子类中,在类外都不能访问
 
 	}
 
 
 };
 void main0202()
 {
 	Child2 c2;
 	//c2.a = 0;//ok		父类中public成员会变成protected：	 在子类中能访问，类外不能访问
 	//c2.b = 1;//ok		父类中protected成员仍然为protected: 在子类中能访问，但是在类外不能访问
 	//c2.c = 2; //err	父类中private成员仍然为private: 在子类中,在类外都不能访问
 
 }
 //private: 修饰的成员变量方法 只能在类的内部使用 不能在类的外部
 class Child3 :private Parent1
 {
 	void UseVar()
 	{
 		a = 0;	//ok		父类中public成员会变成private：	 1.写在子类中，2.看从父类里private继承过来的，3.父类里访问级别是public 故在子类中能访问，类外不能访问
 		b = 0;	//ok		父类中protected成员仍然为protected: 1.写在子类中，2.看从父类里private继承过来的，3.父类里访问级别是protected 故在子类中能访问，但是在类外不能访问
 		//c = 0; //err		父类中private成员仍然为private: 在子类中,在类外都不能访问
 
 	}
 };
 //记住private继承过来的，类外都不能使用
 void main()
 {
 	Child2 c2;
 	//c2.a = 0;//ok		父类中public成员会变成private：	 1.写在子类中，2.看从父类里private继承过来的，3.父类里访问级别是public 故在子类中能访问，类外不能访问
 	//c2.b = 1;//ok		父类中protected成员仍然为protected: 1.写在子类中，2.看从父类里private继承过来的，3.父类里访问级别是protected 故在子类中能访问，但是在类外不能访问
 	//c2.c = 2; //err		父类中private成员仍然为private: 在子类中,在类外都不能访问
 
 }

### 3.2.3“三看”原则 ###

C++中的继承方式（public、private、protected）会影响子类的对外访问属性

判断某一句话，能否被访问

**         1）看调用语句，这句话写在子类的内部、外部**

**         2）看子类如何从父类继承（public、private、protected）       **

**         3）看父类中的访问级别（public、private、protected）**

### 3.2.3派生类类成员访问级别设置的原则 ###

**         **思考：如何恰当的使用public，protected和private为成员声明访问级别？

**1、需要被外界访问的成员直接设置为public**

**2、只能在当前类中访问的成员设置为private**

**3、只能在当前类和子类中访问的成员设置为protected，protected成员的访问权限介于public和private之间。**

**3.2.4综合训练**

练习：

public继承不会改变父类对外访问属性；

private继承会改变父类对外访问属性为private；

protected继承会部分改变父类对外访问属性。

结论：一般情况下class B : public A

//demo_03派生类访问控制综合训练.cpp
 //类的继承方式对子类对外访问属性影响
 
 #include <cstdlib>
 #include <iostream>
 
 using namespace std;
 
 class A
 {
 private:
 	int a;
 protected:
 	int b;
 public:
 	int c;
 
 	A()
 	{
 		a = 0;		b = 0;		c = 0;
 	}
 
 	void set(int a, int b, int c)
 	{
 		this->a = a;		this->b = b;		this->c = c;
 	}
 };
 //公用继承
 class B : public A
 {
 public:
 	void print()
 	{
 		//cout<<"a = "<<a; //err private还是private，只能在父类类内访问
 		cout << "b = " << b; //ok protected还是protected 基类子类中访问，类的外部不能访问
 		cout << "c = " << endl; //ok public还是public 都能访问
 	}
 };
 /*
 1、需要被外界访问的成员直接设置为public
 2、只能在当前类中访问的成员设置为private
 3、只能在当前类和子类中访问的成员设置为protected，protected成员的访问权限介于public和private之间。
 
 */
 //保护继承
 class C : protected A
 {
 public:
 	void print()
 	{
 		//cout<<"a = "<<a; //err 父类中private还是private 只能在基类中访问的成员
 		cout << "b = " << b; //ok 父类中protected还是protected 能在基类和子类中访问，类外部不能访问
 
 		cout << "c = " << endl; //ok 父类中public变成protected 能类的内部访问，不能外部访问
 	}
 };
 //private私有继承
 class D : private A
 {
 public:
 	void print()
 	{
 		//cout<<"a = "<<a; //err 父类中private还是private,只能在基类中访问
 		cout << "b = " << b << endl; //ok protected 变成private,能在类内部访问
 		cout << "c = " << c << endl; // ok 只能在子类的内部访问了
 	}
 };
 
 int main()
 {
 
 	A aa;
 	B bb;
 	C cc;
 	D dd;
 
 	aa.c = 100; //1.看写在类的外部，2.看类中的访问级别，c是public，故可以类的外部访问
 	bb.c = 100; // ok 1.看写在类的外部 2.看子类是从父类中公用继承过来的，c在父类中访问级别是public，总体还是public,故可以在类的外部访问
 	//cc.c = 100; // err 1.看写在类的外部 2.看子类是从父类中protected继承过来的，c在父类中访问级别是public，总体还是protected,不可以在类的外部访问
 	//dd.c = 100; // err1.看写在类的外部 2.看子类是从父类中private继承过来的，不可以在类的外部访问
 
 	aa.set(1, 2, 3); //ok 1.看写在类外的，2.看类中的访问级别public 
 	bb.set(10, 20, 30); //ok1.看写在类外的，2.看类中的访问级别public 
 	//cc.set(40, 50, 60); // err 1.看写在类外的，2.看子类从父类中保护继承过来的，故不能访问
 	//dd.set(70, 80, 90); //err1.看写在类外的，2.看子类从父类中私有继承过来的，故不能访问
 
 
 	bb.print(); //ok 1.看写在类外的，2.不是子类就不看，直接看父类的访问级别是public,肯定就可以类外访问
 	cc.print(); //ok 1.看写在类外的，2.不是子类就不看，直接看父类的访问级别是public,肯定就可以类外访问
 
 	system("pause");
 	return 0;
 }

### 3.3.1类型兼容性原则 ###

类型兼容规则是指在需要基类对象的任何地方，都可以使用公有派生类的对象来替代。通过公有继承，派生类得到了基类中除构造函数、析构函数之外的所有成员。这样，公有派生类实际就具备了基类的所有功能，凡是基类能解决的问题，公有派生类都可以解决。类型兼容规则中所指的替代包括以下情况：

**子类对象可以当作父类对象使用**

**子类对象可以直接赋值给父类对象**

**子类对象可以直接初始化父类对象**

**父类指针可以直接指向子类对象**

**父类引用可以直接引用子类对象**

在替代之后，派生类对象就可以作为基类的对象使用，但是只能使用从基类继承的成员。

**类型兼容规则**是**多态性**的重要基础之一。

//demo_05类型兼容性原则.cpp
 /*
 兼容规则中所指的替代包括以下情况：
 子类对象可以当作父类对象使用
 子类对象可以直接赋值给父类对象
 子类对象可以直接初始化父类对象
 父类指针可以直接指向子类对象
 父类引用可以直接引用子类对象
 */
 
 #include <iostream>
 using namespace std;
 
 class Parent
 {
 public:
 	void prinT()
 	{
 	
 		cout << "我是父类" << endl;
 	}
 
 	Parent()
 	{
 		cout << "Parent 构造函数" << endl;
 	}
 
 	Parent(const Parent &obj)
 	{
 		cout << "Parent 拷贝构造函数" << endl;
 	}
 private:
 
 };
 //class Child:Parent class 默认私有继承
 class Child:public Parent
 {
 public:
 	void printC()
 	{
 		cout << "我是儿子" << endl;
 	}
 private:
 
 };
 //在替代之后，派生类对象就可以作为基类的对象使用，但是只能使用从基类继承的成员
 void howToprinT(Parent *base)
 {
 	base->prinT();
 }
 
 void howToprinT2(Parent &base)
 {
 	base.prinT();//基类的成员函数
 }
 int main()
 {
 	Parent p1;
 	p1.prinT();
 
 	Child c1;
 	c1.prinT();
 	c1.printC();
 
 	//赋值兼容性原则 
 	//1-1 基类指针 (引用) 指向 子类对象
 	Parent *p = NULL;
 	p = &c1;
 	p->prinT();
 
 	//1-2 指针做函数参数
 	howToprinT(&p1);
 	howToprinT(&c1);//子类对象可以当作父类对象使用
 
 	//1-3引用做函数参数
 	howToprinT2(p1);
 	howToprinT2(c1);
 
 	//第二层含义
 
 	//可以让子类对象 初始化 父类对象
 	//子类就是一种特殊的父类
 	Parent p3 = c1;//需要拷贝构造函数
 	p3.prinT();
 //	总结：子类就是特殊的父类(base *p = &child;)
 	system("pause");
 	return 0;
 }

### 3.3.2继承中的对象模型 ###

类在C++编译器的内部可以理解为结构体

子类是由父类成员叠加子类新成员得到的

![70 3][]

**继承中构造和析构**

**问题：如何初始化父类成员？父类与子类的构造函数有什么关系**

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

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

### 3.3.3继承中的构造析构调用原则 ###

1、子类对象在创建时会首先调用父类的构造函数

2、父类构造函数执行结束后，执行子类的构造函数

3、当父类的构造函数有参数时，需要在子类的初始化列表中显示调用

4、析构函数调用的先后顺序与构造函数相反

//demo06_继承中构造和析构.cpp
 #include <iostream>
 using namespace std;
 
 //观看一个类多个对象中 继承中的构造析构调用原则
 //结论
 //先 调用父类构造函数 在调用 子类构造函数
 //析构的顺序 和构造相反
 
 /*
 1、子类对象在创建时会首先调用父类的构造函数
 2、父类构造函数执行结束后，执行子类的构造函数
 3、当父类的构造函数有参数时，需要在子类的初始化列表中显示调用
 4、析构函数调用的先后顺序与构造函数相反
 */
 
 class Parent
 {
 public:
 	Parent()
 	{
 		this->a = 0;
 		this->b = 0;
 		cout << "父类的默认构造函数" << endl;
 	}
 	Parent(int m_a, int m_b)
 	{
 		this->a = m_a;
 		this->b = m_b;
 		cout << "父类的有参构造函数" << endl;
 	}
 	~Parent()
 	{
 		cout << "父类的析构函数" << endl;
 	}
 private:
 	int a;
 	int b;
 };
 
 class Child:public Parent
 {
 public:
 	Child(int a, int b, int c) : Parent(a, b)//初始化列表，否则会报错
 	{
 		this->c = c;
 		cout << "子类的构造函数" << endl;
 	}
 
 	~Child()
 	{
 		cout << "子类的析构函数" << endl;
 	}
 
 	void printC()
 	{
 		cout << "我是儿子" << endl;
 	}
 private:
 	int c;
 };
 
 void playObj()
 {
 	Child c1(1, 2, 3);
 }
 
 void main()
 {
 	playObj();
 
 }
 /*
 父类的有参构造函数
 子类的构造函数
 子类的析构函数
 父类的析构函数
 请按任意键继续. . .
 */

[70]: /images/20220528/3d8d455426f342318026c13df9371366.png
[70 1]: /images/20220528/457309f179c14caa8bf05d119f42e978.png
[70 2]: /images/20220528/e01789aa87f64507b4811f825ce9e931.png
[70 3]: /images/20220528/fdfd35b7a1f1422eafa48550d19c1d97.png