第三章 继承

已于 2022-06-01 17:08:16 修改
阅读量79 收藏
点赞数
分类专栏： C++重难点 文章标签： c++
于 2022-05-31 17:23:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43205256/article/details/125069330
版权

1 继承的概念

继承是面向对象三大特性之一
有些类与类之间存在特殊的关系，例如下图中：

我们发现，定义这些类时，下级别的成员除了拥有上一级的共性，还有自己的特性。
这个时候我们就可以考虑利用继承的技术，减少重复代码 。

2 继承的基本语法

例如我们看到很多网站中，都有公共的头部，公共的底部，公共的左侧列表，只有中心内容不同接下来我们分别利用普通写法和继承的写法来实现网页中的内容，看一下继承存在的意义以及好处。
2.1 普通实现： 
//Java页面 
class Java 
{
public: 
	  void header()
	  {
		cout << "首页、公开课、登录、注册...（公共头部）" << endl;
	  }
				  
	  void footer() 
	  { 
		  cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl; 
	  }

	  void left() 
	  { 
		  cout << "Java,Python,C++...(公共分类列表)" << endl; 
	  }

	  void content() 
	  {
		  cout << "JAVA学科视频" << endl; 
	  } 
};



//Python页面 
class Python 
{
public: 
	void header() 
	{ 
		cout << "首页、公开课、登录、注册...（公共头部）" << endl; 
	}
	void footer() 
	{ 
		cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl; 
	}
	void left() 
	{ 
		cout << "Java,Python,C++...(公共分类列表)" << endl; 
	}
	void content() 
	{ 
		cout << "Python学科视频" << endl; 
	} 
};



//C++页面 
class CPP 
{
public: 
	void header() 
	{ 
		cout << "首页、公开课、登录、注册...（公共头部）" << endl; 
	}
	void footer() 
	{ 
		cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl; 
	}
	void left() 
	{ 
		cout << "Java,Python,C++...(公共分类列表)" << endl; 
	}
	void content() 
	{ 
		cout << "C++学科视频" << endl; 
	} 
};



void test01() 
{ 
	//Java页面 
	cout << "Java下载视频页面如下： " << endl; 
	Java ja; 
    ja.header(); 
	ja.footer(); 
    ja.left(); 
	ja.content(); 
	cout << "--------------------" << endl; 
	

	//Python页面 
	cout << "Python下载视频页面如下： " << endl; 
	Python py; 
    py.header();
	py.footer(); 
	py.left(); 
	py.content(); 
	cout << "--------------------" << endl; 
	

	//C++页面 
	cout << "C++下载视频页面如下： " << endl; 
	CPP cp; 
    cp.header(); 
    cp.footer(); 
	cp.left(); 
    cp.content();
    cout << "--------------------" << endl;  
}



int main() 
{ 
	test01(); 
	return 0; 
}

输出结果

Java下载视频页面如下：
首页、公开课、登录、注册...（公共头部）
帮助中心、交流合作、站内地图...(公共底部)
Java,Python,C++...(公共分类列表)
JAVA学科视频
--------------------
Python下载视频页面如下：
首页、公开课、登录、注册...（公共头部）
帮助中心、交流合作、站内地图...(公共底部)
Java,Python,C++...(公共分类列表)
Python学科视频
--------------------
C++下载视频页面如下：
首页、公开课、登录、注册...（公共头部）
帮助中心、交流合作、站内地图...(公共底部)
Java,Python,C++...(公共分类列表)
C++学科视频
--------------------

2.2 继承实现：  
//公共页面 
class BasePage 
{
public: 
	void header() 
	{ 
		cout << "首页、公开课、登录、注册...（公共头部）" << endl; 
	}
	void footer() 
	{ 
		cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl; 
	}
	void left() 
	{ 
		cout << "Java,Python,C++...(公共分类列表)" << endl; 
	} 
};


//Java页面 
class Java : public BasePage 
{
public: 
	void content() 
	{ 
		cout << "JAVA学科视频" << endl; 
	} 
};



//Python页面 
class Python : public BasePage 
{
public: 
	void content() 
	{ 
		cout << "Python学科视频" << endl; 
	} 
};



//C++页面 
class CPP : public BasePage 
{
public: 
	void content() 
	{ 
		cout << "C++学科视频" << endl; 
	} 
};


void test01() 
{ 
	//Java页面 
	cout << "Java下载视频页面如下： " << endl; 
	Java ja; 
	ja.header(); 
	ja.footer(); 
	ja.left(); 
	ja.content(); 
	cout << "--------------------" << endl; 
	
	//Python页面 
	cout << "Python下载视频页面如下： " << endl; 
	Python py; 
	py.header(); 
	py.footer(); 
	py.left(); 
	py.content(); 
	cout << "--------------------" << endl; 
	
	//C++页面 
	cout << "C++下载视频页面如下： " << endl; 
	CPP cp; 
	cp.header(); 
	cp.footer(); 
	cp.left(); 
	cp.content(); 
	cout << "--------------------" << endl;
}


int main() 
{ 
	test01();  
	return 0; 
}

输出结果

Java下载视频页面如下：
首页、公开课、登录、注册...（公共头部）
帮助中心、交流合作、站内地图...(公共底部)
Java,Python,C++...(公共分类列表)
JAVA学科视频
--------------------
Python下载视频页面如下：
首页、公开课、登录、注册...（公共头部）
帮助中心、交流合作、站内地图...(公共底部)
Java,Python,C++...(公共分类列表)
Python学科视频
--------------------
C++下载视频页面如下：
首页、公开课、登录、注册...（公共头部）
帮助中心、交流合作、站内地图...(公共底部)
Java,Python,C++...(公共分类列表)
C++学科视频
--------------------

由上可见，继承语法在实现同样功能时可大幅度减少代码量。

总结：
继承的好处：==可以减少重复的代码==
class A : public B;
A 类称为子类 或 派生类
B 类称为父类 或 基类
派生类中的成员，包含两大部分：
一类是从基类继承过来的，一类是自己增加的成员。
从基类继承过过来的体现其共性，而新增的成员体现了其个性。

3. 继承方式

继承的语法： class 子类 : 继承方式 父类
继承方式一共有三种：
公共继承
保护继承
私有继承

如下图所示：

示例： 
class Base1 
{ 
public: 
	int m_A;
protected: 
	int m_B;
private: 
	int m_C;
};


//公共继承 
class Son1 :public Base1 
{
public: 
	void func() 
	{ 
		m_A; //可访问 public权限 
		m_B; //可访问 protected权限 
	  //m_C; //不可访问 
	} 
};

void myClass() 
{ 
	Son1 s1; 
	s1.m_A; //对象只能访问到公共权限 
}


//保护继承
class Base2 
{
public: 
	int m_A;
protected: 
	int m_B;
private: 
	int m_C; 
}; 

class Son2 :protected Base2 
{
public: 
	void func() 
	{
	m_A; //可访问 protected权限 
	m_B; //可访问 protected权限 
  //m_C; //不可访问 
	} 
};

void myClass2() 
{ 
	Son2 s; 
  //s.m_A; //对象内所有成员都不可访问 
}


//私有继承 
class Base3 
{
public: 
	int m_A; 
protected: 
	int m_B;
private: 
	int m_C; 
};

class Son3:private Base3 
{
public: 
	void func() 
	{ 
		m_A; //可访问 private权限 
		m_B; //可访问 private权限 
	  //m_C; //不可访问 
	} 
};



void myClass3()
{
	Son3 s;
	//s.m_A; //对象内所有成员都不可访问 
}



class GrandSon3 :public Son3
{
public:
	void func()
	{
		//Son3是私有继承，所以继承Son3的属性在GrandSon3中都无法访问到 //m_A; //m_B; //m_C; 
	}
};

4 继承中的对象模型

问题： 从父类继承过来的成员，哪些属于子类对象中？
示例： 
class Base 
{
public: 
int m_A; 
protected: 
int m_B; 
private: 
	int m_C; //私有成员只是被隐藏了，但是还是会继承下去 
};

//公共继承 
class Son :public Base 
{
public: 
	int m_D; 
};

void test01() 
{ 
	cout << "sizeof Son = " << sizeof(Son) << endl; 
}

int main() 
{ 
	test01(); 
	return 0; 
}

输出结果

sizeof Son = 16

结论： 父类中私有成员也是被子类继承下去了，只是由编译器给隐藏后访问不到。

5 继承中构造和析构顺序

子类继承父类后，当创建子类对象，也会调用父类的构造函数
问题：父类和子类的构造和析构顺序是谁先谁后？
示例： 
class Base 
{ 
public: 
	Base() 
	{ 
		cout << "Base构造函数!" << endl; 
	}

	~Base() 
	{ 
		cout << "Base析构函数!" << endl; 
	} 
}; 

class Son : public Base 
{ 
public: 
	Son() 
	{
		cout << "Son构造函数!" << endl;
	}
	
	~Son() 
	{
	cout << "Son析构函数!" << endl; 
	} 
};


void test01() 
{ 
	Base B;
	Son S;         //继承中先调用父类构造函数，再调用子类构造函数，析构顺序与构造相反; 
}

int main() 
{ 
	test01(); 
	return 0; 
}

输出结果

Base构造函数!
Base构造函数!
Son构造函数!
Son析构函数!
Base析构函数!
Base析构函数!

总结： 继承中先调用父类构造函数，再调用子类构造函数，析构顺序与构造相反。

6 继承同名成员处理方式

问题：当子类与父类出现同名的成员，如何通过子类对象，访问到子类或父类中同名的成员呢？
访问子类同名成员 直接访问即可
访问父类同名成员 需要加作用域
示例： 
class Base 
{
public: 
	Base() 
	{ 
		m_A = 100; 
	}void func() 
	{ 
		cout << "Base - func()调用" << endl; 
	}
	void func(int a) 
	{ 
		cout << "Base - func(int a)调用" << endl; 
	}
public: int m_A;
}; 



class Son : public Base 
{
public: 
	Son()
	{
		m_A = 200;
	}
//当子类与父类拥有同名的成员函数，子类会隐藏父类中所有重载的同名成员函数 
//如果想访问父类中被隐藏的同名成员函数，需要加父类的作用域 
	void func()
	{
		cout << "Son - func()调用" << endl;
	}
public: 
	int m_A; 
};


void test01() 
{ 
	Son s; 
	cout << "Son下的m_A = " << s.m_A << endl; 
	cout << "Base下的m_A = " << s.Base::m_A << endl; 
	s.func(); 
	s.Base::func(); 
	s.Base::func(10); 
}

int main() 
{ 
	test01(); 
	return 0; 
}
输出结果
Son下的m_A = 200
Base下的m_A = 100
Son - func()调用
Base - func()调用
Base - func(int a)调用
总结：
1. 子类对象可以直接访问到子类中同名成员
2. 子类对象加作用域可以访问到父类同名成员
3. 当子类与父类拥有同名的成员函数，子类会隐藏父类中同名成员函数，加作用域可以访问到父类中同名函数

7 继承同名静态成员处理方式

问题：继承中同名的静态成员在子类对象上如何进行访问？
访问子类同名成员 直接访问即可
访问父类同名成员 需要加作用域
示例： 
class Base 
{ 
public: 
	static void func() 
	{ 
		cout << "Base - static void func()" << endl; 
	}
	static void func(int a) 
	{ 
		cout << "Base - static void func(int a)" << endl;      //重载函数
	}
	static int m_A;       //类内声明
}; 

int Base::m_A = 100;      //类外定义





class Son : public Base 
{ 
public: 
	static void func() 
	{ 
		cout << "Son - static void func()" << endl; 
	}
	static int m_A;      //类内声明
}; 

int Son::m_A = 200;      //类外定义，同名成员属性 





void test01() 
{ 
	cout << "通过对象访问： " << endl; 
	Son s; 
	cout << "Son 下 m_A = " << s.m_A << endl; 
	cout << "Base 下 m_A = " << s.Base::m_A << endl;
	cout << "\n" << endl;
	cout << "通过类名访问： " << endl;
	cout << "Son 下 m_A = " << Son::m_A << endl; 
	cout << "Base 下 m_A = " << Son::Base::m_A << endl;
	cout << "\n" << endl;
}





//同名成员函数 
void test02() 
{ 
	cout << "通过对象访问： " << endl; 
	Son s; 
	s.func(); 
	s.Base::func();
	cout << "\n" << endl;
	cout << "通过类名访问： " << endl; 
	Son::func(); 
	Son::Base::func();       //出现同名，子类会隐藏掉父类中所有同名成员函数，需要加作作用域访问 
	Son::Base::func(100); 
}



int main() 
{ 
	test01(); 
	test02(); 
	return 0; 
}

输出结果 

通过对象访问：
Son 下 m_A = 200
Base 下 m_A = 100


通过类名访问：
Son 下 m_A = 200
Base 下 m_A = 100


通过对象访问：
Son - static void func()
Base - static void func()


通过类名访问：
Son - static void func()
Base - static void func()
Base - static void func(int a)

总结： 同名静态成员处理方式和非静态处理方式一样，只不过有两种访问的方式（通过对象和通 过类名）

8 多继承语法

C++ 允许 一个类继承多个类
语法： class 子类 ：继承方式 父类1 ， 继承方式 父类2...
多继承可能会引发父类中有同名成员出现，需要加作用域区分
C++ 实际开发中不建议用多继承

示例： 
class Base1 
{ 
public: 
	Base1()
	{
		m_A = 100;
	}

public: 
	int m_A; 
}; 




class Base2 
{
public: 
	Base2()
	{
		m_A = 200;
	}

public: 
	int m_A;
};




class Son : public Base2, public Base1 
{
public: 
	Son()
	{
		m_C = 300;
		m_D = 400;
	}

public: 
	int m_C;
	int m_D; 
};




//多继承容易产生成员同名的情况 
//通过使用类名作用域可以区分调用哪一个基类的成员 
void test01() 
{ 
	Son s; 
	cout << "sizeof Son = " << sizeof(s) << endl; 
	cout << "s.Base1_m_A=" << s.Base1::m_A << endl;
	cout << "s.Base2_m_A=" << s.Base2::m_A << endl;
}




int main() 
{ 
	test01(); 
	return 0;
}

输出结果

sizeof Son = 16
s.Base1_m_A=100
s.Base2_m_A=200

总结： 多继承中如果多个父类中出现了同名情况，子类使用时候要加作用域

9 菱形继承

菱形继承概念：
两个派生类继承同一个基类
又有某个类同时继承者两个派生类
这种继承被称为菱形继承，或者钻石继承
典型的菱形继承案例：

菱形继承问题：
1. 羊继承了动物的数据，驼同样继承了动物的数据，当草泥马使用数据时，就会产生二义性。
2. 草泥马继承自动物的数据继承了两份，其实我们应该清楚，这份数据我们只需要一份就可以。
示例：
  
class Animal 
{ 
public: 
	int m_Age; 
};

//继承前加virtual关键字后，变为虚继承 
//此时公共的父类Animal称为虚基类 

class Sheep : virtual public Animal         //继承Animal
{};


class Tuo : virtual public Animal           //继承Animal
{}; 


class SheepTuo : public Sheep, public Tuo   //继承Sheep和Tuo
{}; 


void test01() 
{ 
	SheepTuo st; 
	st.Sheep::m_Age = 100; 
	st.Tuo::m_Age = 200; 
	cout << "st.Sheep::m_Age = " << st.Sheep::m_Age << endl; 
	cout << "st.Tuo::m_Age = " << st.Tuo::m_Age << endl; 
	cout << "st.m_Age = " << st.m_Age << endl; 
}


int main() 
{ 
	test01(); 
	return 0; 
}

输出结果

st.Sheep::m_Age = 200
st.Tuo::m_Age = 200
st.m_Age = 200

总结：
菱形继承带来的主要问题是子类继承两份相同的数据，导致资源浪费以及毫无意义 ， 利用虚继承可以解决菱形继承问题。

第三章完

happy 天堂
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA 面向对象程序设计第3章 继承与多态.pptx
07-05
第3章 继承与多态;回顾;本章内容;3.1 包;3.1 包;3.1.1 自定义包;3.1.2 包的导入;3.1.2 包的导入;3.1.3 包的访问权限;3.1.4 学生实践练习;3.1.4 学生实践练习;3.2 继承;3.2 继承;3.2.1 继承概述;3.2.1 继承概述;3.2.2...
java第二章继承答案_第二章继承
weixin_28339967的博客
02-24 227
语法修饰符 子类 extends 父类{//类定义部分}继承是面向对象的三大特特之一，Java只支持单继承。继承表达 is a 的关系。子类可以从父类继承到哪些财产?继承public和protected修饰的属性和方法，无论两者是否位于同一个包当找中.继承默认权限修饰符的属性和方法，必须同包无法继承private修饰的属性和方法.无法继承父类的构造函数.在Java中访问修饰符的访问权限访问修饰符本...
JAVA面对对象程序设计：第三章 继承与多态
wyfsg1948753316的博客
06-15 1287
3.1 包 如果在程序中没有声明包，类将存放在default的包中，default的包没有名称。不建议采用default包的形式，建议开发人员按照业务的需要创建用户的
第三章 继承的综合案例
HelloWowofei的博客
05-07 350
第三章 继承的综合案例 3.1综合案例：群主发普通红包 群主发普通红包。某群有多名成员，群主给成员发普通红包。普通红包的规则： 1.群主的一笔金额，从群主余额中扣除，平均分成n等份，让成员领取。 2.成员领取红包后，保存到成员余额中。 请根据描述，完成案例中所有类的定义以及指定类之间的继承关系，并完成发红包的操作。 3.2案例分析 根据描述分析，得出如下继承体系： 3.3案例实现 定义用户类： ...
Java面向对象笔记 • 【第3章 继承与多态】
杨明金的博客
05-11 7086
3.1 包 生活工作中的包、文件夹 管理计算机程序和文件的目录结构 3.1.1 自定义包 如果在程序中没有声明包，类将被存放在default的包中，该方式不被提倡。 语法： package 包名 包命名规范： 包的命名规范应当体现出项目资源良好的划分 自定义标签类所在包命名规范：公司名称.开发组名称.项目名称 例如：com.java.explorer 声明一个包的语句必须写在类中的第一行 3.1.2 包的导入 语法： import 包名.类名 示例：
第三章 继承与多态 掌握封装的含义及用法 什么是继承? 继承有什么作用? 怎么写继承?
03-16
第三章 继承与多态 掌握封装的含义及用法 什么是继承? 继承有什么作用? 怎么写继承? 1.继承的概念及其用法 2.方法的重写及重载与其的区别 3.多态及其应用 4.super关键字 5.final关键字
3第三章知识点整理1
08-03
第三章 类的重用3.1 类的继承3.1.1 继承的概念根据已有类定义新类，新类拥有已有类的所有功能。Java 只支持单继承，每个子类只能有一个直接超类。超类是所
WPF揭秘 第三章 wpf 开发
04-09
　第3章　WPF的重要新概念　 　3.1　逻辑树与可视树　 　3.2　依赖属性　 　3.2.1　依赖属性的实现　 　3.2.2　变更通知　 　3.2.3　属性值继承　 　3.2.4　对多个提供程序的支持　 　3.2.5　附加属性　 　3.3　路由...
PTA-JAVA第3章练习
10-31
6-31 定义复数类Complex 6-32 比较两个对象是否相等 ...6-39 实现部门介绍功能需求说明（继承） 6-310 高速公路车辆收费系统（继承） 6-311 模拟控制动物叫的功能（多态） 6-312 使用多态实现图书馆计算罚金功能
【C++第三阶段】list容器&排序
还有很多需要学习，现在还很菜
04-29 626
以下内容仅为当前认识，可能有不足之处，欢迎讨论！
《21天学通C++》（第十章）实现继承（1）
立志成为炼丹师？
04-28 243
覆盖是一种极端情况，即派生类中的重载方法会隐藏基类中方法的所有重载版本，导致需要调用时无法调用，示例代码如下。解决方法3：在派生类中，把基类中的方法全部重载一次，并在派生类中就调用基类方法。只要派生类中实现了从基类中继承的函数，且返回值和标值相同，就可以覆盖。如果基类包含重载的构造函数，可以使用初始化列表传递参数。，避免不定义的情况下，随机数值产生影响。解决办法1：使用作用域解析符。解决方法2：在派生类中使用。同样使用作用域解析运算符。在构造一个派生类时，使用作用域解析运算符。若想调用基类中的方法。
C++ Primer (第五版）第八章习题部分答案
weixin_48467622的博客
04-27 1041
C++ Primer (第五版）第八章习题部分答案
手搓顺序表（C语言）
m0_62646213的博客
04-23 751
顺序表头插头删，尾插尾删，任意位置插入删除的实现和优劣分析
C++相关概念和易错语法（9）（变量的存储、new和delete混用分析）
SGlow0708的博客
04-28 719
我们发现如果这个时候直接去调用operator delete[]、operator delete、delete、free就会导致释放的内存起始位置发生了位移，这就会导致报错，而delete[]就会先从前4个字节开始，先读取个数，然后。注意数组是开辟了空间的，会发生复制操作，就算是常量字符串储存在代码段，也要拷贝过来。如果类没有显式实现析构函数，那么就意味着不会多开辟那4个字节，也就不会报错，这个时候混用不会导致程序崩溃。当我们创建类的数组时，使用new[]，因为使用它可以在开辟空间的时候。
C++ 智能指针
最新发布
m0_65143871的博客
05-02 294
智能指针是针对内存泄漏的问题进行处理。
C++中list的使用
m0_74189279的博客
04-29 1116
C++lsit的使用详细介绍与示范
(C++) this_thread 函数介绍
cuber-lotus的博客
04-24 1709
在C++11起，标准规定了标注的并发库。头文件为并发支持库 (C++11 起) - cppreference.com其包含线程、原子操作、互斥、条件变量和 future 的内建支持。而其中有一个namespace为，里面有四个重要的全局函数，其实现都与当前系统环境和编译器强绑定。std::this_thread 符号索引 - cppreference.comget_id()yield()返回当前线程的id。这个id是一个的内部类型。其实现依附于所在平台。
迭代器iterator是C++中用于遍历容器中元素的对象
book_dw5189的博客
04-28 784
迭代器的使用通常伴随着容器的.begin()和.end()成员函数，这两个函数分别返回指向容器第一个元素和尾后元素的迭代器。
编译原理第三版第六章答案
12-05
编译原理第三版第六章主要介绍了语义分析的相关内容，包括翻译模式、预测翻译器、属性文法等。其中，翻译模式是一种自顶向下的语法分析方法，可以通过构造预测翻译器来实现。预测翻译器是一种递归下降的语法分析器，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值