JAVA基础 第4章继承与多态练习题10.docx
《JAVA基础 第4章继承与多态练习题10.docx》由会员分享，可在线阅读，更多相关《JAVA基础 第4章继承与多态练习题10.docx（18页珍藏版）》请在冰豆网上搜索。
JAVA基础第4章继承与多态练习题10
第4章继承与多态
一．选择题
1、编译与运行以下两文件结果就是（D）。
//文件P1、java
packageMyPackage;
classP1{
voidafancymethod（）{
System、out、println（"Whatafancymethod"）;
}
}
//文件P2、java
packageYourPackage;
importMyPackage、*;
publicclassP2extendsP1{
publicstaticvoidmain（Stringargv[]）{
P2p2=newP2（）;
p2、afancymethod（）;
}
}
A.两个均通过编译,P2运行时输出Whatafancymethod
B.没一个通过编译
C.两个均通过编译,但P2运行时出错
D.P1通过编译,但P2出现编译错误
2.下列程序运行的结果就是（A）。
packagea;
packageb;
publicclassD{
publicstaticvoidmain（Stringargs[]）{
System、out、println（"^_^,今天心情不错！
"）;
}
}
A.出现编译错误
B.^_^,今天心情不错！
C.通过编译,运行时出错
D.以上都不对
3.Java的核心类库中哪个包,Java系统能自动引入（B）。
A.java、ioB.java、lang
C.java、netD.java、util
4.下列程序运行结果就是（A）。
privateclassBase{
Base（）{
inti=100;
System、out、println（i）;
}
}
publicclassPriextendsBase{
staticinti=200;
publicstaticvoidmain（Stringargv[]）{
Prip=newPri（）;
System、out、println（i）;
}
}
A.编译错误B.200C.100200D.100
5.下列程序运行结果就是（C）。
classBase{
Base（）{
inti=100;
System、out、println（i）;
}
}
publicclassPriextendsBase{
staticinti=200;
publicstaticvoidmain（Stringargv[]）{
Prip=newPri（）;
System、out、println（i）;
}
}
A.编译错误B.200C.100200D.100
6.如何定义一个不能有子类的类Key（B）。
A.classKey{}B.finalclassKey{}
C.publicclassKey{}D.classKey{finalinti;}
7.哪个选项可以做为以下方法的覆盖方法（A）。
publicvoidadd（inta）{…}
A.publicvoidadd（intb）{…}B.voidadd（inta）{…}
C.publicintadd（inta）{…}D.publicvoidadd（floata）{…}
8.在子类构造方法的哪个地方可以调用超类的构造方法（B）。
A.任何地方
B.构造方法的第一条语句
C.构造方法的最后一条语句
D.不能在子类构造方法中调用超类的构造方法
9.下列程序的运行结果就是（C）。
publicclassTest{
publicstaticvoidtest（）{
this、print（）;
}
publicstaticvoidprint（）{
System、out、println（"Test"）;
}
publicstaticvoidmain（Stringargs[]）{
test（）;
}
}
A.输出Test
B.无输出结果
C.类编译错误,指示不能在static上下文中使用this
D.以上都不对
10.设有如下代码:
1、classExample{
2、Stringstr;
3、Example（）{
4、str="example";
5、}
6、Example（Strings）{
7、str=s;
8、}
9、}
10、classDemoextendsExample{
11、}
12、publicclassTest{
13、publicvoidf（）{
14、Exampleex=newExample（"Good"）;
15、Demod=newDemo（"Good"）;
16、}
17、}
以下哪行将导致错误（D）。
A.第3行B.第6行C.第10行D.第15行
11.在Java中,如下的修饰符不就是访问控制修饰符（A）。
A.staticB.publicC.protectedD.private
12.试完成下述程序片段（D）。
publicclassPoint{
intx,y;
publicPoint（intx,inty）{
（）=x;
（）=y;
}
、、、
}
A.Point、xPoint、y
B.无解
C.x1y1
D.this、xthis、y
13.在JAVA中（C）。
A.一个子类可以有多个父类,一个父类也可以有多个子类
B.一个子类可以有多个父类,但一个父类只可以有一个子类
C.一个子类只可以有一个父类,但一个父类可以有多个子类
D.上述说法都不对
14.什么就是在子类中创建一个与父类具有一样特征的方法,特征包括方法名字,参数个数,参数类型与方法返回值类型（A）。
A.覆盖（overloading）B.重载（overriding）C.继承（inheritance）D.none
15.哪个关键词在子类中用来访问与父类中一样的方法（A）。
A.superB.thisC.staticD.以上没有
16.哪个关键词用来引用当前类的对象（B）。
A.superB.thisC.staticD.以上没有
17.哪个修饰符定义的方法与变量只在定义它们的类中可见,而在其她的任何类中它们都不可见（C）。
A.protectedB.publicC.privateD.noneoftheabove
18.1、classPerson{
2、publicvoidprintValue（inti,intj）{//、、、}
3、publicvoidprintValue（inti）{//、、、}
4、}
5、publicclassTeacherextendsPerson{
6、publicvoidprintValue（）{//、、、}
7、publicvoidprintValue（inti）{//、、、}
8、publicstaticvoidmain（Stringargs[]）{
9、Persont=newTeacher（）;
10、t、printValue（10）;
11、}
12、}
第10行将调用的会就是哪个方法（D）。
A.online2B.online3C.online6D.online7
19.以下代码运行结果就是（C）。
classBase{}
classSubextendsBase{}
classSub2extendsBase{}
classCEx{
publicstaticvoidmain（Stringargv[]）{
Baseb=newBase（）;
Subs=（Sub）b;
}
}
A.编译通过B.编译错误C.运行异常D.以上都不对
20.设有如下类定义:
classBaseWidget{
Stringname="BaseWidget";
voidspeak（）{
System、out、println（"Iama"+name）;
}
}
classTypeAWidgetextendsBaseWidget{
TypeAWidget（）{
name="TypeA";
}
}
以下哪段代码将正确编译与执行（B）。
A.Objecta=newBaseWidget（）;a、speak（）;
B.BaseWidgetb=newTypeAWidget（）;b、speak（）;
C.TypeAWidgetc=newBaseWidget（）;c、speak（）;
D.以上都不对
21.设有文件Derived、java中代码如下、
publicclassBaseextendsObject{
StringobjType;
publicBase（）{
objType="IamaBasetype";
}
}
publicclassDerivedextendsBase{
publicDerived（）{
objType="IamaDerivedtype";
}
publicstaticvoidmain（Stringargs[]）{
DerivedD=newDerived（）;
}
}
编译程序将出现何问题（B）。
A.将创建Base、class与Derived、class两个文件
B.编译程序将指示第1行有问题
C.编译程序将在第7行出错
D.以上都不对
22.哪种访问组合可放在第3行aMethod前与第8行的aMethod前（C）。
1、classSuperDuper
2、{
3、voidaMethod（）{}
4、}
5、
6、classSubextendsSuperDuper
7、{
8、voidaMethod（）{}
9、}
A.line3:
public;line8:
private
B.line3:
protected;line8:
private
C.line3:
private;line8:
protected
D.line3:
public;line8:
protected
23.以下类:
1、publicclassBase{
2、publicvoidmethod（inti）{
3、System、out、print（"Valueis"+i）;
4、}
5、}
1、classSubextendsBase{
2、publicvoidmethod（intj）{
3、System、out、print（"Thisvalueis"+j）;
4、}
5、publicvoidmethod（Strings）{
6、System、out、print（"Iwaspassed"+s）;
7、}
8、publicstaticvoidmain{Stringargs[]）{
9、Basebl=newBase（）;
10、Baseb2=newSub（）;
11、bl、method（5）;
12、b2、method（6）;
13、}
14、}
Sub类的main方法的执行结果为（C）。
A.Valueis5Valueis6
B.Thisvalueis5Thisvalueis6
C.Valueis5Thisvalueis6
D.Thisvalueis5Valueis6
24.下列程序的运行的结果就是（A）。
classparent{
voidtest（）{
System、out、print（"parent"）;
}
}
publicclasschildextendsparent{
voidtest（）{
super、test（）;
System、out、print（"child"）;
}
publicstaticvoidmain（Stringargs[]）{
childx=newchild（）;
x、test（）;
}
}
A.parentchildB.childC.parentD.childparent
25.下列程序的运行的结果就是（D）。
classparent{
parent（Strings）{
s="parent";
}
voidtest（）{
System、out、print（"parent"）;
}
}
publicclasschildextendsparent{
voidtest（）{
super、test（）;
System、out、print（"child"）;
}
publicstaticvoidmain（Stringargs[]）{
childx=newchild（）;
x、test（）;
}
}
A.parentchildB.childC.parentD.编译错误
26.下列程序的运行的结果就是（D）。
classparent{
parent（Strings）{
s="parent";
}
voidtest（）{
System、out、print（"parent"）;
}
}
publicclasschildextendsparent{
child（Strings）{
s="child";
}
voidtest（）{
super、test（）;
System、out、print（"child"）;
}
publicstaticvoidmain（Stringargs[]）{
childx=newchild（）;
x、test（）;
}
}
A.parentchildB.childC.parentD.编译错误
27.瞧下列程序
packagea;
classparent{
privateinti=20;
protectedintj=30;
publicintk=40;
inth=50;
}
classchildextendsparent{
voidf（）{}
}
在子类child的方法f（）中不可以操作的变量就是（A）。
A.iB.jC.kD.h
28.瞧下列程序
packagea;
publicclassparent{
privateinti=20;
protectedintj=30;
publicintk=40;
inth=50;
}
packageb;
importa、parent;
classchildextendsparent{
voidf（）{}
}
在子类child的方法f（A）中不可以操作的变量就是（D）。
A.iB.jC.kD.h
29.瞧下列程序
packagea;
classparent{
privateinti=20;
protectedintj=30;
publicintk=40;
inth=50;
}
classchild1extendsparent{}
classchild2extendschild1{
voidf（）{}
}
在子类child2的方法f（）中不可以操作的变量就是（A）。
A.iB.jC.kD.h
30.如下类的声明:
classA{}
则类A的父类就是（C）。
A.没有父类B.本身C.ObjectD.Lang
31.下列程序的运行结果就是（C）。
classparent{
inti=20;
intj=30;
voidf（）{
System、out、print（""+i）;
}
}
classchildextendsparent{
inti=30;
intk=40;
voidf（）{
System、out、print（""+i）;
}
voidg（）{
System、out、print（""+k）;
}
publicstaticvoidmain（Stringargs[]）{
parentx=newchild（）;
System、out、print（x、i）;
x、f（）;
childx1=（child）x;
System、out、print（""+x1、i）;
x1、f（）;
}
}
A.30303030B.20202020C.20303030D.都不对
32.什么样的方法不能被重写（B）。
A.私有方法
B.最终方法（final方法）
C.受保护的方法
D.都不对
33.如果一个成员变量声明时必须赋给初值,而且不能再发生变化,那么这个成员变量就是（B）。
A.私有变量
B.最终变量（常量）
C.受保护的变量
D.都不对
34.关于重载与重写的叙述正确的就是（D）。
A.重载就是多态的一种,而重写不就是
B.重载就是子类中定义的方法与父类中某个方法相同
C.重写就是一个类中多个同名的方法,并且方法的参数不同
D.重写方法时不允许降低方法的访问权限
二.编程题
1．创建2个包:
a与b。
在包a中编写一个公共类A,类A中有:
2个publicdouble类型的属性c、d;一个构造方法publicA（doublex,doubley）对c,d进行初始化;还有一个方法publicdoubleadd（）返回c与d的与。
在包b中编写一个主类B,在类B的main方法中创建类A的对象e,
并用对象e调用方法add求2个数的与。
1.packagea;
publicclassA{
publicdoublec,d;
publicA（doublex,doubley）{
c=x;
d=y;
}
publicdoubleadd（）{
returnc+d;
}
}
packageb;
importa、A;
classB{
publicstaticvoidmain（String[]args）{
Ae=newA（1,2）
System、out、println（"两个数之与:
"+e、add（））;
}
}
2、编写一个类A,该类创建的对象可以调用方法f输出小写的英文字母表。
然后再编写一个A类
的子类B,要求子类B必须继承A类的方法f（不允许重写）,子类B创建的对象不仅可以调
用方法f输出小写的英文字母表,而且可以调用子类新增的方法g输出大写的英文字母表。
最后编写主类C,在主类的main方法中测试类A与类B。
2.classA{
voidf（）{
System、out、println（"A输出小写的英文字母表:
"）;
charc;
for（c='a';c<='z';c++）{
System、out、print（""+c）;
}
System、out、println（）;
}
}
classBextendsA{
voidg（）{
charc;
System、out、println（"B输出大写的英文字母表:
"）;
for（c='A';c<='Z';c++）
System、out、print（""+c）;
System、out、println（）;
}
}
classC{
publicstaticvoidmain（Stringargs[]）{
Aa=newA（）;
Bb=newB（）;
a、f（）;
b、f（）;
b、g（）;
}
}
3.编写一个Java应用程序,该程序包括3个类:
A类、B类与主类E。
其中类B就是类A的子类,
在子类B中新增了成员变量与成员方法,并且隐藏了父类A的成员变量与重写了父类A的成员
方法。
在主类E的main方法中,创建类B的对象并赋给父类A的对象a,使用上转型对象a
来测试上转型对象的一些特性。
3.classA{
inti=1;
intj=10;
voida（）{
System、out、println（"aofA"）;
}
voidb（）{
System、out、println（"bofA"）;
}
}
classBextendsA{
intj=20;
intk=200;
voidb（）{
System、out、println（"bofB"）;
}
voidc（）{
System、out、println（"cofB"）;
}
}
classE{
publicstaticvoidmain（String[]args）{
Aa=newB（）;
System、out、println（"a、i="+a、i）;//extends
System、out、println（"a、j="+a、j）;//隐藏
a、a（）;//extends
a、b（）;//重写
}
}
4.编写一个Java应用程序,该程序包括3个类:
类人猿类、People类与主类E。
要求:
1）类人猿中有个构造方法:
类人猿（Strings）,并且有个publicvoidspeak（）方法,在
speak方
升级会员 