JAVA基础第章继承与多态练习题.docx
《JAVA基础第章继承与多态练习题.docx》由会员分享，可在线阅读，更多相关《JAVA基础第章继承与多态练习题.docx（18页珍藏版）》请在冰豆网上搜索。
JAVA基础第章继承与多态练习题
第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．D．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方法中输出“咿咿呀呀......”的信息。
2）People类是类人猿的子类，在Peop
升级会员 