java复习题库习题31习题36.docx
《java复习题库习题31习题36.docx》由会员分享，可在线阅读，更多相关《java复习题库习题31习题36.docx（17页珍藏版）》请在冰豆网上搜索。
java复习题库习题31习题36
第三章面向对象程序设计
一、选择题
1. 下列不属于面向对象编程的三个特征的是（B）
A. 封装B. 指针操作
C. 多态性D. 继承
2. 类所实现的接口以及修饰不可以是（D）
A. public
B. abstract
C. final
D. void
3. 下列类的定义，错误的是（D）
A. publicclasstestextendsObject{
……
}
B. finalclassoperators{
……
}
C. classPoint{
……
}
D. voidclassPoint{
……
}
4. 关键字supper的作用是（D）
A. 用来访问父类被隐藏的成员变量
B. 用来调用父类中被重载的方法
C. 用来调用父类的构造函数
D. 以上都是
5. 关于对象的删除，下列说法正确的是（C）
A. 必须由程序员完成对象的清除
B. java把没有引用的对象作为垃圾收集起来并释放
C. 只有当程序中调用System.gc（）方法时才能进行垃圾收集
D. java中的对象都很小，一般不进行删除操作。
二、填空题
1. 把对象实例化可以生成多个对象，使用____new_____运算符为对象分配内存空间。
2. java程序引入接口的概念，是为了弥补只允许类的____单继承____的缺憾。
3. java语言以___类____为程序的基本单位，它是具有某些共同特性实体的集合，是一种抽象的概念。
4. 抽象方法只能存在于抽象类中。
抽象方法用关键字___abstract_____来修饰。
5. java语言中____Object___是所有类的根.
6. 在java中有一种叫做_____构造函数__的特殊方法,在程序中用它来对类成员进行初始化.
7. new是___创建___对象的操作符.
8. 我们在java程序中,把关键字____super____加到方法名称的前面,来实现子类调用父类的方法
9. 在java程序里,同一类中重载的多个方法具有相同的方法名和_不同的____的参数列表.重载的方法可以有不同的返回值类型
10. java语言通过接口支持__多重____继承,使类继承具有更灵活的扩展性
11. java语言中,调用方法时,参数传递是___值___调用,而不是地址调用
12. 接口是一种只含有抽象方法或___常量___的一种特殊抽象类
一、填空题
1.在子类中使用关键字_______做前缀可调用被子类覆盖的父类中的方法。
2.Java中所有类都是_______类的子类。
3.通过_______运算符就能实现对对象成员变量的访问和对象方法的调用。
4.类的构造方法的名称必须与_______名相同。
5.类方法只能处理用关键字_______修饰的对象。
二、选择题
1.对象使用时，下面描述错误的是（）
A.通过“.”运算符调用成员变量和方法
B.通过成员变量的访问权限设定限制自身对这些变量方法的调用
C.将一个对象申明为类的成员时，必须在使用前为其分配内存
D.在方法中使用对象作为参数时，采用引用调用
2.定义一个名为“MyClass”的类，并且该类可被一个工程中的所有类访问，那么该类的正确声明应为：
（）
A.privateclassMyClassextendsObjectB.classMyClassextendsObject
C.publicclassMyClassD.privateclassMyClassextendsObject
3.Java中访问限定符不包括（）
A.publicB.privateC.defaultD.final
4.构造方法何时被调用（）
A.类定义时B.创建对象时C.调用对象方法时D.使用对象的变量时
5.如果任何包中的子类都能访问超类中的成员，那么应使用哪个限定词（）
A.publicB.privateC.protectedD.transient
三、程序阅读题
1.编译并运行下面的程序，运行结果为（）
publicclassT1
{
publicstaticvoidmain（String[]args）
{
T1a=newT1（）;
a.method（8）;
a.method（1.2f）;
}
voidmethod（floati）
{
System.out.println（"float:
"+i）;
}
voidmethod（longi）
{
System.out.println（"long:
"+i）;
}
}
（2）定义类A和类B如下：
classA
{
inta=1;
doubled=2.0;
voidshow（）
{
System.out.println（"ClassA:
a="+a+"\td="+d）;
}
}
classBextendsA
{
floata=3.0f;
Stringd="Javaprogram.";
voidshow（）
{
super.show（）;
System.out.println（"ClassB:
a="+a+"\td="+d）;
}
}
（1）若在应用程序的main方法中有以下语句：
Aa=newA（）;
a.show（）;
则输出的结果如何？
（2）若在应用程序的main方法中定义类B的对象b：
Ab=newB（）;
b.show（）;
则输出的结果如何？
四、简答题
1.什么是类？
什么是对象？
类和对象有何联系？
2.方法的重载和方法的覆盖有什么不同？
3.类变量和实例变量有何区别？
4.抽象类和抽象方法有什么特点？
答案：
一、1.super2.Object3.圆点4.类5.static
二、1.B2.C3.D4.B5.C
三、程序阅读题
1.答：
程序可以编译运行，输出结果为：
long:
8float:
1.2
3.答：
ClassA:
a=1d=2.0
ClassA:
a=1d=2.0
ClassB:
a=3.0d=Javaprogram.
四、简答题
1.答：
在面向对象程序设计里，类是定义一个对象的属性和方法的蓝本。
对象就是一组变量和相关方法的集合，其中变量表明对象的状态，方法表明对象所具有的行为。
类是对象的模板，对象是类的实例，可以从一个类中创建许多对象。
2.答：
方法重载，指的是在类中创建多个具有相同名称，但使用不同参数的方法，Java虚拟机根据传递给方法的参数个数和类型决定调用哪个重载方法。
方法的覆盖指在子类中重新定义父类中已有的方法，对于重写的方法，运行时系统根据调用该方法的实例的类型来决定选择哪个方法调用。
3．答：
由static修饰的变量称为类变量，当系统在程序中第一次遇到一个类时，便会拷贝一份所有的类变量在内存里。
然后那些由此类产生的实例便可分享这些类变量。
实例变量指不是用static修饰的变量，可供实例方法使用。
实例变量会复制于每一个从类产生的实例中。
4.答：
①一个抽象类里可以没有抽象方法，但含有抽象方法的类必定为抽象类。
②抽象类不能被实例化为对象，而只能作为其它类的超类，并且必须被继承。
③若某子类继承自一个抽象类，而该子类不是抽象类，则子类需用覆盖的方式来实例化超类中的所有抽象方法。
抽象方法可再与public、protected复合使用，但不能与final、private和static复合使用。
④抽象方法只有方法声明，不能有方法体。
一、判断题
1.内部类可以访问外层类的任何变量，包括私有的。
（）
2.匿名类可以有构造器,声明时候不能带参数。
（）
3.抽象方法可以是static的。
（）
4.构造器没有任何返回类型，哪怕是void也不行。
（）
5.只要类中显式地定义一个，那么Java不会再为你定义一个默认的构造器。
（）
6.构造方法可以被继承。
（）
7.方法的参数变量不能是final的（）
8.一个Java类可以有多个父类，这称作多继承．（）
二、简答题
1.Java的成员变量修饰符有哪几种？
其中哪种修饰符限定的范围最大？
2.写出下列关键字的意义和运用场合：
①final；②finalize；③finally。
答案：
一、1.T2.F3.F4.T5.T6.F7.F8.F
二、1.答：
成员变量的修饰符有public、protected、private、static、final、transient、volatile七种。
Public修饰符的限定范围最大。
2.答：
final,finally,finalize的区别如下：
final用于声明属性、方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。
finally是异常处理语句结构的一部分，表示总是执行。
finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资源回收，例如关闭文件等。
一、判断程序段
1.abstractclassName{
privateStringname;
publicabstractbooleanisStupidName（Stringname）{}
}
2.abstractclassSomething{
privateabstractStringdoSomething（）;
}
3.publicclassSomething{
publicintaddOne（finalintx）{
return++x;
}
}
4.publicclassSomething{
publicstaticvoidmain（String[]args）{
Othero=newOther（）;
newSomething（）.addOne（o）;
}
publicvoidaddOne（finalOthero）{
o.i++;
}
}
classOther{
publicinti;
}
5.classSomething{
inti;
publicvoiddoSomething（）{
System.out.println（"i="+i）;
}
}
二、下面代码编译和运行的结果是什么？
1.classValue{
publicinti=15;
}
publicclassTest{
publicstaticvoidmain（Stringargv[]）{
Testt=newTest（）;
t.first（）;
}
publicvoidfirst（）{
inti=5;
Valuev=newValue（）;
v.i=25;
second（v,i）;
System.out.println（v.i）;
}
publicvoidsecond（Valuev,inti）{
i=0;
v.i=20;
Valueval=newValue（）;
v=val;
System.out.println（v.i+""+i）;
}
}
A.15020B.15015C.20020D.01520
2.classFatherClass{publicFatherClass（）{System.out.println（"FatherClassCreate"）;}}publicclassChildClassextendsFatherClass{publicChildClass（）{System.out.println（"ChildClassCreate"）;}publicstaticvoidmain（String[]args）{FatherClassfc=newFatherClass（）;ChildClasscc=newChildClass（）;}}
3.publicclassStatic{
static{
intx=5;
}
staticintx,y;
publicstaticvoidmain（Stringargs[]）{
x--;
myMethod（）;
System.out.println（x+y+++x）;
}
publicstaticvoidmyMethod（）{
y=x+++++x;
}
}
A.编译错误B.输出１C.输出２D.输出３
4.classMyParent{
intx,y;
MyParent（intx,inty）{
this.x=x;
this.y=y;
}
publicintaddMe（intx,inty）{
returnthis.x+x+y+this.y;
}
publicintaddMe（MyParentmyPar）{
returnaddMe（myPar.x,myPar.y）;
}
}
classMyChildextendsMyParent{
intz;
MyChild（intx,inty,intz）{
super（x,y）;
this.z=z;
}
publicintaddMe（intx,inty,intz）{
returnthis.x+x+this.y+y+this.z+z;
}
publicintaddMe（MyChildmyChi）{
returnaddMe（myChi.x,myChi.y,myChi.z）;
}
publicintaddMe（intx,inty）{
returnthis.x+x+this.y+y;
}
}
publicclassMySomeOne{
publicstaticvoidmain（Stringargs[]）{
MyChildmyChi=newMyChild（10,20,30）;
MyParentmyPar=newMyParent（10,20）;
intx=myChi.addMe（10,20,30）;
inty=myChi.addMe（myChi）;
intz=myPar.addMe（myPar）;
System.out.println（x+y+z）;
}
}
A.300B.240C.120D.180
答案：
一、1.错。
abstractmethod必须以分号结尾，且不带花括号。
2.错。
abstract的methods不能以private修饰。
abstract的methods就是让子类implement（实现）具体细节。
3.错。
intx被修饰成final，意味着x不能在addOnemethod中被修改。
4.正确。
在addOnemethod中，参数o被修饰成final。
如果在addOnemethod里我们修改了o的reference（比如:
o=newOther（）;），那么如同上例这题也是错的。
但这里修改的是o的membervairable（成员变量），而o的reference并没有改变。
5.正确。
输出的是"i=0"。
二、1. 正确答案A
2.答案：
FatherClass Create
FatherClass Create
ChildClass Create
3.正确答案 D
4.正确答案：
A
一、简答题
1.什么是异常？
为什么要进行异常处理？
2.简述异常处理的过程。
二、选择题
1.下面（ ）是正确的接口。
A.interfaceAB.abstractinterfaceA
{{
Voidprint（）{};print（）;
}}
C.abatractinterfaceAD.interfaceA
{{
Abstractvoidprint（）{};voidprint（）;
}}
2.在异常处理中，如释放资源、关闭文件、关闭数据库等由（）来完成。
A.try子句B.catch子句
C.finally子句D.throw子句
3.当方法遇到异常又不知如何处理时，下列哪种说法是正确的（）。
A.捕获异常 B.抛出异常
C.声明异常 D.嵌套异常
4.关键字（ ）可以抛出异常？
A.transientB.throws
C.throwD.static
5.下面是一个有错的程序：
1packagepayroll;
2classEmployeeNames{
3publicstaticString[]names={"a","b"};
4publicstaticString[]getNames（）{
5returnnames;
6}
7}
另一个文件
8packageclient
9importpayroll.EmployeeNames;
10publicclassTraderNamesextendsEmployeeNames{
11publicString[]traders={"c","d"};
12}
下面有四个改正项，哪个答案能改正程序？
（ ）
A.8packageclient;
B.2protectedclassEmployeeNames{
C.1packageparyroll;
D.9importpayroll.EmployeeNames
6.
String str = "Java";
StringBuffer buffer = new StringBuffer（str）;
if（str.equals（buffer））{
System.out.println（"Both are equal"）;
}else{
System.out.println（"Both are not equal"）;
}
A.both are not equalB.both are equalC.编译错D. 运行错
7.class Parent{
private void method1（）{
System.out.println（"Parent's method1（）"）;
}
public void method2（）{
System.out.println（"Parent's method2（）"）;
method1（）;
}
}
class Child extends Parent{
public void method1（）{
System.out.println（"Child's method1（）"）;
}
public static void main（String args[]）{
Parent p = new Child（）;
p.method2（）;
}
}
A. 编译错
B. 运行错
C. 打印parent’s method2（） parent’s method1（）
D. 打印 parent’s method2（） child’s method1（）
8.下面程序段的编译和运行的结果是什么？
String s1 = new String（"Test"）;
String s2 = new String（"Test"）;
if （s1==s2） System.out.println（"Same"）;
if （s1.equals（s2）） System.out.println（"Equals"）;
A. Same EqualB. EqualsC. SameD. 编译错
9.那一行的输出结果是false?
1.publicclassMyClass
2.{
3.staticStrings1="Iamunique!
";
4.publicstaticvoidmain（Stringargs[]）
5.{
6.Strings2="Iamunique!
";
7.Strings3=newString（s1）;
8.System.out.println（s1==s2）;
9.System.out.println（s1.equals（s2））;
10.System.out.println（s3==s1）;
11.System.out.println（s3.equals（s1））;
12.System.out.println（TestClass.s4==s1）;
13.}
14.}
15.
16.classTestClass
17.{
18.staticStrings4="Iamunique!
";
19.}
A.10和12行B.12行C.8和１０行D.都不是
答案：
一、1.答：
异常，是指由于程序运行时发生错误，从而导致程序错误结束。
在进行程序设计时，错误的产生是不可避免的，没有异常处理代码的程序，在运行时发生错误则可能非正常结束，引起严重问题。
因此，Java给程序员提供了处理运行时错误的功能，称为异常处理。
2.答：
程序运行时出现错误时，创建异常对象，抛出异常对象，捕获该异常对象并进行处理。
二、1.D2.C3.C 在Java语言中，有时一个方法生成一个异常，但该方法并不能确定如何处理此异常，如找不到文件之类的异常，必须将异常传递给调用方法，由调用它的方法来处理，这种时候方法用声明异常抛出，让异常对象可从调用栈向后传递，直至有相应的方法捕获它为止。
所以当方法
升级会员 