公有继承 —— 学生信息类

任务描述
本关任务：采用公有继承设计学生信息类。

相关知识
继承
继承是使代码可以复用的重要手段，也是面向对象程序设计的核心思想之一。简单的说，继承是指一个对象直接使用另一对象的属性和方法。

C++ 中的继承关系就好比现实生活中的父子关系，继承一笔财产比白手起家要容易得多，原始类称为基类，继承类称为派生类，基类是对派生类的抽象，派生类是对基类的具体化。它们是类似于父亲和儿子的关系，所以也分别叫父类和子类。而子类又可以当成父类，被另外的类继承。

继承方式
不同的继承方式决定了基类成员在派生类中的访问属性，主要体现在：

派生类成员对基类成员的访问权限；

通过派生类对象对基类成员的访问权限。

对于派生类的成员或者派生类对象访问自己类的成员不讨论，跟一般类一样，下面只讨论对基类的成员的访问。

公有继承：基类的 public 和 protected 成员访问属性在派生类中保持不变；基类的 private 成员不可直接访问。

保护继承：基类的 public 和 protected 成员都以 protected 身份出现在派生类中；基类的 private 成员不可直接访问。

私有继承：基类的 public 和 protected 成员，都以 private 身份出现在派生类中；基类的 private 成员不可直接访问。

可以看出无论采用何种继承方式得到的派生类，派生类成员及其友元都不能访问基类的私有成员。且一般情况，保护继承与私有继承在实际编程中极少使用，它们只在技术理论上有意义。

公有继承
公有继承是访问性最高的一种继承，在子类中能完整延续父类成员的访问性，而且对外可见。如果要公有继承一个类，只需继承时在类名前面加上 public 关键字即可。

在公有继承中，派生类成员可以访问继承的基类的 public 部分与 protected 部分，但是不能访问 private 部分，只有基类成员以及基类的友元可以访问 private 部分。

例如：

class Base
{
public:
int A;
};
class D1 : public Base // 公有继承 Base 类
{
/* …… */
};
int main()
{
D1 d;
d.A = 10; // 访问 D1 的基类 Base 中的 A 成员，因为是公有继承，所以没问题
}
编程要求
在右侧编辑器中的Begin-End之间补充代码，设计 Student 类，并实现 Set 和 PrintSID 函数，具体要求如下：

Student 类公有成员函数：void PrintSID()，函数输出成员变量 SID 的值，输出格式为：学号：SID。

普通函数：Set(int sid,string name,Student *ptr)，它用前两个参数设置 ptr 对象的 SID 和 Name（继承 People 拥有的属性）属性值。

现在已有一个基类 People，它有一个公有成员变量姓名 Name，一个公有成员函数 PrintName（函数的功能是打印出 Name 的值）。

class People
{
public:
string Name;
void PrintName();
};
void People::PrintName()
{
cout << “姓名：” << Name << endl;
}

usr.h

#include "people.h"     // People 类定义在这里面
#include <string>
#include <iostream>using namespace std;/**********  Begin **********/
//公有继承 People
class Student:public People
{public:int SID;void PrintSID();
};
/**********  End **********/void Student::PrintSID()
{/********* Begin *********///输出 SIDcout << "学号：" << SID << endl;/********* End *********/
}void Set(int sid,string name,Student *ptr)
{/********* Begin *********///给 ptr 对象的两个属性赋值ptr->SID = sid;ptr->Name = name;/********* End *********/
}

people.h

#ifndef PEO_H_
#define PEO_H_#include<string>
#include<iostream>
using namespace std;class People
{public:string Name;void PrintName();
};void People::PrintName()
{cout << "姓名：" << Name << endl;
}
#endif

main.cpp

#include "usr.h"int main()
{int id; string name;cin >> id >> name ;Student st;Set(id,name,&st);st.PrintSID();st.PrintName();
}

保护继承 —— 学生信息类

任务描述
本关任务：采用保护继承设计学生信息类。

相关知识
为了完成本关任务，你需要掌握保护继承的使用。

保护继承
保护继承相对于公有继承，访问性有所降低，父类的公有成员在子类中变成了保护成员，也就无法在外部通过一个对象访问父类成员了，但是对于这个子类的子类仍然是可见的（因为可见性只是降到了 protected ）。

如果要保护继承一个类，只需继承时在类名前面加上 protected 关键字即可。

例如：

class Base
{
public:
int A;
};
class D1 : protected Base // 保护继承 Base 类
{
/* …… */
};
int main()
{
D1 d;
d.A = 10; // 尝试访问 D1 的基类 Base 中的 A 成员，但是由于是保护继承，所以这样做是错误的。
}
在保护继承中如果想通过子类访问父类的成员，那就只能在子类中增加一些 get 、set 函数来实现了。

例如：

/* Base类的定义同上 */
class D1 : protected Base
{
public:
void SetA(int a); // 设置 Base 类中 A 的值
int GetA(); // 获取 Base 类中 A 的值
};
void D1::SetA(int a)
{
A = a;
}
int D1::GetA()
{
return A;
}
int main()
{
Student st;
st.SetA(10); // 将 Base 类的 A 成员设置为 10
}
编程要求
在右侧编辑器中的Begin-End之间补充代码，采用保护继承设计学生信息类，并实现 Set 和 PrintSID 函数，具体要求如下：

Student 类公有成员函数：void PrintSID()，函数输出成员变量 SID 的值，输出格式为：学号：SID。

普通函数：Set(int sid,string name,Student *ptr)，它用前两个参数设置 ptr 对象的 SID 和 Name（继承 People 拥有的属性）属性值。

现在已有一个基类 People，它有一个公有成员变量姓名 Name，一个公有成员函数 PrintName（函数的功能是打印出 Name 的值）。

class People
{
public:
string Name;
void PrintName();
};
void People::PrintName()
{
cout << “姓名：” << Name << endl;
}
usr.h

#include "people.h"     // People 类定义在这里面
#include <string>
#include <iostream>
using namespace std;/**********  Begin **********/
//保护继承 People
class Student : protected People
{public:int SID;void PrintSID();//添加一个 Set 函数来设置父类的 Name 成员friend void Set(int sid,string name,Student *ptr);};/********* End *********/void Student::PrintSID()
{/********* Begin *********///输出学号 SIDcout << "学号：" << SID << endl;/********* End *********/
}void Set(int sid,string name,Student *ptr)
{/********* Begin *********///给 ptr 对象的两个属性赋值ptr->SID=sid;ptr->Name=name;/********* End *********/
}

people.h

#ifndef PEO_H_
#define PEO_H_#include<string>
#include<iostream>
using namespace std;class People
{public:string Name;void PrintName();
};void People::PrintName()
{cout << "姓名：" << Name << endl;
}
#endif

run.cpp

#include "usr.h"int main()
{int id; string name;cin >> id >> name ;Student st;Set(id,name,&st);st.PrintSID();((People*)&st)->PrintName();
}

研究生信息类

任务描述
本关任务：采用私有继承完成学生信息类和研究生信息类的设计。

相关知识
为了完成本关任务，你需要掌握私有继承的使用。

私有继承
私有继承在保护继承的基础上更进一步，访问性进一步降低，父类中的公有成员和保护成员的访问性均降到了私有 private，不仅对外不可见，对这个类的子类也不可见了。

要私有继承一个类，只需继承时在类名前面加上 private 关键字即可。

例如：

/* 继承关系：Base->D1->D2 */
class Base
{
public:
int A;
};
class D1 : private Base // 私有继承 Base 类
{
public:
F1();
};
void D1::F1()
{
A = 10; // 父类的成员 A 可以看做 D1 类的私有成员，在 D1 类中访问 A 是可行的
}
class D2 : public D1 // 公有继承 D1
{
public:
F2();
};
void D2::F2()
{
A = 10; // 这里就不行了，因为 D1 类私有继承了 Base 类，所以 Base 类的 A 成员对 D2 类就是不可见的。
}
同样，如果想在某个类的外部或者它的子类中访问它私有继承的基类的成员，那也只能在这个类中增加 get、set 方法了。

例如：

/* Base类的定义同上 /
/ 继承关系：Base->D1->D2 */
class D1 : private Base
{
public:
void SetA(int a); // 设置 Base 类中 A 的值
int GetA(); // 获取 Base 类中 A 的值
};
void D1::SetA(int a)
{
A = a;
}
int D1::GetA()
{
return A;
}
class D2 : public D1 // 公有继承 D1 类
{
public:
void F2();
}
void D2::F2()
{
SetA(10); // 调用 D1 类的 SetA 公有方法设置 Base 类 A 的值
}
编程要求
在右侧编辑器中的Begin-End之间补充代码，设计学生信息类（ Student ）和设计研究生信息类（ Graduate ），Graduate 类公有继承 Student 类，而 Student 类私有继承 People 类，并实现他们的成员函数以及一个普通函数，具体要求如下：

Graduate 类
增加一个成员变量研究方向：int ResearchID，以及一个成员函数：void PrintResearchID()，函数用来输出 ResearchID 的值，输出格式为：研究方向：ResearchID。

Student 类
补充有成员函数：void PrintSID()，函数输出成员变量 SID 的值，输出格式为：学号：SID。

普通函数：Set(int sid,int rid,string name,Graduate *ptr)函数，它用前三个参数设置 ptr 所指对象的三个成员。
People 基类，它有一个公有成员变量姓名 Name，一个公有成员函数 PrintName（函数的功能是打印出 Name 的值），代码如下：

/* 继承关系：People->Student->Graduate */
class People
{
public:
string Name;
void PrintName();
};
void People::PrintName()
{
cout << Name << endl;
}

usr.h

#include "people.h" //People类定义在这里面
#include <string>
#include <iostream>
using namespace std;/********* Begin *********/
//私有继承 People 类
class Student:private People
{public:int SID;void PrintSID();//添加一个 Set 函数来设置父类的 Name 成员void SetName(string name){Name=name;};};/********* End *********/void Student::PrintSID()
{/********* Begin *********///输出学号 SIDcout << "学号：" << SID << endl;/********* End *********/
}/********* Begin *********/
// 公有继承 Student 类
class Graduate:public Student
{public:int ResearchID;void PrintResearchID();//添加一个 Set 函数来设置父类的 SID 成员friend void Set(string name,int sid,int rid,Graduate *ptr); //添加一个 Set 函数来调用父类的 SetName 函数void set(string name){SetName(name);};
};/********* End *********/void Graduate::PrintResearchID()
{/********* Begin *********///输出研究方向 ResearchIDcout<<"研究方向："<<ResearchID<<endl;/********* End *********/
}void Set(string name,int sid,int rid,Graduate *ptr)
{/********* Begin *********///设置 ptr 所指对象的三个成员ptr->set(name);ptr->SID=sid;ptr->ResearchID=rid;/********* End *********/
}

people.h

#ifndef PEO_H_
#define PEO_H_
#include<string>
#include<iostream>
using namespace std;class People
{public:string Name;void PrintName();
};void People::PrintName()
{cout << "姓名：" << Name << endl;
}
#endif

main.cpp

#include "usr.h"int main()
{int i,j;string name;cin >> i >> j >> name;Graduate st;Set(name,i,j,&st);((Student*)&st)->PrintSID();((People*)&st)->PrintName();st.PrintResearchID();
}

狼人类

任务描述
本关任务：采用多继承设计一个狼人类。

相关知识
在前面的关卡中，我们学习的派生类都只有一个基类，称为单继承。除此之外，C++ 也是支持多继承的，即一个派生类可以有两个或多个基类。下面我们就一起来学习多继承的使用。

多继承
C++ 语言支持一个子类同时继承多个父类，就像单继承时一样，继承多个父类也就相当于同时有了多个父类的公有成员和保护成员，而且可以单独为每一个父类指定继承的方式。

因此多继承的优点说可以使一个类实现多个接口，而缺点使容易造成混淆。

如果要继承多个类，只需将父类的类名依次写在子类类名的冒号（:）后面，基类名之间用逗号（,）隔开，每一个基类名前面带上它的访问性关键字。即多继承声明语法如下：

class 派生类名 : 访问控制基类名1, 访问控制基类名2, …
{
成员变量和成员函数的声明
};
例如：

/* 继承关系：BaseA->D，BaseB->D /
class BaseA
{
public:
int A;
};
class BaseB
{
public:
int B;
};
class D : public BaseA , public BaseB // 公有继承 BaseA 和 BaseB
{
/ 其他成员 */
};
int main()
{
D d;
d.A = 10; // 给来自 BaseA 类的成员 A 赋值
d.B = 10; // 给来自 BaseB 类的成员 B 赋值
}
多继承访问基类成员
多继承访问基类成员大体与单继承一致，但当继承的多个父类中有同名的成员时，要访问其中一个成员就不能简单的只写成员名了，必须使用作用域运算符（::）来指定是哪一个类的成员。

例如：

/* 继承关系：BaseA->D，BaseB->D /
class BaseA
{
public:
int A;
};
class BaseB
{
public:
int A; // 与 BaseA 的 A 成员同名了
};
class D : public BaseA , public BaseB / /公有继承 BaseA 和 BaseB
{
/ 其他成员 */
};
int main()
{
D d;
d.BaseA::A = 10; // 使用作用域运算符，给来自 BaseA 类的成员 A 赋值
d.BaseB::A = 10; // 使用作用域运算符，给来自 BaseB 类的成员 A 赋值
}
编程要求
在右侧编辑器中的Begin-End之间补充代码，实现三个类的设计，其中成员变量和成员函数的访问性可自行设置，具体要求如下：

狼类（ Wolf ）

成员变量姓名：string Name

成员变量爪子锋利度：int Shape

成员函数：void PrintState()，按照姓名爪子锋利度格式输出两个成员变量的值。

人类（ Human ）

成员变量姓名：string Name

成员变量智力：int Intell

成员函数：void PrintState()，按照姓名智力格式输出两个成员变量的值。

狼人类（ Werewolf ），它继承狼类和人类

成员函数：void SetName(string name)，函数用来设置两个基类的成员变量姓名。

成员函数：void SetState(int shape,int intell)，函数用 shape 、intell 两个参数分别设置狼类的爪子锋利度和人类的智力。

成员函数：void PrintAllState()，函数按照狼类，人类的顺序调用两个基类的 PrintState 函数，输出他们的成员变量值。

usr.h

#include <string>
#include <iostream>using namespace std;/********* Begin *********/
class Wolf
{//狼类成员的声明
public:string Name;int Shape;void PrintState();};
//狼类成员的定义void Wolf::PrintState()
{cout<< "姓名："<<Name<<"，爪子锋利度为："<<Shape<<endl;
}class Human
{//人类成员的声明public:string Name;int Intell;void PrintState();};
//人类成员的定义void Human::PrintState()
{cout<< "姓名："<<Name<<"，智力为："<<Intell<<endl;}// 记得在这里写上要继承的类
class Werewolf : public Wolf,public Human
{//狼人类成员的声明
public:void SetName(string name);void SetState(int shape,int intell);void PrintAllState();};
//狼人类成员的定义void Werewolf::SetName(string name)
{Wolf::Name=name;Human::Name=name;
}
void Werewolf::SetState(int shape,int intell)
{Shape=shape;Intell=intell;
}
void Werewolf::PrintAllState()
{Wolf::PrintState();Human::PrintState();
}/********* End *********/

run.cpp

#include "usr.h"int main()
{int i,j;string name;cin >> i >> j >> name;Werewolf ww;ww.SetName(name);ww.SetState(i,j);ww.PrintAllState();
}

人与复读机

任务描述
本关任务：设计人类、英语学生类和复读机类三个类。

相关知识
为了完成完成本关任务，你需要掌握虚函数的基本使用。

多态性
在面向对象的方法中，多态性是指向不同对象发送同一个消息，不同对象在接收时会产生不同的行为（方法）。

通俗点说就是可以不用像 C 语言中为了求多种图形的面积而针对不同的图形各设计一个独立名字的函数，在 C++ 中只要设计一个专门用于求面积的函数名即可。这个专门用于求面积的函数名可以作为各种求图形面积的函数名。

这么做的好处在于程序设计者可以省去设立多个函数名对应多个函数的麻烦，使用的时候统一用同一个函数名就可调用具有不同功能的函数。

多态在 C++ 中的实现可以是函数的重载、运算符的重载和虚函数，本实训我们介绍虚函数的使用。

虚函数
我们知道在同一个类中是不能定义两个名字相同、参数个数和类型完全相同的函数，否则就是重复定义。但是在类的继承层次结构中，在不同的层次中可以出现名字相同、参数个数和类型相同而功能不同的函数。这时系统会根据同名覆盖的原则决定调用的对象。

那么有没有一种方法，用同一种调用形式，既能调用派生类又能调用基类的同名函数？即不通过不同的对象名去调用不同派生层次中的同名函数，而是通过指针调用它们，虚函数就是用来解决这个问题的。

虚函数是一种动态的重载方式。虚函数的作用是允许在派生类中重新定义与基类同名的函数，并可以通过基类指针或引用来访问基类和派生类中同名函数。

C++ 中要声明一个成员函数为虚函数，只需要在函数的声明前加上一个关键字 virtual 即可，然后就像对待普通成员函数那样，给它加上定义。

例如：

class Base
{
public:
virtual void VFunc(); // 声明一个虚函数
};
void Base::VFunc()
{
cout << “虚函数” << endl;
}
重写父类虚函数
当一个类继承了一个含有虚函数的类，子类就可以选择是否要对父类的虚函数进行重写。所谓重写，就是覆盖父类中的定义，提供一个自己的定义。当然也可以选择不重写，那么就沿用父类的定义。

要重写一个虚函数，需要增加一条与要重写的函数相同（参数与返回值）的函数声明，然后在声明后面加上说明符 override。

例如：

/* Base类的声明同上 */
class D1 : public Base // 继承 Base 类
{
public:
void VFunc() override; // 重写 VFunc 函数
};
void D1::VFunc()
{
cout << “覆盖父类实现” <<endl;
}
int main()
{
D1 b;
b.VFunc();
}
输出结果为：覆盖父类实现

在子类中重写虚函数时是可以重新定义访问性的，即使父类中虚函数的访问性为 private，在子类中仍然可以重写为 public。如果子类想要访问被重写的父类的定义，同样使用作用域运算符（::）即可。

例如：

/* Base类的声明同上 */
class D1 : public Base // 继承 Base 类
{
public:
void VFunc() override; // 重写 VFunc 函数
};
void D1::VFunc()
{
Base::VFunc(); // 调用父类的定义
cout << “覆盖父类实现” <<endl;
}
int main()
{
D1 b;
b.VFunc();
}
输出结果为：

虚函数
覆盖父类实现
编程要求
在右侧编辑器中的Begin-End之间补充代码，设计人类、英语学生类和复读机类三个类，具体要求如下：

人类（ Chinese ）

它有一个虚函数 greet，函数输出中文问候，即你好。
英语学生类（ EnglishLearner ）

继承 Chinese 类，重写 greet 函数，访问性为 public，输出英文问候，即Hello。
复读机类（ Repeater ）

继承 Chinese 类，以 public 访问性重写 greet 函数，函数调用 Chinese 类的 greet 函数。

#include <iostream>
using namespace std;/********* Begin *********/
class Chinese
{//人类的声明
public:virtual void greet();};
//人类的定义
void Chinese::greet()
{cout<<"你好"<<endl;
}class EnglishLearner : public Chinese
{//英语学生类的声明public:void greet() override;};
//英语学生类的定义void EnglishLearner::greet()
{cout<<"Hello"<<endl;
}class Repeater : public Chinese
{//复读机类的声明
public:void greet() override;};
//复读机类的定义void Repeater::greet()
{Chinese::greet();
}/********* End *********/

.cpp

#include "usr.h"int main()
{Chinese ce;EnglishLearner le;Repeater re;ce.greet();le.greet();re.greet();
}

复读机的毁灭

任务描述
本关任务：设计三个复读机类并实现一个普通函数。

相关知识
为了完成本关任务，你需要掌握虚析构函数的使用。

多态性的体现
C++ 允许将一个对象的指针赋值给它的父类指针变量。而当通过父类指针调用一个虚函数时，则会调用子类中最后被重写的那个版本，这样对于同一段通过指针调用某个虚函数的代码，就会因为实际指向的对象不同，而调用不同函数，这就是所谓的多态性。

同理，通过引用调用一个虚函数，也会有这样的效果。

例如：

class Base
{
public:
virtual void Cal(int a,int b);
};
void Base::Cal(int a, int b)
{
cout << a * b << endl; // 默认是乘法
}
class Add : public Base
{
public:
void Cal(int a,int b) override;
};
void Add::Cal(int a,int b)
{
cout << a + b << endl; // 实现一个加法
}
class Sub : public Base
{
public:
void Cal(int a,int b) override;
};
void Sub::Cal(int a,int b)
{
cout << a - b << endl; //实现一个减法
}
//普通函数
void call(Base *ptr)
{
ptr->Cal(10,10); // 通过指针调用虚函数
}
int main()
{
Add ad;
call(&ad);
Sub sb;
call(&sb);
}
输出结果为：

20
0
可以看到，连续两次调用 call 函数，调用的效果有所不同。第一次调用的是对象是 Add，因此实现的是加法，即10+10=20；而第二次的调用对象是 Sub，实现的则是减法，即10-10=0。

虽然 C++ 也允许将子类对象直接赋值给父类变量，但是这样做会导致子类被切割成父类对象，丢失了子类的成分，这时调用虚函数，也就不会调用到被子类的重写的版本了。

例如：

/* 类的定义同上 */
void call(Base b) // 这里不使用指针
{
b.Cal(10,10);
}
int main()
{
Add ad;
call(ad); // Add 子类赋值给 Base 父类变量
Sub sb;
call(sb); // Sub 子类赋值给 Base 父类变量
}
输出结果为：

100
100
如果子类对象赋值给父类变量，则使用该变量时只能访问子类的父类部分（因为子类含有父类的部分，所以不会有问题）。因此无论哪个对象在调用 Call 函数时都是调用的父类的成员函数，所以输出结果都为100，即10*10=100。

虚析构函数
如果一个父类的析构函数没有声明成虚函数，那么使用 delete 运算符销毁一个父类指针所指的子类对象时，就只会调用父类的析构函数，子类的析构函数则不会被调用，这样就可能导致子类动态分配的资源无法及时回收，造成资源泄露。

例如：

class Base
{
public:
~Base(); // 析构函数不是虚函数
};
Base::~Base()
{
cout << “父类析构函数” << endl;
}
class D : public Base
{
public:
int *Ptr;
D();
~D();
};
D:

C++面向对象 - 继承、派生和多态相关推荐

Python之面向对象继承和派生
Python之面向对象继承和派生什么是继承: 继承是一种创建新的类的方法.在Python中,新建的类可以继承自一个或多个父类.原始类称为基类或超类. 新建的类称为派生类或子类. Python中类的继 ...
Python类与对象最全总结大全（类、实例、属性方法、继承、派生、多态、内建函数）
目录面向对象编程常用术语/名词解释抽象/实现封装/接口合成派生/继承/继承结构泛化/特化多态自省/反射访问限制私有属性和公有属性私有方法的设置类创建类声明与定义类属性 ...
day08_面向对象继承多态Object
面向对象_day03 学习目标: 1. 熟练掌握面向对象---继承 2. 熟练使用访问权限修饰符 3. 熟练掌握super关键字 4. 熟练掌握Object类 5. 熟练掌握面向对象---多态特性视 ...
python中的继承有什么特点_Python中什么是面向对象-继承和多态
文字有点长,对于不想看文字的朋友,可以去这里看视频,内容和这个文字一样的,视频可能更好理解 https://www.piqizhu.com/v/zaX9K4pd4GE 上一篇文章<python教 ...
笔记整理3----Java语言高级（三）11 综合练习+12 面向对象-static变量与代码块+13 面向对象-继承与抽象类+14 面向对象-接口与多态+15 面向对象-包修饰符
11 综合练习+12 面向对象-static变量与代码块+13 面向对象-继承与抽象类+14 面向对象-接口与多态+15 面向对象-包&修饰符第11天综合练习今日内容介绍 综合练习 ...
面向对象——继承与派生
继承与派生继承与派生的概念区分继承和组合从模块累积的角度来说,大模块是由无数个小模块构成的.构建一个模块的方式有两种,一是小模块架构组合成为大模块,二是小模块继承生成大模块. 模块可以通 ...
面向对象---继承/封装/多肽
1. 继承比较官方的说法就是: 继承(英语:inheritance)是面向对象软件技术当中的一个概念. 如果一个类别A"继承自"另一个类别B,就把这个A称为"B的子类别 ...
2021-11-09 C++封装继承多态---继承语法、多态语法、文件操作（附代码理解）
6 继承 6.1继承的基本语法例如我们看到很多网站中,都有公共的头部,公共的底部,甚至公共的左侧列表,只有中心内容不同,接下来我们分别利用普通写法和继承的写法来实现网页中的内容,看一下继承存在的意义 ...
允许使用抽象类类型 isearchboxinfo 的对象_Java面向对象编程三大特征 - 多态
Java面向对象编程三大特征 - 多态本文关键字:Java.面向对象.三大特征.多态多态是面向对象编程的三大特征之一,是面向对象思想的终极体现之一.在理解多态之前需要先掌握继承.重写.父类引用指向 ...
面向对象 - 继承/组合 - 总结
面向对象 - 继承:1.继承: 类与类之间的关系什么是什么的关系 eg:人是动物狗是动物功能: 解决代码重用问题, 创建新类的方式, 类: 可继承一个或多个父类: 父类 == 基类/超类类 = ...

C++面向对象 - 继承、派生和多态

公有继承 —— 学生信息类

保护继承 —— 学生信息类

研究生信息类

狼人类

人与复读机

复读机的毁灭

C++面向对象 - 继承、派生和多态相关推荐

最新文章

热门文章