当前位置:文档之家› C习题集3(继承和多态)

C习题集3(继承和多态)

C习题集3(继承和多态)
C习题集3(继承和多态)

,.

习题3

一、选择题

1.在C++中,类与类之间的继承关系具有( C )

A)自反性B)对称性C)传递性D)反对称性

2.在公有继承的情况下,基类的成员(私有的除外)在派生类中的访问权限( B )

A)受限制B)保持不变C)受保护D)不受保护

3.按解释中的要求在下列程序划线处填入的正确语句是:( C )

#include

class Base{

public:

void fun(){cout<<"Base::fun"<

};

class Derived:public Base{

public:

void fun()

{ //在此空格处调用基类的函数fun()

cout<<"Derived::fun"<

};

A)fun();B)Base.fun();C)Base::fun();

D)Base->fun();

4.在保护继承的情况下,基类的成员(私有的除外)在派生类中的访问权限(C )

A)受限制B)保持不变C)受保护D)不受保护5.在哪种派生方式中,派生类可以访问基类中的protected 成员(B )

A)public和private B)public、protected和private

C)protected和private D)仅protected

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 )

A) 基类B) 纯基类C) 派生类

D) 抽象类

15.假设A为抽象类,下列声明(B)是正确的

A) A fun(int); B) A *p; C) int fun(A);

D) A Obj;

16.在派生类中,重载一个虚函数时,要求函数名、参数的个数、参数的类型、参数的顺序和函数的返回值(B )A) 不同B) 相同C) 相容

D) 部分相同

17.下面函数原型声明中,(C)声明了fun为普通虚函数

A) void fun()=0; B) virtual void fun()=0;

C) virtual void fun(); D) virtual void fun(){};

18.在下面四个选项中, (A)是用来声明虚函数的。

A)virtual B)public C)using D)false

19.实现运行时的多态性要使用(D)。

A)重载函数B)构造函数

C)析构函数D)虚函数

20.关于虚函数的描述中,正确的是(D)。

A)虚函数是一个静态成员函数

B)虚函数是一个非成员函数

C)虚函数既可以在函数说明时定义,也可以在函数实现时定义

D)派生类的虚函数与基类中对应的虚函数具有相同的参数个数和类型

二、填空题:

1.派生类对基类的继承有三种方式:_public___、_protected_ __ 和__private_ __。

,.

2.如果类Alpha继承了类Beta,则类Alpha称为__派生__类,类Beta称为__基_类。

3. 设置虚基类的目的是为了消除二义性,可通过_virtual 标识虚基类。

4. 类继承中,缺省的继承方式是__ private _________。

5. 当用protected继承从基类派生→个类时,基类的public成员成为派生类的_ protected __________成员,protected成员成为派生类的_protected ____ ____成员。

6.指向基类的对象的指针变量也可以指向__公有派生类的对象。

三、程序题

1.继承的工作方式,完成以下代码。要求:(1)处继承方式为共有继承public,(2)处填写基类的ai,(3)处填写派生类的bi,(4)对象b的数据成员有哪些?ai,bi #include

#include

class A{

public:

A(){ai=1;}

protected:

int ai;

};

class B: _____ A{

public:

B(){bi=2;}

void display(){cout<<____(2)____<< ____(3)____<

private:

int bi;

};

,. int main()

{

B b;

b.display();

}

2.派生类的构造。派生类的构造总是由基类的初始化开始的。填写代码,完成基类的初始化。并且要求屏幕输出效果是:

#include

class A{

public:

A(int i){x=i; cout<<"CA:"<

~A(){cout<<"DA"<

private:

int x;

};

class B:public A{

public:

B():_A(90)_{y=0;cout<<"CB"<

~B(){cout<<"DB"<

private:

int y;

};

int main()

{

B b;

}

3.填写初始化列表,完成以下程序,使得屏幕输出:

#include

class A{

public:

A(int i){x=i; cout<

,.

private:

int x;

};

class D{

public:

D(int i){m=i;cout<

private:

int m;

};

class B:public A{

public:

B():_A(90),d(19)

{y=0;}

private:

int y;

D d;

};

int main()

{

B b;

}

4.请问以下程序输出什么?

#include

class A{

public:

A(int i){x=i;}

int x;

};

class B:public A{

public:

B(int i):A(i+1){y=i;}

int y;

,. };

void f1(A & ra)

{

cout<

}

void f2(A * pa)

{

cout<x<

}

int main()

{

B b(3);

f1(b);

f2(&b);

}

4答案:

5.请问以下程序输出什么?

#include

class A{

public:

void display(){cout<<"A"<

};

class B:public A{

public:

void display(){cout<<"B"<

};

void f(A &r)

{

r.display();

}

,. int main()

{

B b;

f(b);

A a;

f(a);

}

5.答案:

6.多态性,虚函数。

请问以下程序输出什么?

#include

class A{

public:

virtual void display(){cout<<"A"<

};

class B:public A{

public:

virtual void display(){cout<<"B"<

};

void f(A &r)

{

r.display();

}

int main()

{

B b;

f(b);

A a;

,.

f(a);

}

6.答案:

7.请问以下程序输出什么?

#include

class A{

public:

virtual void display(){cout<<"A"<

};

class B:public A{

public:

virtual void display(){cout<<"B"<

};

class C:public A{

public:

virtual void display(){cout<<"C"<

};

int main()

{

A a,aa;

B b;

C c,cc,ccc;

A *pa[6]={&a,&aa,&b,&c,&cc,&ccc};

int i=0;

for(i=0;i<6;++i)

pa[i]->display();

}

答案:

8.以下程序的屏幕输出是:。为何以下程序的屏幕输出中会输出DA呢?请说明。

#include

class A{

public:

~A(){cout<<"DA ";}

};

class B:public A{

public:

~B(){cout<<"DB ";}

};

int main()

{

B b;

}

答案:定义类B对象b时,先调用基类A的构造函数,再调用派生类类B的构造函数。析构时正好相反,先析构B类,再析构A类。

1答案:(1)public (2)ai (3)bi (4)ai、bi

2.答案:A(90)

3.答案:A(90),d(19)

4答案:

5.答案:

6.答案:

7. 答案:

8.答案:定义类B对象b时,先调用基类A的构造函数,再调用派生类类B的构造函数。析构时正好相反,先析构B类,再析构A类。

选择

CBCCB CBAAC CBDDB BCADD

填空:

1.public__、___protected__ 和___private

2.派生,基类

3.为了消除二义性virtual

4. private

5. _protected_protected

6. 公有派生类

JAVA继承和多态实验报告

实验项目名称:继承和多态 (所属课程:Java语言程序设计) 院系:专业班级:姓名: 学号:实验地点:指导老师: 本实验项目成绩:教师签字:日期: 1.实验目的 (1)掌握类的继承机制。 (2)熟悉类中成员变量和方法的访问控制。 (3)熟悉方法或构造方法多态性。 2.实验内容 (1)模拟编写程序,理解类的继承、多态、继承和多态规则。 (2)独立编程,实现类的继承和多态。 3.实验作业 设计一个类Shape(图形)包含求面积和周长的area()方法和perimeter()方法以及设置颜色的方法SetColor(),并利用Java多态技术设计其子类Circle(圆形)类、Rectangle (矩形)类和Triangle(三角形)类,并分别实现相应的求面积和求周长的方法。每个类都要覆盖toString方法。 海伦公式:三角形的面积等于s(s-a)(s-b)(s-c)的开方,其中s=(a+b+c)/2 程序代码为: Class包 package Class; public class Shape { private String color = "while"; public Shape(String color){ this.color = color; } public void setColor(String color){ this.color = color; } public String getColor(){ return color;

} public double getArea(){ return 0; } public double getPerimeter(){ return 0; } public String toString(){ return"color:" + color; } } package Class; public class Circle extends Shape { private double radius; public Circle(String color,double radius) { super(color); this.radius = radius; } public void setRadius(double radius){ this.radius = radius; } public double getRadius(){ return radius; } public double getCircleArea(){ return 3.14*radius*radius; } public double getCirclePerimeter(){ return 3.14*2*radius; } public String toString(){

java实验报告2 继承多态 封装

实验报告 学生姓名:学号:专业班级: 实验类型:□验证□综合□设计□创新实验日期:实验成绩: 一、实验项目名称抽象、封装与类(一) 二、实验目的 1.掌握抽象、封装、继承和多态 2.熟练掌握如何自定义一个类。 3.掌握类的访问权限 4.掌握类成员的访问控制

三、实验基本原理 四、主要仪器设备及耗材 Myclipse 五、实验步骤 1、调试程序例3-4 2、编写如下程序。 (1)定义一个表示学生的类Student,包括属性“学号”、“班号”、“姓名”、“性别”、“年龄”;方法“获得学号”、“获得班号”、“获得姓名”、“获得性别”、“获得年龄”、“修改年龄”。 (2)为Student类定义构造函数初始化所有属性,增加一个方法public String toString(),把Student类对象的所有属性信息组合成一个字符串输出。 (3)在main()中创建Student类对象,测试自定义类。 六、实验数据及处理结果 1、package ncu;

public class Exam3_4 { static double d; public static void main(String args[]){ int i; Exam3_4 pt=new Exam3_4(); i=5; (i); "int type value is:"+i); =; (pt); "double type value is"+d); } public void changeInt(int v) {v=10;} public void changeDouble(Exam3_4 ref) {=;} }

继承与多态习题

继承与多态习题 一.基本概念与基础知识自测题 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 关键字只对紧随其后的基类名起作用。

实验04 类的继承与多态

实验四类的继承与多态 一、实验目的 1.掌握构造方法和成员方法重载的应用。 2.理解类的继承性的作用 3.领会面向对象编程的多态性。 二、实验内容与要求 基本概念 1.进一步理解继承的含义 新类可从现有的类中产生,并保留现有类的成员变量和方法并可根据需要对它们加以修改。新类还可添加新的变量和方法。这种现象就称为类的继承。 当建立一个新类时,不必写出全部成员变量和成员方法。只要简单地声明这个类是从一个已定义的类继承下来的,就可以引用被继承类的全部成员。被继承的类称为父类或超类(superclass),这个新类称为子类。 Java 提供了一个庞大的类库让开发人员继承和使用。设计这些类是出于公用的目的,因此,很少 有某个类恰恰满足你的需要。你必须设计自己的能处理实际问题的类,如果你设计的这个类仅仅实现了继承,则和父类毫无两样。所以,通常要对子类进行扩展,即添加新的属性和方法。这使得子类要比父类大,但更具特殊性,代表着一组更具体的对象。继承的意义就在于此。 2.了解成员变量的隐藏方式 所谓隐藏是指子类重新定义了父类中的同名变量,在子类L ine 中重新定义了x为x1,y 为y1,隐藏了父类Point 中的两个成员变量x 和y。子类执行自己的方法时,操作的是子类的变量,子类执行父类的方法时,操作的是父类的变量。在子类中要特别注意成员变量的命名,防止无意中隐藏了父类的关键成员变量,这有可能给程序带来麻烦。 3.了解成员方法的覆盖方式 (1)方法覆盖的定义与作用通过继承子类可以继承父类中所有可以被子类访问的成员方法,但如果子类的方法与父类方法同名,则不能继承,此时称子类的方法覆盖了父类的方法,简称为方法覆盖(override)。方法覆盖为子类提供了修改父类成员方法的能力。 4.理解类的多态性类的继承发生在多个类之间,而类的多态只发生在同一个类上。在一个类中,可以定义多个同名的方法,只要确定它们的参数个数和类型不同。这种现象称为类的多态。多态使程序简洁,为程序员带来很大便利。在O OP 中,当程序要实现多个相近的功能时,就给相应的方法起一个共同的名字,用不同的参数代表不同的功能。这样,在使用方法时不论传递什么参数,只要能被程序识别就可以得到确定的结果。 类的多态性体现在方法的重载(overload)上,包括成员方法和构造方法的重载。 实践应用

Java继承与多态实验报告

西安邮电大学 (计算机学院) 课内实验报告 实验名称:继承与多态 专业名称:计算机科学与技术 班级:计科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/f95760450.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

JAVA面向对象基础测试题,继承,封装,多态等测试题

JAVA面向对象基础测试题 提示:本题为第一阶段,JAVA面向对象基础部分练习题,包括对象,类,继承,封装,多态,接口,内部类等等,java核心基础,适合初学者对面向对象基础的知识进行测试,以便查漏补缺。 1. 程序执行的结果是:()。 01 public class Point{ 02 int y = 7; 03 public void step(int y) { 04 y += y; 05 System.out.println(y); 06 } 07 public static void main(String[] args) { 08

Point p = new Point(); 09 p.step(10); 10 } 11 } A.14 B.20 C.10 D.17 正确答案:B解析: 2. 程序的执行结果是:()。 01 public class Question { 02 private int num; 03 public static void main(String [] args){ 04 Question q = new Question();

05 q.num=13; 06 update(q); 07 System.out.println(q.num); 08 } 09 public static void update(Question q){ 10 q.num=9; 11 } 12 } A.13 B.9 C.0 D.4 正确答案:B解析: 3.

程序执行的结果是:()。 01 public class Answer { 02 public static void main(String[] args) { 03 int score = 20; 04 Answer ans= new Answer(); 05 ans.add(score); 06 System.out.println(" main:score = " + score); 07 } 08 void add(int score) { 09 System.out.println(" add:score=" + score++); 10 } 11

如何体现封装、继承、多态 编程人员看看

如何体现封装、继承、 编程人员看看! 如何体现封装、继承、多态 编程人员看看!! ! 什么事封装? 1. 保护数据成员, 不让类以外的程序直接访问或 修改,只能通过提供的公共的接口访问==>数据封 装。 2. 方法的细节对用户是隐藏的,只要接口不变, 内容的修改不会影响到外部的调用者==>方法封装。 3. 当对象含有完整的属性和与之对应的方法时称为 封装。 4. 从对象外面不能直接访问对象的属性, 只能通 过和该属性对应的方法访问。 5. 对象的方法可以接收对象外面的消息。 比如: Class A { private int prop; puplic int getProp() { return prop; }

public void setProp(int prop) { this.prop = prop; } } 属性 prop 是 private 的,外界不能直接访问, 但是外界可以通过调用 getProp()和 setProp()的方 法, 给对象发消息,从而完成某种功能。 什么事多态? 多态性的概念经常被说成事“一个接口,多种方 法”。这意味着可以为一组相关的动作作设计一个通 用 的接口。多态允许同一个接口被必于同一个类的多个 动作使用,这样就降低了程序的复杂性。再拿狗作比 喻, 一条狗的嗅觉是多态的。如果狗闻到猫的气味,它会 在吠叫并且追着它跑。如果狗闻到食物的气味,它将 分 泌唾液并向盛着食物的碗跑去。两种状况下同一种嗅 觉器官在工作,差别在于问到了什么气味,也就是有

两 种不同类型的数据作用于狗的鼻子!在 java 中,同一 个类中的 2 个或 2 个以上的方法可以有同一个名字, 只要 参数声明不同即可。在这种情况下,该方法就被称为 重载(Overload),这个过程称为方法重载(Method overloading)。方法重载是 java 实现多态的一种方 式。 有两种方式可以实现多态:* 1. 继承(子类继承父类(包括 abstract class,interf ace ect)) 2. 重载(同一个类中) 如果是面向对象程序设计的话,面向对象程序设 计中的另外一个重要概念是多态性。在运行时,通过 指向 基类的指针,来调用实现派生类中的方法。可以把一 组对象放到一个数组中,然后调用它们的方法,在这 种场 合下,多态性作用就体现出来了,这些对象不必是相 同类型的对象。当然它们都继承自某个类,你可以把 这些 派生类都放到一个数组中。如果这些对象都有同名方

C 的封装性、继承性和多态性概念

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. 接口重用:为了类在继承和派生的时候,保证使用家族中任一类的实例的某一属性时的正确调用。

实验三 继承、多态和图形用户界面

实验三字符串与文本 (上课被教师验收的同学不用提交实验结果,并注意在教师处签名。未完成的同学请提交实验结果,即将程序直接粘贴至本DOC文件,并在邮件名的标题中注明:学号+姓名+实验三) 1.给出下面程序的输出: 2.直接给出下面程序的运行结果: “B’s constructor is invoked” “A’s constructor is invoked” 2. 下面的说法对的注明“True”,错的注明“False” (1)子类是父类的一个子集。(f)(2)当从子类调用一个构造函数时,它的父类的无参构造方法总是被调用。(f)(3)可以覆盖定义在父类中的私有方法。( f) (4)可以覆盖定义在父类中的静态方法。( f) (5) 如果子类中的一个方法和它的父类中的方法具有完全相同的方法头,但返回值 类型不同,也可以构成覆盖。( f) (6) 可以给面板添加一个框架。( f) (7) 可以给框架添加一个面板。( t ) 3. 指出下面程序中的问题:

有四处错误 给radius和length赋值要用this. 调用父类的构造方法Circle()和getArea()前需要加上关键字super 4.下面的程序是要在框架中显示一个按钮,但是什么也没有显示出来。这个程序有什么问 题?

Test()中没有创建实例对象 将new javax.swing.JFrame() 改成new Test() 5.填空: (1)在类上使用default修饰符,才能使同一个包中的类可以访问它,而不同包中的类不能访问它。 (2)在类上使用protected 修饰符,才能使不同包中的类不能访问这个类,而任何包中的子类可以访问它。 6. 在程序清单11-9中,MyStack是用组合实现的,现请扩展ArrayList,利用继承来实现MyStack。编写一个测试程序,提示用户输入五个字符串,然后以逆序显示这些字符串。 package Test03; public class MyStack extends java.util.ArrayList { public Object peek() { return this.get(size() - 1); } public Object pop() { Object o = this.get(size() - 1); this.remove(size() - 1);

第七章继承多态练习题

第七章继承多态 一、选择题: 1、分析: class A { A() { } } class B extends A { //系统自动生成的构造方法和类的访问权限一样 } 哪两种说法是正确的? ( ) A:类B的构造方法是public的. B:类B的构造方法包含对this()的调用. C:类B的构造方法没有参数. D:类B的构造方法包含对super()的调用. 2、运行结果是:() class Base { Base() { System.out.print("Base"); } } public class Alpha extends Base { public static void main( String[] args ) { new Alpha(); new Base(); } } A: Base B: BaseBase C: 编译失败. D: 没有输出. E: 运行时异常. 3. 程序的运行结果是?() A: 编译失败. B: hello from a C: hello from b D: hello from b E: hello from a hello from a hello from b

4. 运行结果是:() class TestSuper { TestSuper(int i) { } } class TestSub extends TestSuper{ } class TestAll { public static void main (String [] args) { new TestSub(); } } A: 编译失败. B: 程序运行没有异常. C: 第7行抛出异常. D: 第2行抛出异常. 5. 程序的运行结果是?() A: 0 B: 1 C: 2 D: 编译失败. 6. 对于语句"B is a D" 和"B has a C",一下哪两种说法是正确的? ( ) A:D是B. B:B是D. C:D是C. D:B是C. E:D继承B. F:B 继承D. 7. 运行结果是?()

面向对象的三大特性(封装-继承-多态)

一丶封装 1 权限修饰符 可以用来修饰成员变量和成员方法,对于类的权限修饰只可以用public和缺省default。 被public修饰的类可以在任意地方被访问;default类只可以被同一个包内部的类访问。 权限由大到小:public protected default(不写) private 被private修饰的成员只能在本类中访问,外界不能访问 2 set()/get()方法 (1)this关键字 a.可以用来调用变量,方法,构造方法; b.this.xx 理解为调用当前类的xx。 (2)成员变量和局部变量 1)在类中的位置不同 a:成员变量:在类中,方法外 b:局部变量:在方法声明上(形式参数),或者是在方法定义中

2)在内存中的位置不同 a:成员变量:在堆内存 b:局部变量:在栈内存 3)生命周期不同 a:成员变量:随着对象的创建而存在,随着对象的消失而消失 b:局部变量:随着方法调用而存在,随着方法的调用结束而消失 4)初始化值不同 a:成员变量:有默认值 b:局部变量:必须初始化值,否则报错!(在使用它之前,没有初始化) (3)set()/get()方法 当成员变量被private修饰时,不在本类中无法直接访问,便需要set()/get()方法来解决这个问题 3 封装性 封装:是面向对象的第一大特性,所谓封装,就是值对外部不可见(一般而言被private修饰),外部只能通过对象提供的接口(如set()/get()方法)来访问。 封装的好处:a.良好的封装能够减少耦合;

b.类内部的结构可以自己修改,对外部影响不大; c.可以对成员进行更精准的控制(防止出现与事实不符的情况); d.影藏实现细节。 注意:在开发中,类的成员变量全部要进行封装,封装之后通过set()/get()方法访问。 二丶继承extends 1 实现:通过 class Zi extends Fu{} 实现类的继承 (1)子类继承父类,父类中声明的属性,方法,子类都可以获取到; 当父类中有私有的属性方法时,子类同样可以获取到,由于封装性的设计,使得子类不能直接调用访问。 (2)子类除了可以继承父类的结构外,还可以定义直接特有的成员变量,成员方法; (3)Java中类的继承只支持单继承,一个类只能继承一个父类,父类可以有多个子类,但是可以多层继承; (4)子类不能继承父类的构造方法,可以间接的通过super关键字去访问父类的构造方法(super();); 在子类的构造方法中如果没有显示的调用父类的构造方法,会默认调用父类的无参构造(所以最好父类都写有无参构造方法)。 子类继承父类的访问特点:首先父类进行初始化,然后子类进行初始化;多层访问! 2 方法的重写(区别重载) 子类继承父类以后,若父类的方法对子类不适用,那么子类可以对父类方法重写(override) 规则:1)要求子类方法的返回值类型方法名(参数列表)与父类方法一致; 2)子类方法的权限修饰符不能小于父类方法的修饰权限; 3)若父类方法抛异常,那么子类方法抛的异常类型不能大于父类; 注意: a.当子类重写了父类的方法以后,可以用 super.方法调用父类被重写的内容; b.子父类的方法必须同为static或同为非static。 class Fu{ private int i; public Fu(){ //无参构造 super();可以省略 super(); } public Fu(int i){ //有参构造

继承与多态实验报告

《高级Java编程技术》课程实验报告 院(系)名称:计算机学院专业班级:09计科 3 班 学号:姓名: 实验题目:实验10继承与多态 实验日期:2011/11/29实验(上机)学时:2 一、实验内容、要求 1.实验内容:计算课程成绩 2.要求: 编写应用程序,读入以下风格的文本文件,并显示最后的课程成绩,根据列出的公式,对于本科生和研究生,课程成绩的计算方法不同。输入的文本格式如下: (1)用单独的一行表示一个学生的信息。 (2)每行使用下面的格式: 其中,指明学生是研究生,还是本科生;指明学 生的姓和名;指明是第i次测试成绩。 (3)“END”指明输入的结束。字母的大小写不重要。 公式如下: 学生类型评分方案 本科生通过,如果(test1+test2+test3)/3>=70 研究生通过,如果(test1+test2+test3)/3>=80 实现一个类完成以下功能: (1)读入输入文本文件。

(2)计算课程成绩。 (3)输出结果。 我们将用五个增量步骤开发此程序: (1)以程序结构开始,定义ComputeGrades类的框架。 (2)实现printResult方法,定义实现printResult所必需的任何其他方法。 (3)实现computerGrades方法,定义实现computerGrades所必需的任何其他方法。 (4)实现readDate方法,定义实现readDate所必需的任何其他方 法。 (5)最后完成并改进。 二、所采用的数据结构 如:线性表,二叉树,树,图等。你在此用到了啥样的数据结构就写啥。无数据结构。 三、实验的主要模块(或函数)及其功能 函数分块及各块主要功能的文字描述 ComputGrades类:这是本程序的主类,且是MainWindow的子类。MainWindows本身是Jframe的子类,并且又将其自身放在屏幕中间的功能。ComputGrades类包含的方法如下: 1、构造方法。生成任意大小的数组,让程序员在构造方法中传递数组的 大小,不在构造方法中生成数组。 2、printResult方法。将学生信息机计算出来的成绩输出到OutputBox

JAVA面向对象基础测试题-继承-封装-多态等测试题教程文件

J A V A面向对象基础测试题-继承-封装-多 态等测试题

JAVA面向对象基础测试题 提示:本题为第一阶段,JAVA面向对象基础部分练习题,包括对象,类,继承,封装,多态,接口,内部类等等,java核心基础,适合初学者对面向对象基础的知识进行测试,以便查漏补缺。 1. 程序执行的结果是:()。 01 public class Point{ 02 int y = 7; 03 public void step(int y) { 04 y += y; 05 System.out.println(y); 06 } 07 public static void main(String[] args) { 08 Point p = new Point(); 09 p.step(10); 10 } 11 } A.14 B.20 C.10 D.17 正确答案:B解析: 2. 程序的执行结果是:()。 01 public class Question { 02 private int num; 03 public static void main(String [] args){ 04 Question q = new Question();

q.num=13; 06 update(q); 07 System.out.println(q.num); 08 } 09 public static void update(Question q){ 10 q.num=9; 11 } 12 } A.13 B.9 C.0 D.4 正确答案:B解析: 3. 程序执行的结果是:()。 01 public class Answer { 02 public static void main(String[] args) { 03 int score = 20; 04 Answer ans= new Answer(); 05 ans.add(score); 06 System.out.println(" main: score = " + score); 07 } 08 void add(int score) { 09 System.out.println(" add: score=" + score++); 10 } 11

Java为什么要继承、封装和多态

为什么要继承、封装和多态 1,为什么要继承 继承的好处是代码重用.哲学上讲事物都是有共性和特性的.把共性函数代码放入到父类中,把特性函数代码放入到子类中,当然是否共性要以参照点的标准.OO中所谓的抽象我自己理解为哲学中的共性在同一个行业中,他们各业务流程往往有很大的相似性,但往往我们都是到一个项目中就重新写一套流程代码,或者粘贴以前的代码.可能有很多代码都是以前写过的重复代码.造成重复劳动.如果采用继承应该这样,首先在父类中做一个基本上大部分行业项目都必要的简洁的主流程.在子类中针对具体项目的特殊性做主流程充分的完善的补充.这样在每个项目中,只针对项目的特殊性编写代码,大大降低重复劳动.当然根据具体流程的复杂多可以划分多的继承层次,呈现一种继承的树结构,但一定的要保证层次一定要有实际的意义. 2,为什么要封装 高内聚低偶合的思想简单的理解同一模块内的提高内聚,不同模块降低偶合.如果说一个类代表一个模块或是一个业务流,那么A类内部要提高内聚,类的属性可以看成是内的局部变量.提高数据的重用.公共函数尽量能被其他主函数,尽量达到功能内聚.如果说是A类和B类,并且是不同模块(也许是同一个模块下的两个子模块),那么B 是不能使用A的函数和属性的,紧进行数据偶合.封装的作用就体现在这里.

再现实中就项目中经常遇到这种情况,某项业务增加或修改一种类型的业务流,自己本身调试成功了,但是缺影响了此业务下其他的业务流,不得不测试所有得其他原本正常的业务流并不得不针对此做类型判断的补丁,这种补丁很肯能导致程序结构的不合理. 3.为什么要多态 个人认为多态的好处体现在代码的可扩充性,比如一个业务有多个业务流,为了区别不同的类型就的使用判断,那么新添加一个流程就得在过程执行主流程(往往是final,必然是面向过程的)中添加一个”if then”或是重载一个函数 在目前项目中mvc得控制器就是典型的多态.想想如果我们不使用多态那么怎么办?因为对PO对象是新添加的,那么必须针对新的PO 对象在代码中做IF判断,才能用他本身的对象类型指向他.造成过程执行主流程不断的要变更自己的代码. 总结: OO中继承和多态互相依赖又互相矛盾,没有继承就不可能有多态,多态的使用往往又在面向过程的代码中.继承是使子类可以使用父类的功能,而多态使父类能使用子类的功能. OO并非只是在编码阶段来处理,实际上在概要设计,详细设计,数据库设计的时候就应该OO的思想来设计.提高软件可重用性和可扩充性.对于想对一个行业做标准化产品软件而言,很重要.

第7课件 封装、继承和多态(4学时 19-22)

第七讲义面向对象——类 几种设计模式: 1. 当创建一个对象,若不想让对象的内容(私有成员变量)发生变化,则需要满足以下条件 (1) 所有数据域都是私有的;(2)没有修改方法setMethod;(3)没有一个访问器方法会返回一个指向可变数据域的引用。不可变类/对象例如:String类 2. 为了防止用户创建某个类的对象,则应该定义该类的私有构造方法。例如:Math类 3. 当只允许某个类只能创建一个实例时,称为单例模式。 一、类的封装 方法的抽象;类的抽象;(将方法的实现和使用分开| 将类的实现和使用分开) 类的用户&类的开发者 二、类的继承和多态(2个学时) 继承是java在软件重用方面最重要的特征。能有效避免代码冗余,使系统易于理解和维护、子类继承于父类,UML图表示,次类——超类,或继承类—基类。 当子类继承父类的时候,子类可以继承父类的所有成员跟方法,继承下来不代表可以访问,要访问得看访问控制规则。私有属性也可以继承,不过根据访问控制规则,私有属性虽继承下来却不可以访问的,只有通过public的方法访问继承下来的私有属性。 B继承A类,C继承B类。A类中的私有属性,到了C会怎么样,能继承、访问吗?答案是:如果A中的属性有增加setget方法,可以访问的。举例 public class A { private int a; public int getA(){ return a; } public void setA(int a){ this.a=a; } } public class B extends A{ private int b; public int getB() { return b; } public void setB(int b) { this.b = b; } } public class C extends B { private int c; public int getC() { return c; }

对多态性和继承的理解

C#中的继承符合下列规则: 1、继承是可传递的。如果C从B中派生,B又从A中派生,那么C不仅继承了B中声明的成员,同样也继承了A中的成员。Object 类作为所有类的基类。 2、派生类应当是对基类的扩展。派生类可以添加新的成员,但不能除去已经继承的成员的定义。 3、构造函数和析构函数不能被继承。除此以外的其它成员,不论对它们定义了怎样的访问方式,都能被继承。基类中成员的访问方式 只能决定派生类能否访问它们。 4、派生类如果定义了与继承而来的成员同名的新成员,就可以覆盖已继承的成员。但这并不因为这派生类删除了这些成员,只是不能再 访问这些成员。 5、类可以定义虚方法、虚属性以及虚索引指示器,它的派生类能够重载这些成员,从而实现类可以展示出多态性。 6、派生类只能从一个类中继承,可以通过接吕实现多重继承。 多态性 在C#中,多态性的定义是:同一操作作用于不同的类的实例,不同的类将进行不同的解释,最后产生不同的执行结果。C#支持两种类型的多态性: ●编译时的多态性 编译时的多态性是通过重载来实现的。对于非虚的成员来说,系统在编译时,根据传递的参数、返回的类型等信息决定实现何种操作。 ●运行时的多态性 运行时的多态性就是指直到系统运行时,才根据实际情况决定实现何种操

作。C#中,运行时的多态性通过虚成员实现。 编译时的多态性为我们提供了运行速度快的特点,而运行时的多态性则带来了高度灵活和抽象的特点。 2、实现多态 多态性是类为方法(这些方法以相同的名称调用)提供不同实现方式的能力。多态性允许对类的某个方法进行调用而无需考虑该方法所提供的特定实现。可以用不同的方式实现组件中的多态性: ●接口多态性。 ●继承多态性。 ●通过抽象类实现的多态性。 接口多态性 多个类可实现相同的“接口”,而单个类可以实现一个或多个接口。接口本质上是类需要如何响应的定义。接口描述类需要实现的方法、属性和事件,以及每个成员需要接收和返回的参数类型,但将这些成员的特定实现留给实现类去完成。组件编程中的一项强大技术是能够在一个对象上实现多个接口。每个接口由一小部分紧密联系的方法、属性和事件组成。通过实现接口,组件可以为要求该接口的任何其他组件提供功能,而无需考虑其中所包含的特定功能。这使后续组件的版本得以包含不同的功能而不会干扰核心功能。其他开发人员最常使用的组件功能自然是组件类本身的成员。然而,包含大量成员的组件使用起来可能比较困难。可以考虑将组件的某些功能分解出来,作为私下实现的单独接口。 根据接口来定义功能的另一个好处是,可以通过定义和实现附加接口增量地将功能添加到组件中。优点包括:

封装,继承,多态,抽象,接口

1.1封装 封装是面向对象编程的三大特征之一。封装就是将通过抽象得到的属性和方法相结合,形成一个有机的整体——“类”。封装的目的是增强数据安全性和简化编程,使用者不必了解具体的实现细节,所有对数据的访问和操作都必须通过特定的方法,否则便无法使用,从而达到数据隐藏的目的。 封装是面向对象编程语言对客观世界的模拟,客观世界的属性都是被隐藏在对象内部的,外界不能直接进行操作或者修改。譬如:常见的空调电视机等对象,这些对象都是封装好的,普通人只可以通过对小小的按钮操作来控制这些家电;不可以随意打开设备进行修改对象内容的配置。但是专业人员可以修改这些家电,而我们就是要做这些“专家”;如下图所示。 操作按钮 操作按钮 图1.1.1 封装对象 1.1.1为什么需要封装 通过第一阶段的学习,我们知道类由属性和方法组成,在类的外部通过本类的实例化对象可以自由访问和设置类中的属性信息,这样不利于属性信息的安全,示例1.1就是如此。示例1.1 public class Person { public String name; public int age; public void sayHello(){ System.out.print("你好!"); } } public class Test { public static void main(String[] args) { Person p=new Person(); https://www.doczj.com/doc/f95760450.html,="皇帝"; p.age=1000;//属性信息可以直接设置 p.sayHello();

} } 上述代码在第一阶段Java的课程中经常见到,大致一看没什么问题,但是仔细分析过之后会发现:把年龄设置成1000合理吗? 由于Person类的属性都是公有的(public),那也就意味着在Person类的外部,通过Person类的实例化对象可以对这些公有属性任意修改,这就使得我们无法对类的属性进行有效的保护和控制。这属于设计上的缺陷,那能不能避免这种情况呢?这就需要用到下面的封装了。 1.1.2现实生活中的封装 现实生活中封装的例子随处可见,例如药店里出售的胶囊类药品,我们只需要知道这个胶囊有什么疗效,怎么服用就行了,根本不用关心也不可能去操作胶囊的药物成分和生产工艺。再例如家家户户都用的电视机,我们只需要知道电视机能收看电视节目,知道怎么使用就行了,不用关心也不可能去搞清楚电视机内部都有哪些硬件以及是如何组装的。这些都是现实生活中封装的例子。 在刚才的两个例子中,我们可以认为药物成分是胶囊的属性,但是用户不需要也不可能去操作它。我们也可以认为内部硬件是电视机的属性,但是用户也不需要去操作它。这就是现实生活中封装的特征,程序中的封装与此类似。 1.1.3程序中的封装 封装就是:将对象的状态信息隐藏在对象内部,不允许外部程序直接访问对象内部的信息,而是通过该类所提供的方法来实现对内部信息的操作和访问。简而言之,封装就是将类的属性私有化,并提供公有方法访问私有属性的机制,我们看示例1.2。 示例1.2 public class Person{ //将属性使用private修饰,从而隐藏起来 private String name; private int age; public void sayHello() { System.out.print("你好!"); } } public class Test { public static void main(String[] args) { Person p=new Person(); https://www.doczj.com/doc/f95760450.html,="杰克"; //编译报错 p.age=1000; //编译报错 p.sayHello(); } }

相关主题
文本预览
相关文档 最新文档