• 继承(个人学习笔记黑马学习)

    1、基本语法

    1. #include 
    2. using namespace std;
    3. #include 
    4.  
    5. //普通实现页面
    6.  
    7. //Java页面
    8. //class Java {
    9. //public:
    10. //	void header() {
    11. //		cout << "首页、公开课、登录、注册...(公共头部)" << endl;
    12. //	}
    13. //	void footer() {
    14. //		cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
    15. //	}
    16. //	void left() {
    17. //		cout << "Java、python、c++...(公共分类列表)" << endl;
    18. //	}
    19. //	void content() {
    20. //		cout << "Java学科视频" << endl;
    21. //	}
    22. //};
    23. //
    24. //
    25. Python页面
    26. //class Python {
    27. //public:
    28. //	void header() {
    29. //		cout << "首页、公开课、登录、注册...(公共头部)" << endl;
    30. //	}
    31. //	void footer() {
    32. //		cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
    33. //	}
    34. //	void left() {
    35. //		cout << "Java、python、c++...(公共分类列表)" << endl;
    36. //	}
    37. //	void content() {
    38. //		cout << "Python学科视频" << endl;
    39. //	}
    40. //}; 
    41. //
    42. C++页面
    43. //class CPP {
    44. //public:
    45. //	void header() {
    46. //		cout << "首页、公开课、登录、注册...(公共头部)" << endl;
    47. //	}
    48. //	void footer() {
    49. //		cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
    50. //	}
    51. //	void left() {
    52. //		cout << "Java、python、c++...(公共分类列表)" << endl;
    53. //	}
    54. //	void content() {
    55. //		cout << "C++学科视频" << endl;
    56. //	}
    57. //};
    58.  
    59. //继承实现页面
    60.  
    61. //公共页面
    62. class BasePage {
    63. public:
    64. 		void header() {
    65. 			cout << "首页、公开课、登录、注册...(公共头部)" << endl;
    66. 		}
    67. 		void footer() {
    68. 			cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
    69. 		}
    70. 		void left() {
    71. 			cout << "Java、python、c++...(公共分类列表)" << endl;
    72. 		}
    73. };
    74.  
    75. //Java页面
    76. class Java :public BasePage {
    77. public:
    78. 	void content() {
    79. 				cout << "Java学科视频" << endl;
    80. 			}
    81. };
    82.  
    83. //Python页面
    84. class Python :public BasePage {
    85. public:
    86. 	void content() {
    87. 		cout << "Python学科视频" << endl;
    88. 	}
    89. };
    90.  
    91. //C++页面
    92. class CPP :public BasePage {
    93. public:
    94. 	void content() {
    95. 		cout << "C++学科视频" << endl;
    96. 	}
    97. };
    98.  
    99. void test01() {
    100. 	cout << "Java下载视频页面如下：" << endl;
    101. 	Java ja;
    102. 	ja.header();
    103. 	ja.footer();
    104. 	ja.left();
    105. 	ja.content();
    106.  
    107. 	cout << "---------------------------" << endl;
    108. 	cout << "Python下载视频页面如下：" << endl;
    109. 	Python py;
    110. 	py.header();
    111. 	py.footer();
    112. 	py.left();
    113. 	py.content();
    114.  
    115.  
    116. 	cout << "---------------------------" << endl;
    117. 	cout << "C++下载视频页面如下：" << endl;
    118. 	CPP cpp;
    119. 	cpp.header();
    120. 	cpp.footer();
    121. 	cpp.left();
    122. 	cpp.content();
    123. }
    124.  
    125. int main() {
    126.  
    127. 	test01();
    128.  
    129.  
    130.  
    131. 	system("pause");
    132. 	return 0;
    133. }

    2、继承方式

    继承方式一共有三种:

    • 公共继承
    • 保护继承
    • 私有继承
    1. #include 
    2. using namespace std;
    3. #include 
    4.  
    5.  
    6. //公共继承
    7. class Base1 {
    8. public:
    9. 	int m_A;
    10. protected:
    11. 	int m_B;
    12. private:
    13. 	int m_C;
    14. };
    15.  
    16. class Son1 :public Base1 {
    17. 	void func() {
    18. 		m_A = 10;//父类中的公共权限成员 到子类中依然是公共权限
    19. 		m_B = 10;//父类中的保护权限成员 到子类中依然是保护权限
    20. 		//m_C = 10;//父类中的私有权限成员 子类访问不到
    21. 	}
    22. };
    23. void test01() {
    24. 	Son1 s1;
    25. 	s1.m_A = 100;
    26. 	//s1.m_B = 100;//到son1中 m_B是保护权限 类外访问不到
    27. }
    28.  
    29. //保护继承
    30. class Base2 {
    31. public:
    32. 	int m_A;
    33. protected:
    34. 	int m_B;
    35. private:
    36. 	int m_C;
    37. };
    38.  
    39. class Son2 :protected Base2 {
    40. public:
    41. 	void func() {
    42. 		m_A = 10;//父类中的公共权限成员 到子类中是保护权限
    43. 		m_B = 10;//父类中的保护权限成员 到子类中依然是保护权限
    44. 		//m_C = 10;//父类中的私有权限成员 子类访问不到
    45. 	}
    46. };
    47.  
    48. void test02() {
    49. 	Son2 s1;
    50. 	//s1.m_A = 1000;//在son2中 m_A变为保护权限 因此类外访问不到
    51. 	//s1.m_B = 1000;//在son2中 m_B保护权限 不可以访问
    52. }
    53.  
    54. //私有继承
    55. class Base3 {
    56. public:
    57. 	int m_A;
    58. protected:
    59. 	int m_B;
    60. private:
    61. 	int m_C;
    62. };
    63. class Son3 :private Base2 {
    64. public:
    65. 	void func() {
    66. 		m_A = 10;//父类中的公共权限成员 到子类中是私有权限
    67. 		m_B = 10;//父类中的保护权限成员 到子类中是私有权限
    68. 		//m_C = 10;//父类中的私有权限成员 子类访问不到
    69. 	}
    70. };
    71.  
    72. class GrandSon3 :public Son3 {
    73. public:
    74. 	void func() {
    75. 		//m_A = 1000;//到了son3中 m_A变为私有 即使是儿子 也访问不到
    76. 		//m_B = 1000;//到了son3中 m_B变为私有 即使是儿子 也访问不到
    77. 	}
    78. };
    79.  
    80. void test03() {
    81. 	Son3 s1;
    82. 	//s1.m_A = 1000;//在son3中 m_A变为私有权限 因此类外访问不到
    83. 	//s1.m_B = 1000;//在son3中 m_B私有权限 不可以访问
    84. }
    85.  
    86. int main() {
    87.  
    88.  
    89.  
    90.  
    91.  
    92. 	system("pause");
    93. 	return 0;
    94. }

    3、继承中的对象模型

    1. #include 
    2. using namespace std;
    3. #include 
    4.  
    5. class Base {
    6. public:
    7. 	int m_A;
    8. protected:
    9. 	int m_B;
    10. private:
    11. 	int m_C;
    12. };
    13.  
    14. class Son :public Base {
    15. public:
    16. 	int m_D;
    17.  
    18. };
    19.  
    20. //利用开发人员命令提示符工具查看对象模型
    21. //跳转盘符 F:
    22. //跳转文件路径 cd 具体路径下
    23. //查看命令
    24. // cl /d1 reportSingleClassLayout类名 文件名
    25.  
    26.  
    27. void test01() {
    28.  
    29. 	//16
    30. 	//父类中所有非静态成员属性都会被子类继承下去
    31. 	//父类中私有成员属性 是被编译器给隐藏了 因此是访问不到，但是缺省被继承下去了
    32. 	cout << "size of Son = " << sizeof(Son) << endl;
    33. }
    34.  
    35.  
    36. int main() {
    37.  
    38.  
    39. 	system("pause");
    40. 	return 0;
    41. }

    4、继承中构造和析构顺序

    1. #include 
    2. using namespace std;
    3. #include 
    4.  
    5. //继承中的构造和析构顺序
    6. class Base {
    7. public:
    8. 	Base() {
    9. 		cout << "Base的构造函数" << endl;
    10. 	}
    11.  
    12. 	~Base() {
    13. 		cout << "Base的析构函数" << endl;
    14.  
    15. 	}
    16. };
    17. class Son :public Base {
    18. public:
    19. 	Son() {
    20. 		cout << "Son的构造函数" << endl;
    21. 	}
    22.  
    23. 	~Son() {
    24. 		cout << "Son的析构函数" << endl;
    25.  
    26. 	}
    27. };
    28.  
    29. void test01() {
    30.  
    31. 	//继承的构造和析构顺序如下：
    32. 	//先构造父类 再构造子类，析构的顺序与构造的顺序相反
    33. 	Son s;
    34. }
    35.  
    36.  
    37. int main() {
    38.  
    39. 	test01();
    40.  
    41. 	system("pause");
    42. 	return 0;
    43. }

    5、同名成员处理

    1. #include 
    2. using namespace std;
    3. #include 
    4.  
    5. class Base {
    6. public:
    7.  
    8. 	Base() {
    9. 		m_A = 100;
    10. 	}
    11. 	void func() {
    12. 		cout << "Base - func()调用" << endl;
    13. 	}
    14.  
    15. 	void func(int a) {
    16. 		cout << "Base - func(int a)调用" << endl;
    17. 	}
    18.  
    19. 	int m_A;
    20. };
    21. class Son :public Base {
    22. public:
    23. 	Son() {
    24. 		m_A = 200;
    25. 	}
    26.  
    27. 	void func() {
    28. 		cout << "Son - func()调用" << endl;
    29. 	}
    30.  
    31. 	int m_A;
    32. };
    33.  
    34. //同名成员属性
    35. void test01() {
    36. 	Son s;
    37. 	cout << "Son 下m_A = " << s.m_A << endl;
    38.  
    39. 	//如果通过子类对象 访问到父类中同名成员 需要加作用域
    40. 	cout << "Base 下m_A = " << s.Base::m_A << endl;
    41.  
    42. }
    43.  
    44. //同名成员函数处理
    45. void test02() {
    46. 	Son s;
    47. 	s.func();//直接调用 调用是子类中的同名成员
    48.  
    49. 	s.Base::func();//调用父类的
    50.  
    51. 	//如果子类中出现和父类同名的成员函数，子类的同名成员会隐藏掉父类中所有同名的成员函数
    52. 	//如果想访问到父类中被隐藏的同名成员函数，需要加作用域
    53. 	//s.func(100); 错误
    54. 	s.Base::func(100);
    55. }
    56.  
    57. int main() {
    58.  
    59. 	//test01();
    60. 	test02();
    61.  
    62. 	system("pause");
    63. 	return 0;
    64. }

    6、同名静态成员处理方法

    1. #include 
    2. using namespace std;
    3. #include 
    4.  
    5. class Base {
    6. public:
    7. 	static int m_A;
    8.  
    9. 	static void func() {
    10. 		cout << "Base - static void func()" << endl;
    11. 	}
    12. };
    13. int Base::m_A=100;
    14.  
    15.  
    16. class Son :public Base {
    17. public:
    18. 	static int m_A;
    19.  
    20. 	static void func() {
    21. 		cout << "Son - static void func()" << endl;
    22. 	}
    23. };
    24. int Son::m_A = 200;
    25.  
    26.  
    27. //同名静态成员属性
    28. void test01() {
    29.  
    30. 	//1、通过对象访问
    31. 	cout << "通过对象访问：" << endl;
    32. 	Son s;
    33. 	cout << " Son 下m_A = " << s.m_A << endl;
    34. 	cout << "Base 下m_A = " << s.Base::m_A << endl;
    35.  
    36.  
    37. 	//2、通过类名访问
    38. 	cout << "通过类名访问：" << endl;
    39. 	cout << "Son 下m_A = " << Son::m_A << endl;
    40. 	//第一个：代表通过类名方式访问 第二个：代表访问父类作用域下
    41. 	cout << "Base 下m_A = " << Son::Base::m_A << endl;
    42.  
    43. }
    44. //同名静态成员函数
    45. void test02() {
    46.  
    47. 	//1、通过对象访问
    48. 	cout << "通过对象访问：" << endl;
    49. 	Son s;
    50. 	s.func();
    51. 	s.Base::func();
    52.  
    53. 	//2、通过类名访问
    54. 	cout << "通过类名访问：" << endl;
    55. 	Son::func();
    56. 	Son::Base::func();
    57. }
    58.  
    59.  
    60. int main() {
    61.  
    62. 	//test01();
    63. 	test02();
    64.  
    65. 	system("pause");
    66. 	return 0;
    67. }

    7、多继承语法

    1. #include 
    2. using namespace std;
    3. #include 
    4.  
    5. class Base1 {
    6. public:
    7. 	Base1() {
    8. 		m_A = 100;
    9. 	}
    10.  
    11. 	int m_A;
    12. };
    13.  
    14. class Base2{
    15. public:
    16. 	Base2() {
    17. 		m_A = 200;
    18. 	}
    19.  
    20. 	int m_A;
    21. };
    22.  
    23.  
    24. //子类 需要继承Base1 和Base2
    25. class Son :public Base1, public Base2 {
    26. public:
    27.  
    28. 	Son() {
    29. 		m_C = 300;
    30. 		m_D = 400;
    31. 	}
    32. 	int m_C;
    33. 	int m_D;
    34. };
    35.  
    36. void test01() {
    37. 	Son s;
    38. 	cout << "sizeof Son = " << sizeof(s) << endl;
    39. 	//当父类中出现同名成员，需要加作用域区分
    40. 	cout << "Base1::m_A = " << s.Base1::m_A << endl;
    41. 	cout << "Base2::m_A = " << s.Base2::m_A << endl;
    42. }
    43.  
    44. int main() {
    45.  
    46. 	test01();
    47.  
    48.  
    49. 	system("pause");
    50. 	return 0;
    51. }

    8、菱形继承

    菱形继承概念：
    两个派生类继承同一个基类

    又有某个类同时继承者两个派生类

    这种继承被称为菱形继承，或者钻石继承

    1. #include 
    2. using namespace std;
    3. #include 
    4.  
    5. //动物类
    6. class Animal {
    7. public:
    8. 	int m_Age;
    9. };
    10.  
    11. //利用虚继承 解决菱形继承的问题
    12. //继承之前 加上关键字 virtual 变为虚继承
    13. // Animal类称为 虚基类
    14. //羊类  
    15. class Sheep :virtual public Animal {
    16.  
    17. };
    18.  
    19. //驼类
    20. class Tuo :virtual public Animal {
    21.  
    22. };
    23.  
    24. //羊驼类
    25. class SheepTuo :public Sheep, public Tuo {
    26.  
    27. };
    28.  
    29. void test01() {
    30. 	SheepTuo st;
    31. 	st.Sheep::m_Age = 18;
    32. 	st.Tuo::m_Age = 28;
    33. 	//当菱形继承，两个父类拥有相同数据，需要加以作用域区分
    34. 	cout << "st.Sheep::m_Age = " << st.Sheep::m_Age << endl;
    35. 	cout << "st.Tuo::m_Age =" << st.Tuo::m_Age << endl;
    36. 	cout << "st.m_Age = " << st.m_Age << endl;
    37.  
    38. 	//这份数据我们知道 只要有一份就可以，菱形继承导致数据有两份，资源浪费
    39.  
    40. }
    41.  
    42. int main() {
    43.  
    44. 	test01();
    45.  
    46.  
    47. 	system("pause");
    48. 	return 0;
    49. }

  • 相关阅读:
    python基础教程
    XAF新手入门 - 类型子系统(Types Info Subsystem)
    SpringCloud - Spring Cloud Alibaba 之 SkyWalking 分布式链路跟踪；跨多服务追踪，集成日志（十五）
    人生的B计划：构建“一个人”的商业模式
    机器学习（西瓜书）第 7 章 贝叶斯分类器
    算法题：Find the closest common ancestor
    JSP总结
    Java中如何遍历Map中的key呢？
    Git学习笔记9
    VSCode 好用的插件分享
  • 原文地址：https://blog.csdn.net/m0_59848857/article/details/132676440