类的继承性
1．基类和派生类
1）继承的几个特性
若类间具有继承关系，它们应该有下列几个特性：
（1）类间具有共享特征。
（2）类间具有细微的差别。
（3）类间具有层次结构。
2）派生类的概念
引入继承的目的，是为了能使代码重用。如果可以利用已编制的程序段，将可以提高编程的效率及程序的可读性。下面通过类CPoint和类CCircle之间的关系来说明C++中类的继承性，通过继承实现了代码的重用。
class CPoint
{
private：
int color；protected：
int x，y；
public：
void show()；
void SetPosition()；}；class CCircle
{
private：
int radius；protected：
int x，y；
int width；
public：
void show()；
void SetPosition()；
double Circumfrence()；}；
类CPoint和类CCircle中的数据成员有许多是相同的，成员函数或者是完全相同的，或者是功能相同的。例如成员变量x、y在类CPoint中表示点的位置，在类CCircle中也如此。又如成员函数SetPosition()的功能是设置成员变量x和y的值，因而在两个类中代码是完全相同的，而成员函数show()在类CPoint中显示一个点，而在类CCirlce中是显示一个圆，因而show()在两个类中的功能是不一样的，其代码显然也是不一样的。由以上分析可以看到类CCircle可以由类CPoint作适当修改和扩充得到，也就是说类CCircle可以从类CPoint 继承而来，因而类CCircle可以写成如下形式，图8.2表示了此两个类的继承关系。
class CCirlce ：public CPoint
{
private ：
int radius ；
protected ：
int width ；
public ：
double Circumfrence()； void show()； }；
上面的写法中在类名CCirlce 后增加了“:public CPoint ”，说明类CCircle 是从类CPoint 继承而来的。这样，凡是在类CPoint 中已定义的成员都可以被类CCirlce 继承，因而在类CCirlce 中只定义了扩充的或将修改的成员数据或函数。CCircle 的成员除了新定义的之外，还包含了从类CPoint 中继承来的数据成员和成员函数。通常称类CPoint 是类CCirlce 的基类，或父类、上级类；称类CCircle 是类CPoint 的派生类或子类、下级类、导出类。
3） 派生类的定义
派生类的定义格式为：
class 派生类名：继承方式 基类名 {
定义派生类成员； }；
如果是多重继承，派生类的定义格式在后面叙述。
上述定义中继承方式可以是三个关键字之一：public 、private 、protected ，缺省值为private 。派生类有以下几个特点：
（1）在基类基础上提供新的成员。 （2）隐藏基类的成员。
（3）重新定义基类中的成员函数。
2． 单继承
1） 派生类对基类的继承关系
在派生类的定义中都必须指明对基类的继承方式，这将决定派生类对基类的访问性质。下面叙述派生类在三种继承方式下是如何继承基类成员的。 （1） 公有继承方式（public ）
基类中的私有成员不可访问（invisible ），所谓不可访问就是派生类无法直接使用基类中的私有成员，基类中其它成员访问权限不变。 （2） 保护继承方式（protected ）
基类中的私有成员不可访问，其它成员的访问权限都变成保护的（protected ）。 （3） 私有继承方式（private ）
基类中的私有成员不可访问，其它成员的访问权限都变成私有的（private ）。 派生类对基类的访问权限归结起来如表8.1所示。
图8.2 类的继承性
例8.1 公有继承示例
//ex8_1.cpp
#include "iostream.h"
class CBass
{
int x;
public:
void SetX(int i){x=i;}
int GetX(){return x;}
};
class CDerivate:public CBass
{
int y;
public:
void SetY(int i){y=i;}
int GetY(){return y;}
int GetXY(){return y*GetX();}
};
void main()
{
CBass a;
CDerivate b;
a.SetX(5);
b.SetX(6);
b.SetY(7);
cout< cout< } 程序运行结果为： 5 6，7，42 程序中类CDerivate是类CBass的派生类，是从类CBass公有继承而来，因而在类CDerivate中除新定义的成员外，还继承了基类CBass中的所有成员。图8.5说明了派生类CDerivate是如何继承基类CBass中的成员的，以及继承后类CDerivate中各成员的访问权限。 由图8.5可知，首先派生类全 盘继承了基类中的成员，它们在类 中构成了一个独立的块，它们的全 体称为派生类的基类子块，简称为 基类子块。显然，基类子块内的各 成员保持了原先的关系，同时它们 还要参与派生类的相关操作。基类 子块在派生类中的访问权限可由继 承方式及基类子块原先的访问权限 共同确定。根据表8.1可以重新确 定基类子块成员在派生类中的访问 权限。在本例中，由于是公有继承，基类子块中除私有成员外，其它成 员的访问权限不变，因而由继承而得到的成员函数SetX()、GetX()仍是公有的，而私有数据成员x 是不可访问的。注意：不可访问的意思是指成员变量x 虽然存在于派生类CDerivate 中，但在派生类中是不可见的，若要显示或更改成员变量x 的值，必须通过基类子块中的接口函数才行。本例程序中定义了基类CBass 的对象a 和派生类CDerivate 的对象b ，语句：“b.SetX(6)；”说明将对对象b 的数据成员x 赋值，在对象b 中没有直接定义成员函数SetX()，但它已从基类中继承而得到成员函数SetX()，该函数是公有的，因而可在主函数中直接调用，不会发生语法错误。进一步分析可以看到，成员函数b.SetX()将对不可访问的成员变量x 赋值，对于基类子块而言，SetX()就是一个公有的接口函数，因而它可以访问私有成员x 。同理b.GetX()也是个公有接口函数，因而它也可以访问私有成员x 。 2） protected 的含义 例8.3 指出程序中的语法错误 //ex8_3 #include "iostream.h" class CBass { int x; protected: int y; public: int z; void SetX(int i){x=i;} void SetY(int i){y=i;} void SetZ(int i){z=i;} }; class CDerivate:public CBass { public: void PrintX(){cout< void main() 图8.5 基类与派生类 { CBass A; CDerivate B; A.SetX(1); A.SetY(2); A.SetZ(3); cout< B.PrintX();//错误:成员函数Print()出错 B.PrintY(); B.PrintZ(); cout< 图8.7中标明了例题中基类子块成员在派生类的访问权限。 程序中主要存在以下两种语法错误： （1） 在类外直接使用了类的私有成员或不可访问成员，例如派生类的成员函数 void PrintX(){Cout< （2） 在类外直接使用了类的保护成员，例如程序中语句:"Cout< 删除出错语句，运行程序所得结果为： 3 5 6 6 本例在基类CBass 中定义了protected （保护）成员y ，y 可以在派生类CDerivate 中被使用，但在类外不可使用。在派生类成员函数 “PrintY(){Cout< 通常讲，保护成员对类内成员相当于公有成员，对类外或对象相当于私有成员。在无继承的情况下，保护成员与私有成员的性质完全一样，在存在继承的情况下，保护成员就具有了二重性，有时呈现私有成员的性质，有时呈现公有成员的性质。当讨论的重心是：派生类对象对由继承而得到的成员的访问特性(亦称水平继承)问题时，保护成员呈现为私有成员性质。当讨论的重心是：派生类成员对由继承而得到的成员的访问特性(亦称垂直水平继承)问题时，保护成员呈现为公有成员性质。上节中提出的基类子块概念能方便地处理保护成员的二重性问题。在继承情况下，通过重新确定基类子块各成员的访问性质，从而化解了因继 图8.7 例8.3中的派生类 承方式引起的问题，基类子块内各成员除因同名被屏蔽以外，其它各成员与对象的关系与无继承时的情况完全一样。唯一要注意的是这时增加了一种新的访问性质：不可访问性。 3）派生类的构造函数和析构函数 每个类中都有显式或隐式的构造函数和析构函数，创建派生类时，派生类将全盘继承基类的数据成员和成员函数，但不继承构造函数和析构函数。因而用户要么在派生类中重新定义构造函数和析构函数，要么使用系统提供的缺省构造函数和析构函数。由于派生类继承了基类的所有成员，在进行初始化时，派生类除了对自身数据成员进行初始化外，还必须对基类子块数据成员进行初始化，因而就涉及到如何在派生类中调用基类的构造函数问题。对于析构函数也有同样的问题。本节主要讨论由于继承引起的这些问题。 派生类的构造函数的一般格式如下： 派生类构造函数名（参数总表）：基类构造函数（参数表），对象成员名（参数表） { 派生类构造函数体；} 由上述格式可以看到，在派生类构造函数的初始化表中将显式调用基类构造函数，对基类子块数据成员进行初始化，如果派生类中存在对象成员，其初始化也在初始化表中进行。 析构函数是不带参数的，不存在初始化表，因而其格式与以前叙述的析构函数完全一样。在执行派生类的析构函数后，系统将自动调用基类析构函数。 派生类中构造函数的调用次序如下：基类的构造函数，成员对象的构造函数，派生类构造函数。析构函数的调用次序与构造函数的调用次序相反，依次为：派生类的析构函数，对象成员的析构函数，基类的析构函数。 例8.4 写出程序运行结果 //ex8_4.cpp #include "iostream.h" class CBass { int x; public: CBass() { x=0; cout<<"Default bass constructor called.\n"; } CBass(int i) { x=i; cout<<"Bass constructor called.\n"; } ~CBass(){cout<<"Bass destructor called.\n";} void Print() const {cout< }; class CDerivate:public CBass { int y; public: CDerivate() { y=0; cout<<"Default derivate constructor called.\n"; } CDerivate(int i,int j):CBass(j) { y=i; cout<<"Derivate constructor called.\n"; } ~CDerivate(){cout<<"Derivate destructor called.\n";} void Print() { CBass::Print(); cout< } }; void main() { CDerivate A,B(5,10); A.Print(); B.Print(); } 程序运行结果为: Default bass constructor called. Default derivate constructor called. Bass constructor called. Derivate constructor called. 10 5 Derivate destructor called. Bass destructor called. Derivate destructor called. Bass destructor called. 程序中派生类CDerivate的构造函数为： CDerivate(int x,int y):CBass(j) { y=i； Cout<<"Derivate constructor called"; } 构造函数的初始化表中显式调用了基类的构造函数CBass（j），对基类子块中的数据成员赋值，基类构造函数中有一个参数，派生类中也有一个数据成员，因而派生类构造函数有两个参数，它们将分别对基类子块和派生类的数据成员进行初始化。 程序的输出结果说明了构造函数和析构函数的调用次序。程序中定义了派生类对象A，由于没有初始值，因而将调用无参构造函数，在执行派生类的构造函数前，将先调用基类构造函数，再执行派生类构造函数，从而形成程序结果中的头两句： Default bass constructor called. Default bass constructor called. 这些运行结果清楚地表明了构造函数和析构函数的调用次序。类似地可以分析对象B 建立和撤消时，是如何调用构造函数和析构函数的。 3．多重继承 实验四类的继承与多态 一、实验目的 1.掌握构造方法和成员方法重载的应用。 2.理解类的继承性的作用 3.领会面向对象编程的多态性。 二、实验内容与要求 基本概念 1．进一步理解继承的含义 新类可从现有的类中产生，并保留现有类的成员变量和方法并可根据需要对它们加以修改。新类还可添加新的变量和方法。这种现象就称为类的继承。 当建立一个新类时，不必写出全部成员变量和成员方法。只要简单地声明这个类是从一个已定义的类继承下来的，就可以引用被继承类的全部成员。被继承的类称为父类或超类（superclass），这个新类称为子类。 Java 提供了一个庞大的类库让开发人员继承和使用。设计这些类是出于公用的目的，因此，很少 有某个类恰恰满足你的需要。你必须设计自己的能处理实际问题的类，如果你设计的这个类仅仅实现了继承，则和父类毫无两样。所以，通常要对子类进行扩展，即添加新的属性和方法。这使得子类要比父类大，但更具特殊性，代表着一组更具体的对象。继承的意义就在于此。 2．了解成员变量的隐藏方式 所谓隐藏是指子类重新定义了父类中的同名变量，在子类L ine 中重新定义了x为x1，y 为y1，隐藏了父类Point 中的两个成员变量x 和y。子类执行自己的方法时，操作的是子类的变量，子类执行父类的方法时，操作的是父类的变量。在子类中要特别注意成员变量的命名，防止无意中隐藏了父类的关键成员变量，这有可能给程序带来麻烦。 3．了解成员方法的覆盖方式 （1）方法覆盖的定义与作用通过继承子类可以继承父类中所有可以被子类访问的成员方法，但如果子类的方法与父类方法同名，则不能继承，此时称子类的方法覆盖了父类的方法，简称为方法覆盖（override）。方法覆盖为子类提供了修改父类成员方法的能力。 4．理解类的多态性类的继承发生在多个类之间，而类的多态只发生在同一个类上。在一个类中，可以定义多个同名的方法，只要确定它们的参数个数和类型不同。这种现象称为类的多态。多态使程序简洁，为程序员带来很大便利。在O OP 中，当程序要实现多个相近的功能时，就给相应的方法起一个共同的名字，用不同的参数代表不同的功能。这样，在使用方法时不论传递什么参数，只要能被程序识别就可以得到确定的结果。 类的多态性体现在方法的重载（overload）上，包括成员方法和构造方法的重载。 实践应用 《面向对象程序设计》实验报告 实验六、类的继承 课程代码：1H10500学分：6 实验类型：实践型实验学时：4个学时 实验时间：2017.11.23 实验地点：5407 班级：计算机164 专业：计算机科学与技术专业学号：2016011147 姓名：林文辉 一、实验目的 （1）学习JAVA继承的思想 （2）了解JAVA语言继承的实现 二、实验内容及步骤 内容：在圆柱体类Cylinder里，用一个构造方法调用另一个构造方法 步骤：方案的设计与分析（类结构图。。。。。。） （1）找出对象的共同属性和行为 （2）设计代表共同状态与行为的类 （3）决定子类是否需要让某项行为有特定的不同的运行方式 （4）寻找更多抽象化的机会 （5）完成类的继承层次 三、实验过程及结果 实验1代码： abstract class Graphics { abstract void parameter(); abstract void area(); } class Rectangle extends Graphics{ double h,w; Rectangle(double u,double v){h=u;w=v;} void parameter() { S ystem.out.println("矩形高度为:"+h+",矩形宽度为:"+w); } void area() { S ystem.out.println("矩形面积为："+(h*w)); } } class Circle extends Graphics{ double r; String c; Circle(double u,String v){r=u;c=v;} void parameter() { System.out.println("圆半径为:"+r+",圆颜色为:"+c); } void area() { System.out.println("圆面积为:"+(Math.PI*r*r)); } } class ExamAbs{ public static void main(String args[]) { Rectangle rec=new Rectangle(2.0, 3.0); Circle cir=new Circle(4.0, "Red"); Graphics[]g= {rec,cir}; for(int i=0;i 湖北工业大学工程技术学院实验报告 课程名称：面向对象程序设计实验内容：实验六继承性与多态性 学院：工程技术学院专业班级： 姓名：学号：指导教师： 实验日期：实验地点： 一、实验目的 1、1、了解多态性的概念。 2、2、了解虚函数的作用及使用方法。 3、3、了解纯虚函数和抽象类的概念和用法。 二、实验步骤 1.设计一个类层次，其中的基类为Date，它拥有一个相关数据成员及一个虚函 数print，从Date类派生ShortE、MediumDate和LongDate类，Date的print 函数使用日期格式：11-26-2015， ShortE的print函数使用日期格式：26-11-2015 MediumDate的print函数使用日期格式：Nov.26,2015 LongDate的print函数使用日期格式：November 26, 2015 编写一个程序来测试各个类的print函数。 #include day=d; } virtual void print() { cout< 1,定义一个接口Assaultable(可攻击的)，该接口有一个抽象方法attack()。 2,定义一个接口Mobile（可移动的）,该接口有一个抽象方法move()。 3,定义一个抽象类Weapon,实现Assaultable接口和Mobile接口，但并没有给出具体的 实现方法。 4,定义3个类：Tank,Flighter,WarShip都继承自Weapon,分别用不同的方式实现Weapon 类中的抽象方法。 5,写一个类Army,代表一支军队，这个类有一个属性是Weapon数组w（用来存储该军队所拥有的所有武器）；该类还提供一个构造方法，在构造方法里通过传一个int类型的参数来限定该类所能拥有的最大武器数量,并用这一大小来初始化数组w。该类还提供一个方法addWeapon(Weapon wa),表示把参数wa所代表的武器加入到数组w中。在这个类中还定义两个方法attackAll()和moveAll()，让w数组中的所有武器攻击和移动。 6，写一个主方法去测试以上程序。 interface Assaultable{//可攻击的 void attack(); } interface Mobile{//可移动的 void move(); } abstractclass Weapon implements Assaultable,Mobile { publicvoid attack(){} publicvoid move(){} } class Tank extends Weapon{ publicvoid attack(){ System.out.println("坦克攻击！！！"); } publicvoid move(){ System.out.println("坦克移动！！！"); } } class Flighter extends Weapon{ publicvoid attack(){ System.out.println("战斗机攻击！！！"); } publicvoid move(){ System.out.println("战斗机移动！！！"); 继承与多态习题 一.基本概念与基础知识自测题 8.1填空题 8.1.1 如果类α继承了类β，则类α称为（1）类，而类β称为（2）类。（3）类 的对象可作为（4）类的对象处理，反过来不行，因为（5）。如果强制转换则要注意（6）。 答案：（1）基类 （2）派生类 （3）派生类 （4）基类 （5）派生类有一些新成员 （6）只能派生类强制转换为基类 8.1.2 当用public继承从基类派生一个类时，基类的public成员成为派生类的（1）成员， protected成员成为派生类的（2）成员，对private成员是（3）。公有派生可以使其类的（4），所以公有派生是主流。 答案：（1）public成员 （2）protected成员 （3）不可访问 （4）接口不变 8.1.3 利用继承能够实现（1）。这种实现缩短了程序开发的时间，VC++中的（2）很 好地体现了这一点。 答案：（1）代码的复用 （2）MFC编程 8.1.4 一个派生类只有一个直接基类的情况称为（1），而有多个直接基类的情况称为 （2）。继承体现了类的（3）概念，这在MFC中得到了很好表现，MFC中只采用了（4）。 答案：（1）单继承 （2）多重继承 （3）层次 （4）单继承 8.1.5 C++中多态性包括两种多态性：（1）和（2）。前者是通过（3）实现的， 而后者是通过（4）和（5）来实现的。 答案：（1）编译时的 （2）运行时的 （3）函数和运算符的重载 （4）类继承关系 （5）虚函数 8.1.6 在基类中将一个成员函数说明成虚函数后，在其派生类中只要（1）、（2）和 （3）完全一样就认为是虚函数，而不必再加关键字（4）。如有任何不同，则认为是（5）而不是虚函数。除了非成员函数不能作为虚函数外，（6）、（7）和（8）也不能作为虚函数。 答案：（1）同虚函数名 （2）同参数表 （3）同返回类型。如基类中返回基类指针，而派生类中返回派生类指针是允许的 （4）virtual （5）重载 （6）静态成员函数 （7）内联函数 （8）构造函数 8.1.7 纯虚函数定义时在函数参数表后加（1），它表明程序员对函数（2），其本质 是将指向函数体的指针定为（3）。 答案：（1）=0 （2）不定义 （3）NULL 8.2简答题 8.2.1构造函数和析构函数可以继承吗？派生类构造函数各部分的执行次序是怎样的？答：构造函数和析构函数不可以继承。派生类构造函数各部分的执行次序是： 1.调用基类构造函数，按它们在派生类声明的先后顺序，依次调用。 2.调用新增成员对象的构造函数，按它们在类定义中声明的先后顺序，依次调用。 3.派生类的构造函数体中的操作。 8.2.2什么叫派生类的同名覆盖（override）? 答：如果派生类声明了一个和某个基类成员同名的新成员（当然如是成员函数，参数表也必须一样，否则是重载），派生类中的新成员就屏蔽了基类同名成员，类似函数中的局部变量屏蔽全局变量。称为同名覆盖（override）。 8.2.3派生类的析构函数中需完成什么任务？是否要编写对基数和成员对象的析构函数的 调用？为什么？ 答：析构函数的功能是作善后工作，析构函数无返回类型也没有参数，情况比较简单。派生类析构函数定义格式与非派生类无任何差异，不要编写对基数和成员对象的析构函数的调用，只要在函数体内把派生类新增一般成员处理好就可以了，因为对新增的成员对象和基类的善后工作，系统会自己调用成员对象和基类的析构函数来完成。 8.2.4为什么要使用虚基类？怎样定义虚基类？用一个实例来解释虚基类在其派生类中的 存储方式。 答：在多重继承是有可能出现同一基类的两个拷贝，为避免这种情况，可使用虚基类。虚基类（virtual base class）定义方式如下： class派生类名:virtual 访问限定符基类类名{...}; class派生类名:访问限定符virtual基类类名{...}; virtual 关键字只对紧随其后的基类名起作用。 C++的封装性、继承性和多态性概念 封装的目的是增强安全性和简化编程，使用者不必了解具体的实现细节，而只是要通过外部接口，一特定的访问权限来使用类的成员。例如，在抽象的基础上，我们可以将时钟的数据和功能封装起来，构成一个时钟类。按c++的语法，时钟类的声明如下：class Clock { public: //共有成员，外部借口void SetTime(int NewH,int NewM,int NewS); void ShowTime(); private: //私有成员，外部无法访问int Hour,Minute,Second; } 可以看到通过封装使一部分成员充当类与外部的接口，而将其他的成员隐蔽起来，这样就达到了对成员访问权限的合理控制，使不同类之间的相互影响减少到最低限度，进而增强数据的安全性和简化程序的编写工作。什么是多态（Polymorphisn）？按字面的意思就是“多种形状”。引用Charlie Calverts对多态的描述——多态性是允许你将父对象设置成为和一个或更多的他的子对象相等 的技术，赋值之后，>>>父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作<<<（摘自“Delphi4 编程技术内幕”）。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。多态性在Object Pascal和C++中都是通过虚函数（Virtual Function）实现的。好，接着是“虚函数”（或者是“虚方法”）。虚函数就是允许被其子类重新定 义的成员函数。而子类重新定义父类虚函数的做法，称为“覆盖”（override），或者称为“重写”。“继承”是面向对象软件技术当中的一个概念。如果一个类A继承自另一个类B，就把这个A称为"B的子类"，而把B称为"A的父类"。继承可以使得子类具有父类的各种属性和方法，而不需要再次编写相同的代码。在令子类继承父类的同时，可以重新定义某些属性，并重写某些方法，即覆盖父类的原有属性和方法，使其获得与父类不同的功能。 ... 继承是指一个对象直接使用另一对象的属性和方法。事实上，我们遇到的很多实体都有继承的含义。例如，若把汽车看成一个实体，它可以分成多个子实体，如：卡车、公共汽车等。这些子实体都具有汽车的特性，因此，汽车是它们的"父亲"，而这些子实体则是汽车的"孩子"。19. 多态的作用？主要是两个：1. 隐藏实现细节，使得代码能够模块化；扩展代码模块，实现代码重用； 2. 接口重用：为了类在继承和派生的时候，保证使用家族中任一类的实例的某一属性时的正确调用。 西安邮电大学 （计算机学院） 课内实验报告 实验名称：继承与多态 专业名称：计算机科学与技术 班级：计科1405班 学生姓名：高宏伟 学号：04141152 指导教师：刘霞林 实验日期：2016.10.13 一、实验目的 通过编程和上机实验理解Java 语言的继承和多态特性，掌握变量的隐藏、方法的覆盖、重载，掌握抽象类和接口的使用。 二、实验要求 1.编写体现类的继承性（成员变量、成员方法、成员变量隐藏）的程序。 2.编写体现类的多态性（成员方法重载）的程序。 3.编写体现类的多态性（构造方法重载）的程序。 4.编写使用接口的程序。 三、实验内容 （一）类的继承 1.创建公共类Student. （1）编写程序文件Student.java，源代码如下: public class Student { protected String name; //具有保护修饰符的成员变量 protected int number; void setData(String m,int h) //设置数据的方法 { name =m; number= h; } public void print() //输出数据的方法 { System.out.println(name+", "+number); } } （2）编译Student.java，产生类文件Student.class。 2．创建继承的类Undergraduate （1）程序功能：通过Student 类产生子类undergraduate，其不仅具有父类的成员变量name（）、number（学号），还定义了新成员变量academy（学院）、department （系）。在程序中调用父类的print 方法。 （2）编写Undergraduate 程序: class Undergraduate extends Student { 【代码1】//定义成员变量academy 【代码2】//定义成员变量department public static void main(String args[]) { 【代码3】//创建一个学生对象s 【代码4】//用父类的setData方法初始化对象s 【代码5】//对象s调用print方法 【代码6】//创建一个大学生对象u 【代码7】//调用父类的成员方法setData初始化对象u 【代码8】//设置对象u的成员变量academy 【代码9】//设置对象u的成员变量department System.out.print(https://www.doczj.com/doc/055747056.html,+", "+u.number+", "+u.academy+", "+u.department); } } （3）编译并运行程序 注意：公共类Student 与undergraduate 类要在同一文件夹（路径）。 (二)方法的重载 （1）程序功能：对不同的数进行排序输出。在IntSort 类中定义3 个同名的方法sort。 （2）编写Sort.java 文件，源代码如下。 import java.awt.Graphics; import java.applet.Applet; class IntSort { public String sort(int a, int b) { if (a>b) return a+""+b; else return b+""+a; } public String sort(int a, int b, int c) { int swap; if (a 南京信息工程大学实验（实习）报告 实验（实习）名称类的继承性和多态性实验（实习）日期得分指导教师陈遥 系计算机专业网络工程年级 2014 班次 2 姓名刘信言学号 20142346074 一、实验目的 1.掌握Java语言的类的继承的概念。 2.掌握Java语言中抽象类的使用。 3.掌握Java语言中接口的使用 二、实验内容及步骤 1.类的继承，具体要求如下： (1)定义一Person类，该类具有属性人名、年龄、身份证号等信息以及将属性信息作为字符串返回的 方法； (2)定义一Student类，让该类继承Person类，该类除了具有属性人名、年龄、身份证号等信息以外还有学号，所在学校等信息；该类也具有将属性信息作为字符串返回的一方法； (3)编写测试类，测试这两个类 【源程序】 【运行效果图】 2.定义一个动物抽象类Animal,该类有一个抽象的方法cry()；定义一个小猫类Cat,该类继承了Animal 类并实现了cry()方法，当调用cry()方法时打印“小猫喵喵叫”，定义一个小狗类Dog,该类也继承了Animal类并实现了cry()方法，当调用cry()方法时打印“小狗汪汪叫”。 【源程序】 【运行效果图】 3. 接口的运用。 定义一接口接口名叫Usb,该接口声明了两个方法分别为start()和stop()方法，定义一U盘类UsbDiskWriter，一照相机类Camera、一手机类Mobile，让它们都实现该接口。 【源程序】 【运行效果图】 五、结果分析 1. 子类若想调用父类的构造函数必须要用super关键字。 2.接口体中只能运用抽象类。 3.在同一个java文件中只能在入口函数的类中用public。 实验三类的继承 实验目的：掌握类的继承、抽象类的定义和使用、对象的向上转型。实验内容：已知若干图形，求以该图形为底的锥体的体积。 实验要求：用面向抽象的思想实现 实验步骤： 1、程序总体框架 2、在shape包中创建抽象类Shape，代码如下： 3、在centrun包中创建一个类Centrun,代码如下： Centrun这个类为核心类，在之后的代码编写中可以不做更改，getVolume函数用来求椎体的体积，即利用抽象类getArea进行适应性计算。 4、创建一个包myshape，在其中先创建一个Circle类，代码如下： Circle是对抽象类shape的继承（记得导入shape包），在Circle类中，利用对getArea 函数代码的重写操作，具体实现了求圆的面积这一操作。【此处的具体实现应该放入该图形的具体面积求法。】 5、创建一个包Test，对以上三个包中的代码进行具体实现，代码如下： 导入myshape包，在main函数中通过向上转型，实例化shape包中的抽象类Shape，然后调用函数输出圆锥的体积。 6、在求出实验结果1，即调试好shape、myshape、centrun这三个包后，不再更改shape、centrun包，而是在myshape包下新建所需的类，如本次实验所需的三角形、矩形； 7、在myshape包下创建一个类Rectangular，代码如下： 8、在myshape包下创建一个类Triangle，需注意的是，求三角形的面积需要判断三角形的三边能否构成三角形（不能构成时返回0），代码如下： 实验结果： 1、Test测试包最终代码： JAVA中继承的总结 一、继承概念： 把多个类中相同的成员给提取出来定义到一个独立的类中。然后让这多个类和该独立的类产生一个关系， 这多个类就具备了这些内容。这个关系叫继承。 二、何时实现继承 A:继承体现的是：is a的关系。 B:采用假设法 三、怎么实现继承 A:用关键字extends表示 B:格式： class 子类名 extends 父类名 {} C:子类 public class 子类 extends 父类 { //增加自己属性 //重写父类的属性 //增加自己的方法 //重写父类的方法 } 四、继承的好处： A:提高了代码的复用性 B:提高了代码的维护性 C:让类与类产生了一个关系，是多态的前提 继承的弊端： A:让类的耦合性增强。这样某个类的改变，就会影响其他和该类相关的类。 原则：低耦合，高内聚。 耦合：类与类的关系 内聚：自己完成某件事情的能力 B:打破了封装性 五、Java中继承的特点 A:Java中类只支持单继承，只能一个直接父类，Object 根类 B:Java中可以多层(重)继承(继承体系) 六、继承的注意事项： A:子类能继承父类的私有成员,但不是都能访问 B:子类不能继承父类的构造方法，但是可以通过super去访问 C:不要为了部分功能而去继承 七、继承中static用法 A:static:子类可以继承父类的静态方法,但不能重写 B:static 的属性和方法都是不能覆盖的，因为static修饰的部分都是与对象无关的，只与类有关 八、Java继承中的成员关系 A:成员变量 a:子类的成员变量名称和父类中的成员变量名称不一样，这个太简单 b:子类的成员变量名称和父类中的成员变量名称一样，这个怎么访问呢? C#中的继承符合下列规则： 1、继承是可传递的。如果C从B中派生，B又从A中派生，那么C不仅继承了B中声明的成员，同样也继承了A中的成员。Object 类作为所有类的基类。 2、派生类应当是对基类的扩展。派生类可以添加新的成员，但不能除去已经继承的成员的定义。 3、构造函数和析构函数不能被继承。除此以外的其它成员，不论对它们定义了怎样的访问方式，都能被继承。基类中成员的访问方式 只能决定派生类能否访问它们。 4、派生类如果定义了与继承而来的成员同名的新成员，就可以覆盖已继承的成员。但这并不因为这派生类删除了这些成员，只是不能再 访问这些成员。 5、类可以定义虚方法、虚属性以及虚索引指示器，它的派生类能够重载这些成员，从而实现类可以展示出多态性。 6、派生类只能从一个类中继承，可以通过接吕实现多重继承。 多态性 在C#中，多态性的定义是：同一操作作用于不同的类的实例，不同的类将进行不同的解释，最后产生不同的执行结果。C#支持两种类型的多态性： ●编译时的多态性 编译时的多态性是通过重载来实现的。对于非虚的成员来说，系统在编译时，根据传递的参数、返回的类型等信息决定实现何种操作。 ●运行时的多态性 运行时的多态性就是指直到系统运行时，才根据实际情况决定实现何种操 作。C#中，运行时的多态性通过虚成员实现。 编译时的多态性为我们提供了运行速度快的特点，而运行时的多态性则带来了高度灵活和抽象的特点。 2、实现多态 多态性是类为方法（这些方法以相同的名称调用）提供不同实现方式的能力。多态性允许对类的某个方法进行调用而无需考虑该方法所提供的特定实现。可以用不同的方式实现组件中的多态性： ●接口多态性。 ●继承多态性。 ●通过抽象类实现的多态性。 接口多态性 多个类可实现相同的“接口”，而单个类可以实现一个或多个接口。接口本质上是类需要如何响应的定义。接口描述类需要实现的方法、属性和事件，以及每个成员需要接收和返回的参数类型，但将这些成员的特定实现留给实现类去完成。组件编程中的一项强大技术是能够在一个对象上实现多个接口。每个接口由一小部分紧密联系的方法、属性和事件组成。通过实现接口，组件可以为要求该接口的任何其他组件提供功能，而无需考虑其中所包含的特定功能。这使后续组件的版本得以包含不同的功能而不会干扰核心功能。其他开发人员最常使用的组件功能自然是组件类本身的成员。然而，包含大量成员的组件使用起来可能比较困难。可以考虑将组件的某些功能分解出来，作为私下实现的单独接口。 根据接口来定义功能的另一个好处是，可以通过定义和实现附加接口增量地将功能添加到组件中。优点包括： 一、选择题 1. 在C++中,类与类之间的继承关系具有（C ） A）自反性B）对称性C）传递性D）反对称性 2. 在公有继承的情况下，基类的成员（私有的除外）在派生类中的访问权限（B A）受限制B）保持不变C）受保护D）不受保护 3. 按解释中的要求在下列程序划线处填入的正确语句是： （C ） #in elude 6. 当一个派生类仅有protected继承一个基类时，基类中的所有公有成员成为派生类的（C） A） public 成员B） private 成员C） protected 成员D) 友元 7. 不论派生类以何种方法继承基类，都不能使用基类的(B ) A) public 成员B) private 成员C) protected 成员D) public 成员和protected 成员 8 下面叙述错误的是( S )。 A) 基类的protected 成员在派生类中仍然是protected 的 B) 基类的protected 成员在public 派生类中仍然是protected 的 C) 基类的protected 成员在private 派生类中是private 的 D) 基类的protected 成员不能被派生类的对象访问 9. 下列说法中错误的是( S )。 A) 保护继承时基类中的public 成员在派生类中仍是public 的 B) 公有继承时基类中的private 成员在派生类中仍是private 的 C) 私有继承时基类中的public 成员在派生类中是private 的 D) 保护继承时基类中的public 成员在派生类中是protected 的 10下面叙述错误的是( C)。 A) 派生类可以使用private 派生 B) 对基类成员的访问必须是无二义性的 C) 基类成员的访问能力在派生类中维持不变 D) 赋值兼容规则也适用于多继承的组合 11派生类的构造函数的成员初始化列表中，不能包含(C )。 A) 基类的构造函数B) 派生类中子对象 的初始化 C) 基类中子对象的初始化D) 派生类中一般数 据成员的初始化 12. 下列虚基类的声明中，正确的是： ( B ) A)class virtual B: public A B)class B: virtual public A C)class B: public A virtual D)virtual class B: public A 13..实现运行时的多态性采用（D ） A）重载函数B）构造函数C）析构函数D）虚函数 14. 若一个类中含有纯虚函数，则该类称为（D ） class shap2D { static double getArea; //面积 static double getPerimeter; //周长 } class circle extends shap2D { double r; double getRadius(){return r=2;} double getArea() {return Math.PI*r*r;} double getPerimeter() {return 2*Math.PI*r;} public String toString() { String s; return s="周长："+getPerimeter()+"面积:"+getArea(); } } class Triangle extends circle { double a,b,c; Triangle (double x,double y,double z) {a=x; b=y;c=z;} void setA(double x){a=x;} double getA(){return a;} public double getPerimeter() {return a+b+c;} public double getArea() { double s=(a+b+c)/2; return Math.sqrt(s*(s-a)*(s-b)*(s-c)); } public boolean isTriangle() { boolean flag=false; if(a>0&&b>0&&c>0&&a+b>c&&a+c>b&&c+b>a) flag=true; return flag; } } class rectangle extends circle { double a,b; 实验七类的继承性练习 新类可从现有的类中产生，并保留现有类的成员变量和方法并可根据需要对它们加以修改。新类还可添加新的变量和方法。这种现象就称为类的继承。 当建立一个新类时，不必写出全部成员变量和成员方法。只要简单地声明这个类是从一个已定义的类继承下来的，就可以引用被继承类的全部成员。被继承的类称为父类或超类（superclass），这个新类称为子类。 Java 提供了一个庞大的类库让开发人员继承和使用。设计这些类是出于公用的目的，因此，很少有某个类恰恰满足你的需要。你必须设计自己的能处理实际问题的类，如果你设计的这个类仅仅实现了继承，则和父类毫无两样。所以，通常要对子类进行扩展，即添加新的属性和方法。这使得子类要比父类大，但更具特殊性，代表着一组更具体的对象。继承的意义就在于此。 6.1、创建将被继承的类 (1) 程序源代码如下。 public class EXP3_7 { protected String xm; //具有保护修饰符的成员变量 protected int xh; void setdata(String m,int h) //设置数据的方法 { xm =m; xh = h; } public void print() //输出数据的方法 { System.out.println(xm+", "+xh); } } (2) 编译源程序。 6.2、创建将被继承的类 (1) 程序功能：通过EXP3_7类产生子类EXP3_8，其不仅具有父类的成员变量xm（姓名）、xh（学号），还定义了新成员变量xy（学院）、xi（系）。在程序中调用了父类的print 方法，同时可以看出子类也具有该方法。 (2) 程序源代码如下。 一.extends和super的使用和方法的重写 1.定义一个人的类（属性有名字，年龄。写一个能输出各个属性值 的方法showInfo（）），定义一个学生类（属性有性别），学生继承人类 要求：（1）父类的属性赋值用构造方法来实现（分别用有参数构造方法和无参数构造方法实现） （2）子类的属性也用构造方法来赋值。 （3）在子类中重写父类的showInfo（）方法 （4）声明学生类的对象，调用学生的显示信息的方法。 2 定义Animal父类，含有属性name，sex，age，方法sleep，run，编写一个子类Person，继承Animal类，然后调用父类的属性和方法二． 1、试编写三个具有继承关系的类，A、B、C（B继承A，C继承B）。 要求A中包含方法a1()、a2()，B类中的方法b1()访问了a1() 和a2()，C类中的方法c1()访问了a1()、a2()、b1()。 提示：（a1(),a2(),b1(),c1()这些方法体除了实现题目要求之外，其余内容可以任意编写。） 2、请编码实现动物世界的继承关系： 动物（Animal）具有行为：吃（eat）、睡觉（sleep） 动物包括：兔子（Rabbit），老虎（Tiger） 这些动物吃的行为各不相同（兔子吃草，老虎吃肉）；但睡 觉的行为是一致的。 请通过继承实现以上需求，并编写测试类AnimalTest进行测试。3、父类Person 包含like（）方法子类Son 重写父类方法并打印输出 4、(选做)父类Employee 属性：name、sex ，带一个构造方法Employee(String n, char s) 子类Worker继承自Employee 属性：char category;法（）可以调用父类 的所有非私有方法 B) super（）可以调用父类的所有非私有构造函数 C) super.属性可以调用父类的所有非私有属性 D) this和super关键字可以出现在同一个构造函数中 8．以下关于final关键字说法错误的是（A,C）（两项） A) final是java中的修饰符，可以修饰类、接口、抽象类、方法和属性 B) final修饰的类肯定不能被继承 C) final修饰的方法不能被重载 D) final修饰的变量不允许被再次赋值 9．访问修饰符作用范围由大到小是（D） A) private-default-protected-public B) public-default-protected-private C) private-protected-default-public D) public-protected-default-private 10．以下（D）不是Object类的方法 A) clone（） B) finalize（） C) toString（） D) hasNext（） 11．多态的表现形式有（A） A) 重写 B) 抽象 C) 继承 D) 封装 12．以下对重载描述错误的是（B） 通过实例理解继承与多态原理与优点 一引子 都说面向对象的4大支柱是抽象，封装，继承与多态。但是一些初涉编程的开发人员，体会不到继承与多态的妙用，本文就试以一个经典实例来诠释继承与多态的用武之地。 二需求 1. 任务说明 我们的需求是一个影片出租的小应用，该应用会记录每个顾客的消费金额并打印出来。程序输入为：顾客租的影片及对应的租期； 程序的处理为：根据顾客租用影片时间及影片类型，计算费用；输出：打印消费单。 影片有三种类型：普通影片、儿童影片及新上映影片。 另外，模仿时下潮流，程序还提供了积分制度，为常客计算积分，积分会根据影片是否为新上映影片而不同。 2. 本实例为控制台程序，运行界面如下： 三非继承多态实现方式 根据需求，我们定义三个类，分别是movie类，Rental类（代表一条租用记录）和Customer 类（租碟顾客） 其中movie类的代码如下： 1 using System; 2 using System.Collections.Generic; 3 using System.Linq; 4 using System.Text; 5 6 namespace _https://www.doczj.com/doc/055747056.html,tbed 7 { 8 public enum TYPE 9 { 10 REGULAR, 11 NEW_RELEASE, 12 CHILDRENS 13 } 14 15 class Movie 16 { 17 private string _title; //movie name 18 TYPE _typeCode; //price code 19 20 public Movie() 21 { 22 _title = "unname"; 23 _typeCode = 0; 24 } 25 26 public Movie(string title, TYPE typeCode) 27 { 28 _title = title; 29 _typeCode = typeCode; 30 } 31 32 public TYPE getTypeCode() 33 { 34 return (TYPE)_typeCode; 35 } 36 37 void setTypeCode(TYPE arg) 38 { 39 _typeCode = arg; 40 } 41 42 public string getTitle() 43 { 习题3 一、选择题 1.在C++中，类与类之间的继承关系具有（ C ） A)自反性B)对称性C)传递性D)反对称性 2.在公有继承的情况下，基类的成员（私有的除外）在派生类中的访问权限（ B ） A)受限制B)保持不变C)受保护D)不受保护 3.按解释中的要求在下列程序划线处填入的正确语句是：（ C ） #include 有公有成员成为派生类的（C） A) public成员B) private成员C) protected成员 D) 友元 7.不论派生类以何种方法继承基类，都不能使用基类的（B ） A) public成员B) private成员C) protected成员D) public成员和protected成员 8下面叙述错误的是（S ）。 A)基类的protected成员在派生类中仍然是protected的 B)基类的protected成员在public派生类中仍然是protected 的 C)基类的protected成员在private派生类中是private的 D)基类的protected成员不能被派生类的对象访问 9.下列说法中错误的是（S ）。 A) 保护继承时基类中的public成员在派生类中仍是public 的 B)公有继承时基类中的private成员在派生类中仍是private 的 C)私有继承时基类中的public成员在派生类中是private的 D)保护继承时基类中的public成员在派生类中是protected 的 10下面叙述错误的是（C）。 A)派生类可以使用private派生 B)对基类成员的访问必须是无二义性的 C)基类成员的访问能力在派生类中维持不变 D)赋值兼容规则也适用于多继承的组合 11派生类的构造函数的成员初始化列表中，不能包含（C ）。 A)基类的构造函数B)派生类中子对象的初始化 C)基类中子对象的初始化D)派生类中一般数据成员的初始化 12.下列虚基类的声明中，正确的是：（ B ） A)class virtual B: public A B)class B: virtual public A实验04 类的继承与多态
JAVA类的继承实验报告
实验六继承性与多态性
Java 接口与类之间继承例题
继承与多态习题
C 的封装性、继承性和多态性概念
Java继承与多态实验报告
类的继承性和多态性
java 类的继承 实验报告(含代码)
java中继承的相关知识总结
对多态性和继承的理解
C++习题3(继承和多态)
JAVA继承类求几何图形面积周长代码
类的继承性练习
java练习题-继承
通过实例理解继承与多态原理与优点
C++习题3(继承和多态)
相关主题
文本预览