P127-4.6继承

  1 #include<iostream>
  2 using namespace std;
  3 
  4 //普通页面实现
  5 
  6 /*
  7 //Java页面
  8 class Java
  9 {
 10 public:
 11     void header()
 12     {
 13         cout << "首页、公开课、登录、注册……(公共头部)" << endl;
 14     }
 15 
 16     void footer()
 17     {
 18 
 19         cout << "帮助中心、交流合作、站内地图……（公共底部）" << endl;
 20     }
 21     void left()
 22     {
 23         cout << "Java、Python、C++……（公共分类列表）" << endl;
 24     }
 25     void content()
 26     {
 27         cout << "Java学科视频" << endl;
 28     }
 29 };
 30 
 31 //Python
 32 class Python
 33 {
 34 public:
 35     void header()
 36     {
 37         cout << "首页、公开课、登录、注册……(公共头部)" << endl;
 38     }
 39 
 40     void footer()
 41     {
 42 
 43         cout << "帮助中心、交流合作、站内地图……（公共底部）" << endl;
 44     }
 45     void left()
 46     {
 47         cout << "Java、Python、C++……（公共分类列表）" << endl;
 48     }
 49     void content()
 50     {
 51         cout << "Python学科视频" << endl;
 52     }
 53 };
 54 
 55 //C++页面
 56 class CPP
 57 {
 58 public:
 59     void header()
 60     {
 61         cout << "首页、公开课、登录、注册……(公共头部)" << endl;
 62     }
 63 
 64     void footer()
 65     {
 66 
 67         cout << "帮助中心、交流合作、站内地图……（公共底部）" << endl;
 68     }
 69     void left()
 70     {
 71         cout << "Java、Python、C++……（公共分类列表）" << endl;
 72     }
 73     void content()
 74     {
 75         cout << "C++学科视频" << endl;
 76     }
 77 };
 78 
 79 
 80 
 81 void test01()
 82 {
 83     cout << "Java下载视频页面如下: " << endl;
 84     Java ja;
 85     ja.header();
 86     ja.footer();
 87     ja.left();
 88     ja.content();
 89 
 90     cout << "-----------------------------" << endl;
 91     cout << "Python下载视频页面如下: " << endl;
 92     Python py;
 93     py.header();
 94     py.footer();
 95     py.left();
 96     py.content();
 97 
 98     cout << "-----------------------------" << endl;
 99     cout << "C++下载视频页面如下: " << endl;
100     CPP cpp;
101     cpp.header();
102     cpp.footer();
103     cpp.left();
104     cpp.content();
105 
106 }
107 */
108 
109 
110 //继承实现页面
111 
112 //公共页面类
113 class BasePage
114 {
115 public:
116     void header()
117     {
118         cout << "首页、公开课、登录、注册……(公共头部)" << endl;
119     }
120 
121     void footer()
122     {
123 
124         cout << "帮助中心、交流合作、站内地图……（公共底部）" << endl;
125     }
126     void left()
127     {
128         cout << "Java、Python、C++……（公共分类列表）" << endl;
129     }
130 
131 };
132 
133 //继承的好处：减少重复代码
134 //语法： class 子类 : 继承方式 父类
135 //子类 也称为 派生类
136 //父类 也称为 基类
137 
138 //Java页面
139 class Java :public BasePage
140 {
141 public:
142     void content()
143     {
144         cout << "Java学科视频" << endl;
145     }
146 
147 };
148 //Python页面
149 class Python :public BasePage
150 {
151 public:
152     void content()
153     {
154         cout << "Python学科视频" << endl;
155     }
156 
157 };
158 //C++页面
159 class CPP :public BasePage
160 {
161 public:
162     void content()
163     {
164         cout << "CPP学科视频" << endl;
165     }
166 
167 };
168 
169 
170 void test01()
171 {
172     cout << "Java下载视频页面如下: " << endl;
173     Java ja;
174     ja.header();
175     ja.footer();
176     ja.left();
177     ja.content();
178 
179     cout << "-----------------------------" << endl;
180     cout << "Python下载视频页面如下: " << endl;
181     Python py;
182     py.header();
183     py.footer();
184     py.left();
185     py.content();
186 
187     cout << "-----------------------------" << endl;
188     cout << "C++下载视频页面如下: " << endl;
189     CPP cpp;
190     cpp.header();
191     cpp.footer();
192     cpp.left();
193     cpp.content();
194 
195 }
196 
197 
198 int main()
199 {
200     test01();
201 
202 
203 
204     return 0;
205 }

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