《C++面向对象程序设计导论》-从抽象到编程 课件 04 继承与多态

类与继承及编程实现《C++面向对象程序设计导论:从抽象到编程》第4章继承与多态分类与继承8.2教师录入成绩的视图4.2.1继承的概念4.1分类与抽象4.2.2继承的编程实现4.2继承本节学习目标能够运用包含运算等集合知识解释继承及相关概念能够运用分类及其标准等知识解释如何抽象继承能够使用C++编程实现继承4.1分类与抽象分类是人们认识和理解客观世界的基本方法，也是形成各种概念的基础。概念有内涵和外延，根据概念可设计出类，根据概念的内涵可设计出类的属性或方法。在认识和理解客观事物过程中，分类和抽象往往是联系在一起的，是人们认识和理解客观事物的两个步骤。4.1分类与抽象按照人的性别特性进行分类后，得到了人、男人和女人三个集合，其中人的集合包含了男人的集合，也包含女人的集合。平时说的，男人是人，女人也是人，就是这层意思，当然，也可以使用类图描述其含义，人与男人和女人的类图。图中的空心箭头（注意是空心箭头）表示集合之间的包含关系。在面向对象中，将母集到子集的关系称为继承(Inherit)，也将子集到母集的关系称为一般化(Generalization)。4.1分类与抽象

认识客观世界时，人们往往从不同的角度认识客观世界中的事物，通过不同的标准对观察事物进行分类，也会进行层层分类，最终将事物划分到容易把握的粒度。例如，可从人类社会的角度，按照人的职业对人进行分类，将人分为学生和教师，再按照受教育的阶段将学生分为小学生、中学生和大学生，又将大学生分为本科学生和研究生，本科学生再分为工科学生和非工科学生，最终形成一个层次关系。其层次关系如图所示。

分类的好处是，能够专注于解决某类事物的共性问题。如何使用集合描述层次关系？4.2.1继承的概念继承（Inherit）是面向对象中最重要的概念之一，用于描述事物类别之间的包含关系，是面向对象设计和实现的核心支柱。具体到面向对象中，继承是类之间的一种关系，表示一个类所代表的集合包含另一个类所代表的集合。在一个继承关系中将代表母集的类称为父类(ParentClass)，代表子集的类称为子类(ChildClass)，将父类到子类称为继承。ParentClassChildClass4.2.1继承的概念与一个家族的家谱类似，每个类有一个父类，但可以允许有多个子类。一个（基）类可以有多个子类，这些子类也称为该类的派生类，每个子类都可以派生出多个子类，一直延续下去，最终可以形成一颗树的结构。为了交流方便，将一个类派生出的所有类统称为派生类，而这个类称为所有派生类的祖先。

可以这样说，类的继承机制就是借鉴传统的家族图谱设计的。4.2.2继承编程的实现按照继承的概念，子类要继承父类的属性和方法，换句话说，子类的对象包含了父类的对象，在创建一个子类的对象时，先构造父类的对象再构造自己，子类的对象包含了父类对象的内存和自己的内存。如图所示，只有一个继承关系，父类ParentClass只有一个属性和一个构造函数，子类ChildClass有一个属性和两个构造函数。4.2.2继承的编程实现#include

<iostream>using

namespacestd;class

ParentClass{public:

ParentClass(inta);protected:int

parentAttribute;};ParentClass::ParentClass(inta){cout<<"ParentClass的首地址："

<<this<<endl;

parentAttribute=a;}class

ChildClass:public

ParentClass{public:

ChildClass(int

pA,double

cA);

ChildClass(const

ChildClass&oldChildClass);protected:double

childAttribute;};ChildClass::ChildClass(int

pA,double

cA):

ParentClass(pA){cout<<"ChildClass的首地址："<<this<<endl;

childAttribute=cA;}ChildClass::ChildClass(const

ChildClass&oldChildClass):

ParentClass(oldChildClass.parentAttribute){

childAttribute=oldChildClass.childAttribute;}ParentClass.cppChildClass.cpp4.2.2继承的编程实现class

ChildClass:public

ParentClass

冒号指明了ChildClass的父类是ParentClass，其中的关键字public说明是公开继承，其语义为，从父类ParentClass继承属性和方法，子类ChildClas全部传承给其子类，没有增加限制，没有截留。ChildClass::ChildClass(int

pA,double

cA):ParentClass(pA)使用了冒号语法说明按照语句ParentClass(pA)调用父类ParentClass的构造函数，与初始化对象成员的代码非常相似，但需要注意的是，初始化父类对象时使用的是类名，而初始化对象成员时使用的是属性名。4.2.2继承编程的实现创建子类对象的步骤如下：1、在子类进行实例化的时候仅为子类对象分配一个内存空间，不会专门构造父类的无

名对象为父类分配空间。2、定义实例变量，分为两步，首先在子类对象的内存空间，执行父类实例变量的定义

并赋默认值，然后执行子类的实例变量定义，并赋默认值。3、执行初始化代码，为实例变量赋初始值。初始化代码一般就是构造函数。也分为两

步，先执行父类的实例初始化代码（构造函数）为父类的实例变量赋初始值，执行

子类的实例初始化代码（构造函数）为子类的实例变量赋初始值。4、一个子类在实例化之后，在它的对象的实例变量里包含它的父类所定义的实例变量。练习使用集合表示继承关系的语义使用时序图描述程序的执行过程使用对象图描述创建的对象及其内部结构上机调试【例4.1】继承的实现，要求：总结及进一步学习思维：分类思想设计：使用类图描述继承关系编码：使用C++描述类及继承关系调试：使用时序图描述子类对象的创建过程，使用对象图描述子类对象的内部结构4.2.3-4.2.4描述类之间的层次进一步学习4.2继承4.2继承8.2教师录入成绩的视图4.2.4保护继承与私有继承4.2.1继承的概念4.2.3描述类之间的层次学习目标能够使用继承描述类之间的层次关系能够使用组合关联（连接）描述派生类（对象）的内部结构能够使用公有、保护和私有继承进行控制访问（对祖先成员）4.2.3描述类间的层次

分层思想能让解决问题变得更加简单，而使用继承描述类之间的层次，也能让代码结构简单清晰，更容易读懂，也让编程变得简单，因此，要有信心编写比较复杂的程序。

提问：

1、Student和Teacher，与类Person之间的关系？2、GraduateStudent与类Student之间的关系？3、GraduateStudent与Teacher之间的的关系？4.2.3描述类间的层次#include

"Tdate.h"#include

“myString.h"class

Person{public:Person(const

char*pName,const

Tdate &tBirthday,boolbSex);Person(const

Person&oldPerson);voidprint();protected:myString

name;Tdate

birthday;bool

sex;};#include

"Person.h"#include

<iostream>using

namespacestd;Person::Person(const

char*pName,const

Tdate &tBirthday,boolbSex):name(pName),birthday(tBirthday){sex=bSex;}Person::Person(const

Person&oldPerson):name(oldPerson.name),birthday(oldPerson.birthday){sex=oldPerson.sex;}voidPerson::print(){name.print();cout<<",";birthday.print();cout<<","<<(sex?"男":"女")<<endl;}类Person的声明中，使用了自定义的数据类型Tdate和myString，需要引入其头文件"Tdate.h"和"myString.h。类Person的声明中，使用了自定义的数据类型Tdate和myString，需要引入其头文件"Tdate.h"和"myString.h。Person.hPerson.cpp4.2.3描述类间的层次#include

"Person.h"class

Student:public

Person{public:Student(const

char*pName,const

Tdate &tBirthday,boolbSex,floatfCredit);Student(const

Student&oldStudent);voidprint(void);protected:float

credits;//学分};#include

"Student.h"#include

<iostream>using

namespacestd;Student::Student(const

char*pName,const

Tdate&tBirthday,boolbSex,floatfCredit): Person(pName,tBirthday,bSex){credits=fCredit;}Student::Student(const

Student&oldStudent): Person(oldStudent){credits=oldStudent.credits;}voidStudent::print(){cout<<"Student:"<<endl;Person::print();cout<<","<<credits;}增加了一个数据成员credits，用于存储学生的学分。构造函数Student(constchar*pName,constTdate&tBirthday,boolbSex,floatfCredit)中，增加了参数fCredit，用于传递一个学生的学分Credit。成员函数print()中的Person::print()，输出父类Person的数据，使用格式“类名::成员”访问继承下来的父类成员。Student.hStudent.cpp4.2.3描述类间的层次#include

"Person.h"class

Teacher:public

Person{public:Teacher(const

Person&p);Teacher(const

Teacher&oldTeacher);voidprint();};#include

"Teacher.h"#include

<iostream>using

namespacestd;Teacher::Teacher(const

Person&p):Person(p){}Teacher::Teacher(const

Teacher&oldTeacher): Person(oldTeacher){}voidTeacher::print(void){cout<<"Teacher:"<<endl;Person::print();}构造函数Teacher(constPerson&p)的实现代码只有Person(p)，其调用父类Person的拷贝构造函数实现了初始化。Teacher.hTeacher.cpp4.2.3描述类间的层次4.2.3描述类间的层次//主程序#include

"GraduateStudent.h"#include

<iostream>using

namespacestd;const

boolmale=true;const

boolfemale=false;intmain(){cout<<"****创建Person对象*****"

<<endl;Personp1("张三",Tdate(8,8,2021),male);p1.print();cout<<endl<<endl<<"****创建Student对象

*****"

<<endl;Students1("李四",Tdate(8,8,2021),female,20);s1.print();

cout<<endl<<endl<<"****创建Teacher对象

*****"

<<endl;Teachert1(p1);t1.print();cout<<endl<<endl<<"****创建GraduateStudent 对象*****"

<<endl;GraduateStudentg1(s1,t1);g1.print();cout<<endl<<endl<<"****main语句结束****"

<< endl;}含main的主程序4.2.4保护继承与私有继承

继承可以公共继承，也可保护继承和私有继承。如，先封装一个基类Base，然后从基类Base派生出三子类，分别采用公共继承、保护继承和私有继承方式，最后从三个子类分别派生一个子类，都采用公共继承方式。但是Base类中不同访问特性的成员，继承下来之后，访问特性将发生变化。

在集成开发环境中编写代码，集成开发环境会及时提示，哪个数据成员能够访问，哪个不能访问。实际上，无论继承的访问控制还是成员的访问控制，只要是private，就只能自己访问；如果是protected，则派生类中都可以访问，但非派生类中不能访问。4.2.4保护继承与私有继承public1.在类成员列表之前，public关键字指定可以从任何函数访问这些成员。2.在基类的名称前面时，public关键字指定基类的公共成员和受保护成员分别是派生类的公共和受保护成员。protected1.声明为protected的类成员，只能由以下项使用：该类的成员函数该类的友元函数使用公共或者受保护访问(派生自该类)的派生类（变为子类保护成员，在子类中使用）对受保护成员具有专用访问权限的以私有方式派生的类（变为子类私有成员，在子类中使用）2.在基类的名称前面时，protected关键字指定基类的公共成员和受保护成员都是其派生类的受保护成员。private（默认）1.在类成员列表前面时，private指定只能从类的成员函数或者友元访问这些成员。2.在基类的名称前面时，private指定基类的公共成员和受保护成员是派生类的私有成员。3.类中成员的默认访问是私有的，类的继承默认也是私有继承的。4.如果基类成员为private，那么无论通过什么方式继承到子类，子类均无法访问该成员。练习1按照下图所示的类及其继承关系，直接在集成开发环境中编写代码，集成开发环境会及时提示，哪个数据成员能够访问，哪个不能访问，并总结访问控制规律。voidtest(){ ml=1; m2=2; m3=3;}练习2上机调试【例4.1-5】的代码使用对象图描述对象g1的内部结构上机调试【例4.1-5】，要求：总结及进一步学习思维：分层思想设计：使用继承描述层次关系编码：访问祖先类成员的控制技术调试：派生类对象的内容结构4.3多态进一步学习4.3多态4.3多态8.2教师录入成绩的视图4.3.3按照多态思维编写代码4.3.2多态的编程技术4.3.1多态的概念学习目标能够运用数学中的计算知识解释多态的概念能够按照多态思维设计程序能够使用虚函数等编程技术编写代码4.3.1多态的概念在实际生活中，存在这类问题，如，计算一个学生的学费。不同阶段的学生，计算他们的学费的方法是不同的，本科生的学费一般按照学分来计算，而研究生的学费一般按照学年来计算。无论是本科学生还是研究生，都是计算他们的学费，但具体计算方法确实不同。面向对象程序设计中怎样解决这个问题？4.3.1多态的概念

多态的地位？多态（Polymorphism）是面向对象（Object-Oriented，OO）思想“三大特征”之一，其余两个分别是封装（Encapsulation）和继承（Inheritance），可见多态的重要性。或者说，不懂得什么是多态就不能说懂得面向对象。

为什么要用多态？封装可以使得代码模块化，继承可以扩展已存在的代码，它们的目的都是为了代码重用。而多态的目的则是为了接口重用。

多态是一种机制、一种能力，而非某个关键字。按字面的意思就是多种形态的意思，可以说同一个函数具有多种形式，比如不同的返回值，参数，运行的内容等。4.3.1多态的概念

更一般的情况下，在进行加法运算时，首先想到的是两个数相加，具体计算时才会关心是整数相加还是实数相加。为了描述这种情况，面向对象程序设计中提出了所谓的“替代原理”。

“替代原理”的运用以方便调用函数对一棵继承树上的对象进行计算。“替代原理”的规则是，当一个对象作为函数调用的实参时，子类的对象可以替代父类的对象，但父类的对象不能替代子类的对象。替换原则：当一个软件实体可以使用某个类时，那么一定可以使用该类的子类，并且原代码并不会感觉父类与子类之间的差异。然而相反的替换却是不可以成功的。4.3.2多态的编程技术classNumber{public:

intadd(intn);

intvalue;};classReal:publicNumber{public:

intadd(intn);};classInt:publicReal{public:

intadd(intn);};针对一般情况，我们提出对多态的需求：拟定义一个通用的普通函数fAdd，参数为父类对象，调用时再传入具体的子类对象作为实参（替代原则），预期为调用对应子类的add函数。但是结果可如预期吗？（相关代码见本页与下一页）intNumber::add(intn){

cout<<"Number+Number"<<endl;returnn;}int

Int::add(intn){

cout<<"整数+整数"

<<endl;returnn;}intReal::add(intn){

cout<<"实数+实数"

<<endl;returnn;}4.3.2多态的编程技术voidfAdd(Number&op1,Number&op2){op1.add(op2.value);//调用Number::add(),Real::add(),还是Int::add()？}intmain(){cout<<"****实数的加法****"

<<endl;Realr1,r2;fAdd(r1,r2);cout<<"****整数的加法****"

<<endl;Inti1,i2;fAdd(i1,i2);}运行结果：****实数的加法****Number+Number****整数的加法****Number+Number运行结果并不如预期。那么如何才能实现多态呢？需要借助虚函数机制。4.3.2多态的编程技术为了描述和实现多态，面向对象中抽出了抽象类（AbstractClass）和虚函数（VirtualFunction）两个概念。

1、虚函数指具有多种实现方式的函数，用于描述客观世界中的多态行为。

2、抽象类指不能直接创建其对象的类。抽象类有一个本质特征，即抽象类必定有虚函数，并且虚函数中至少有一个函数没有具体实现（即纯虚函数）。4.3.2多态的编程技术将类Number及其子类中的成员函数add()设置了虚函数，将类Number设置为抽象类，并标注类Number中的成员函数add()没有实现代码。4.3.2多态的编程技术#include

<iostream>using

namespacestd;class

Number//抽象类{public:virtual

intadd(intn)=0;//纯虚函数，不需要实现int

value;};class

Real:public

Number{public:virtual

intadd(intn);//虚函数};class

Int:public

Real{public:virtual

intadd(intn);//虚函数};intInt::add(intn){cout<<"整数+整数"

<<endl;returnn;}intReal::add(intn){cout<<"实数+实数"

<<endl;returnn;}void

fAdd(Number&op1,Number&op2){//传递引用，也可传递指针op1.add(op2.value);//编译器选择调用Real::add(), 还是Int::add()}intmain(){cout<<"****实数的加法****"

<<endl;Realr1,r2;

fAdd(r1,r2);cout<<"****整数的加法****"

<<endl;Inti1,i2;

fAdd(i1,i2);}执行函数调用fAdd(r1,r2)时，函数fAdd()接收到的是类Real的对象，语句op1.add(op2.value)中，根据对象op1所属的类Real，调用类Real的add()成员函数。执行函数调用fAdd(i1,i2)时，也采用同样的方法，调用了类Int的add()成员函数，实现了多态。运行结果：****实数的加法****实数+实数****整数的加法****整数+整数4.3.3按照多态思维编写代码编写多态特征的代码时，程序员主要做的事情是，告诉编译器哪些类的哪些成员函数描述客观事物的多态行为，以及每种行为的做事方法，即编写成员函数代码，而编译器承担了选择调用哪个成员函数的任务，从而明显降低了程序员的工作量，编写的代码也更加简洁。练习上机调试通过例4.7-8中的代码使用时序图描述程序的执行流程运用多态编程技术等知识解释这个执行流程上机调试【例4.7-8】，要求：总结及进一步学习思维：多态思维设计：按照多态思维设计程序编码：虚函数、重写等多态编程技术调试：多态的实现流程4.4多重继承进一步学习4.4多重继承4.4多重继8.2教师录入成绩的视图4.2.3多重继承的编程方法4.4.1多重继承导致的问题4.4.2多重继承的实现原理学习目标能够使用对象图解释多重继承导致的问题和实现原理能够使用虚拟继承等编程技术设计程序4.4.1多重继承8.2教师录入成绩的视图4.4.1多重继承导致的问题

到目前为止，所讨论的类层次中，每个类只继承一个父辈，即，所谓的单继承，但现实世界中也存在大量从多个父辈继承的情况。面向对象中，将有多个父辈的继承称为多重继承。4.4.1多重继承导致的问题8.2教师录入成绩的视图与单继承相比，多重继承非常复杂，使用时容易出现问题，要特别小心。

平常说的沙发床，它既是沙发，也是床，可用三个类和两个继承描述沙发床。沙发和床都有重量，为描述它们的类，Bed和Sofa都设计了属性weight，也设计了成员函数提出了抽象类的虚拟继承的概念，以及实现技术4.4.1多重继承导致的额问题8.2教师录入成绩的视图

虚拟继承是多重继承中特有的概念。

虚拟基类是为解决多重继承而出现的。如:类D继承自类B1、B2，而类B1、B2都继承自类A，因此在类D中两次出现类A中的变量和函数。为了节省内存空间，可以将B1、B2对A的继承定义为虚拟继承，而A就成了虚拟基类。4.4.2多重继承实现的原理8.2教师录入成绩的视图

按照“沙发和床是家俱”的理解，为家俱设计一个类Furniture，作为类Sofa和Bed的父类，并继承设置为虚拟继承，然后，再将沙发和床的共同属性和共同行为迁移到类Furniture。类Sofa和Bed与类Furniture的继承设置为虚拟继承，表示与其它继承不同。虚拟继承的语义规定，类Furniture的属性只能被其派生类继承一次，即，类Furniture的派生类的对象中，只能包含一个类Furniture对象。4.4.3多重继承的编程方法8.2教师录入成绩的视图练习上机调试程序使用对象图描述对象ss的内部结构上机调试【例4.10】虚拟继承，要求：总结及进一步学习思维：多重继承设计：虚拟继承编码：virtual调试：多重继承的派生类结构4.5银行账户（应用举例）进一步学习学习目标能够使用时序图、类图等工具分析银行业务场景，设计出描述银行账户的类图能够以银行账户为例说明分析、设计和编码三个阶段的主要任务。能够运用已学的知识解释各个阶段所采用的主要方法。4.5应用举例：银行账户4.5银行账户8.2教师录入成绩的视图4.5.4从实现的角度进一步优化4.5.2软件设计4.5.1分析应用场景4.5.3编码实现4.5.1业务场景分析4.5.1业务场景分析发现方法4.5.1业务场景分析消除冗余4.5.2软件设计1.使用链表管理账户2.添加多态特性4.5.3编码实现//Account.hclass

Account{public:

floatDeposit(floatamount);

virtual

floatWithdrawal(floatamount)=0;

unsigned

accountNo(void);

float

acntBalance(void); Account(unsigned

accNo,float

balan); ~Account();protected:

unsigned

acntNumber;

floatbalance;

static

intcount;

Account*pNext;

static

Account*pFirst;};4.5.3编码实现//Account.cpp#include

"Account.h"#include

<iostream>using

namespacestd;

int

Account::count=0;Account*Account::pFirst=NULL;

float

Account::Deposit(float

amount){ balance+=amount;

returnbalance;}unsigned

Account::accountNo(void){

returnacntNumber;}float

Account::acntBalance(void){

returnbalance;}Account::Account(unsigned

accNo,float

balan){ acntNumber=accNo; balance=balan;

count++;

cout<<"账户数："<<count<<",增加："<<this->acntNumber<<endl; pNext=pFirst;//每新建一个结点(对象),就将其挂在链首 pFirst=this;}Account::~Account(){ count--;

cout<<"账户数："<<count<<"删除："<<this->acntNumber<<endl;

if(pFirst==this){//如果要删除链首结点,则只要链首指针指向下一个 pFirst=pNext;

return; }

for(Account*pS=pFirst;pS;pS=pS->pNext){

if(pS->pNext==this){//找到时,pS指向当前结点的结点 pS->pNext=pNext;//pNext即this->pNext

return; } }}4.5.3编码实现4.5.3编码实现Saving//Saving.h#include

"Account.h"class

Saving:public

Account{public:

virtual

floatWithdrawal(floatamount); Saving(unsignedaccNo,floatbalan);};

//Saving.cppfloat

Saving::Withdrawal(float

amount){

if(balance<amount)

cout<<"Insufficientfunds:balance"<<balance <<",withdrawal"<<amount<<endl;

else balance-=amount;

returnbalance;}Saving::Saving(unsigned

accNo,float

balan):Account(accNo,balan){}4.5.3编码实现Checking//Checking.h#include

"Account.h"

enum

Remit{remitByPost,remitByCable,other};//信汇，电汇，其他

class

Checking:public

Account{public:

virtual

floatWithdrawal(floatamount);

voidSetRemit(Remitre); Checking(unsignedaccNo,floatbalan);protected:

Remitremittance;};//Checking.cpp#include

"Checking.h"#include

"Account.h"#include

<iostream>using

namespacestd;

float

Checking::Withdrawal(float

amount){

floattemp=amount; //非信汇、电汇结算方式，则不收手续费

if(remittance==remitByPost) //若信汇，则加收30元手续费 temp=amount+30;

else

if(remittance==remitByCable) //若电汇，则加收60元手续费 temp=amount+60;

if(balance<temp) cout<<"Insufficientfunds:balance"<<balance <<",withdrawal"<<temp<<endl;

el