java认证 习题 第02章 有答案版 OK该试题还有第0103章.docx
《java认证 习题 第02章 有答案版 OK该试题还有第0103章.docx》由会员分享，可在线阅读，更多相关《java认证 习题 第02章 有答案版 OK该试题还有第0103章.docx（23页珍藏版）》请在冰点文库上搜索。
java认证习题第02章有答案版OK该试题还有第0103章
SCJP5.0习题第02章
一、重写和重载1
二、封装、IS-AHAS-A5
四、第二章课后习题7
一、重写和重载
问题1）假设有如下类定义，如下哪些方法可以合法放置在“//Here”的注释之后？
publicclassRid{
publicvoidamethod（inti,Strings）{}
//Here
}
1）publicvoidamethod（Strings,inti）{}
2）publicintamethod（inti,Strings）{}
3）publicvoidamethod（inti,Stringmystring）{}
4）publicvoidAmethod（inti,Strings）{}
答案：
1和4<考察方法重载>
Amethod中的大写字母A意味着这是不同的方法。
问题2）假设有如下类定义，哪些代码可以被合法放置在注释“//Here”之后？
classBase{
publicBase（inti）{}
}
publicclassMyOverextendsBase{
publicstaticvoidmain（Stringarg[]）{
MyOverm=newMyOver（10）;
}
MyOver（inti）{
super（i）;
}
MyOver（Strings,inti）{
this（i）;
//Here
}
}
1）MyOverm=newMyOver（）:
2）super（）;
3）this（“Hello”,10）;
4）Baseb=newBase（10）;
答案：
4
任何this或super的调用都必须是构造函数中的第一行。
由于方法已经调用了this，不能有
别的调用插入了。
问题3）假设有如下类定义
classMammal{
Mammal（）{
System.out.println（“Mamml”）;
}
}
classDogextendsMammal{
Dog（）{
System.out.println（“Dog”）;
}
}
publicclassCollieextendsDog{
publicstaticvoidmain（Stringargv[]）{
Colliec=newCollie（）;
}
Collie（）{
this（“GoodDog”）;
System.out.println（“Collie”）;
}
Collie（Strings）{
System.out.println（s）;
}
}
将会输出什么？
1）Compiletimeerror
2）Mammal,Dog,GoodDog,Collie
3）GoodDog,Collie,Dog,Mammal
4）GoodDog,Collie
答案：
2）Mammal,Dog,GoodDog,Collie
问题4）下面哪些论述是正确的？
1）构造方法不能被继承
2）构造方法可以被重写；《重写不是重载》.
3）父类的构造方法可以使用this调用
4）任何方法都可以调用this和super
答案：
1
问题5）试图编译并运行下面代码会发生什么？
classBase{
publicvoidamethod（inti,Strings）{
System.out.println（“Baseamethod”）;
}
Base（）{
System.out.println（“BaseConstructor”）;
}
}
publicclassChildextendsBase{
inti;
StringParm=“Hello”;
publicstaticvoidmain（Stringargv[]）{
Childc=newChild（）;
c.amethod（）;
}
voidamethod（inti,StringParm）{
super.amethod（i,Parm）;
}
publicvoidamethod（）{}
}
1）编译错误
2）错误，super.amethod（i,Parm）语法不正确
3）输出“BaseConstructor”
4）错误，super.amethod的参数名字不正确
答案：
1
这会导致一个错误，意思是说“你不能重写方法使其访问权限更靠近私有”。
基类的amethod
版本被明确的标注为public，但是在子类中没有标识符。
好了，所以这不是在考察你的构造
函数重载的知识，但是他们也没在考试中告诉你主题。
若这段代码没有省略关键字public，
将会输出“Baseconstructor”，选项3。
问题6）试图编译并运行如下代码时将发生什么？
classMammal{
Mammal（）{
System.out.println（“Four”）;
}
publicvoidears（）{
System.out.println（“Two”）;
}
}
classDogextendsMammal{
Dog（）{
super.ears（）;
System.out.println（“Three”）;
}
}
publicclassScottieextendsDog{
publicstaticvoidmain（Stringargv[]）{
System.out.println（“One”）;
Scottieh=newScottie（）;
}
}
1）One,Three,Two,Four
2）One,Four,Three,Two
3）One,Four,Two,Three
4）Compiletimeerror
答案：
3）One,Four,Two,Three
类是从层次的根部往下创建的。
因此，首先输出One，因为它在Scottieh初始化之前创建。
然后，JVM移动到层次的基类，运行“祖父类”Mammal的构造函数。
这会输出“Four”。
然后，运行Dog的构造函数。
Dog的构造函数调用Mammal中的ears方法，因此输出“Two”。
最后，Dog的构造函数完成，输出“Three”。
问题7）给定下面的类定义
publicclassUpton{
publicstaticvoidmain（Stringargv[]）{
}
publicvoidamethod（inti）{}
//Here
}
下面哪一个在替换//Here后是合法的？
1）publicintamethod（intz）{}
2）publicintamethod（inti,intj）{return99;}
3）protectedvoidamethod（longl）{}
4）privatevoidanothermethod（）{}
答案：
2、3和4
选项1由于两个原因不会被编译。
第一个相当明显，因为它要求返回一个integer。
另一个是
试着直接在类内部重新定义一个方法。
把参数的名字从i换成z是无效的，并且一个方法不
能在同一个类里重写。
问题8）给定下面的类定义
classBase{
publicvoidamethod（）{
System.out.println（"Base"）;
}
}
publicclassHayextendsBase{
publicstaticvoidmain（Stringargv[]）{
Hayh=newHay（）;
h.amethod（）;
}
}
下面在类Hay中的哪一个方法将会编译并使程序打印出字符串"Hay"？
1）publicintamethod（）{System.out.println（"Hay"）;}
2）publicvoidamethod（longl）{System.out.println（"Hay"）;}
3）publicvoidamethod（）{System.out.println（"Hay"）;}
4）publicvoidamethod（void）{System.out.println（"Hay"）;}
答案：
3）publicvoidamethod（）{System.out.println（"Hay"）;}
选项3重写<覆盖>了类Base的方法，因此任何无参数调用都调用这个版本。
选项1修改方法的返回值类型。
选项2将会编译，结果是调用父类中的方法
问题9）给定下面的类定义
publicclassShrubHill{
publicvoidforegate（StringsName）{}
//Here
}
下面的哪一个方法可以合法的直接替换//Here？
1）publicintforegate（StringsName）{}
2）publicvoidforegate（StringBuffersName）{}
3）publicvoidforeGate（StringsName）{}
4）privatevoidforegate（StringsType）{}
答案9）
2）publicvoidforegate（StringBuffersName）{}
3）publicvoidforeGate（StringsName）{}
选项1是试着定义一个方法两次，有一个int返回值并不能帮助将它与存在的foregate方法
相区分。
而像选项4那样改变方法的参数名，也不能与存在的方法相区分。
注意，选项3
里的foreGate方法有一个大写的G。
二、封装、IS-AHAS-A
问题1）假设你被给予如下设计
“一个人有姓名，年龄，地址和性别。
你将要设计一个类来表示一类叫做病人的人。
这
种人可以被给予诊断，有配偶并且可能活着”。
假设表示人的类已经创建了，当你设计病人
类时如下哪些应该被包含在内？
1）registrationdate
2）age
3）sex
4）diagnosis
答案1）
1）registrationdate
2）diagnosis
对于病人来说，注册日期是一个合理的添加域，并且设计明确地指出病人应该有诊断报告。
由于病人是人的一种，它应该有域age和sex（假设它们没有被声明为私有的）。
问题2）当你试图编译并运行如下代码时会发生什么？
classBase{
inti=99;
publicvoidamethod（）{
System.out.println（“Base.amethod（）”）;
}
Base（）{
amethod（）;
}
}
publicclassRTypeextendsBase{
inti=-1;
publicstaticvoidmain（Stringargv[]）{
Baseb=newRType（）;
System.out.println（b.i）;
b.amethod（）;
}
publicvoidamethod（）{
System.out.println（“RType.amethod（）”）;
}
}
1）
RType.amethod
-1
RType.amethod
2）
RType.amethod
99
RType.amethod
3）
99
RType.amethod
4）
Compiletimeerror
答案：
2）
RType.amethod
99
RType.amethod
如果这个答案看起来靠不住，试着编译并运行代码。
原因是这段代码创建了一个RType类
的实例但是把它赋予一个指向Base类的引用。
在这种情况下，涉及的任何域，比如i，都会
指向Base类中的值，但是方法的调用将会指向实际类中的方法而不是引用句柄中的方法。
问题3）你的首席软件设计者向你展示了她正要创建的新电脑部件系统的草图。
在层次结
构的顶端是一个叫做Computer的类，在此之下是两个子类。
一个叫做LinuxPC，另一个
叫做WindowsPC。
两者之间最大的不同点是一个运行Linux操作系统，另一个运行Windows
系统（当然另一个不同在于一个需要不停的重启，另一个则能够可靠的运行）。
在
WindowsPC之下是两个子类，一个叫做Server，另一个叫做Workstation。
你如何评价你
的设计者的工作？
1）使用现在的模式继续做进一步的设计
2）让他重新设计，把操作系统设计为一个成员变量而不是1个类。
3）把WindowsPC去掉，因为很快就会抛弃
4）改变继承结构，删除多余Computer类。
答案：
2？
问题4）假设有如下类
classBase{
intAge=33;
}
关于对Age域的访问，你会如何修改来改进这个类？
1）把变量Age定义为private
2）把变量Age定义为protected
3）把变量Age定义为private，然后提供get方法获取值，set方法更新值。
4）把变量Age定义为protected，然后提供get方法获取值，set方法更新值。
答案：
3
问题5）下面哪些是封装的好处？
1）所有的变量都被封装成对象而不是基本数据类型
2）让所有的变量都被保护起来，以防止意外损坏
3）可以改变类的实现而不影响使用这个类的代码
4）使所有方法都受到保护，防止意外的数据损坏
答案：
3
问题6）指出三个面向对象编程的主要特点？
1）封装、动态绑定、多态
2）多态、重载、过载
3）封装、继承、动态绑定
4）封装、继承、多态
答案：
4
问题7）你如何在类中实现封装？
1）让所有变量都是protected，只能通过方法访问
2）让所有变量都是private，只能通过方法访问
3）保证所有的变量都表示成封装类型
4）保证所有的变量都是通过祖先类中的方法访问
答案：
2
四、第二章课后习题
1.哪个语句正确？
（可以多选）
A.Has-a关系依赖继承
B.Has-a关系依赖实例变量
C.Has-a关系至少需要两个类
D.Has-a关系依赖多态
E.Has-a关系总是导致紧耦合
正确：
B
错误：
C可以类自己的实例作为成员变量，例如表示夫妻关系
2.已知：
classClidders{
publicfinalvoidflipper（）{System.out.println（"Clidder"）;}
}
publicclassClidletsextendsClidders{
publicvoidflipper（）{
System.out.println（"FlipaClidlet"）;
super.flipper（）;
}
publicstaticvoidmain（String[]args）{
newClidlets（）.flipper（）;
}
}
会有什么结果？
A.FlipaClidlet
B.FlipaClidder
C.FlipaClidder
FlipaClidlet
D.FlipaClidlet
FlipaClidder
E.编译失败
正确：
E
3.已知：
publicabstractinterfaceFrobnicate{
publicvoidtwiddle（Strings）;
}
哪个类正确？
可以多选
A.publicabstractclassFrobimplementsFrobnicate{
publicabstractvoidtwiddle（Strings）{}
}
B.publicabstractclassFrobimplementsFrobnicate{}
C.publicclassFrobextendsFrobnicate{
publicvoidtwiddle（Integeri）{}
}
D.publicclassFrobimplementsFrobnicate{
publicvoidtwiddle（Integeri）{}
}
E.publicclassFrobimplementsFrobnicate{
publicvoidtwiddle（Stringi）{}
publicvoidtwiddle（Integers）{}
}
正确：
B和E
4.已知：
classTop{
publicTop（Strings）{System.out.print（"B"）;}
}
publicclassBottom2extendsTop{
publicBottom2（Strings）{System.out.print（"D"）;}
publicstaticvoidmain（String[]args）{
newBottom2（"C"）;
System.out.println（""）;
}
}
Whatistheresult?
A.BD
B.DB
C.BDC
D.DBC
E.编译失败
正确：
E
5.选择两个最能描述低耦合的语句
A.类的属性都是私有的
B.类中引用了少量的其他对象
C.对象只有少量的成员变量
D.通过匿名变量引用对象
E.引用变量声明为接口类型，而不是一个类，接口提供了少量的方法。
F.对一个类的修改不会引起另一个累的任何变化。
正确：
E和F。
6.已知：
classClidder{
privatefinalvoidflipper（）{System.out.println（"Clidder"）;}
}
publicclassClidletextendsClidder{
publicfinalvoidflipper（）{System.out.println（"Clidlet"）;}
publicstaticvoidmain（String[]args）{
newClidlet（）.flipper（）;
}
}
结果是？
A.Clidlet
B.Clidder
C.Clidder
Clidlet
D.Clidlet
Clidder
E.编译失败
正确：
A
父类的final方法是private类型。
子类中定义的方法相当于新方法，不是多态。
7.使用下面的代码块，完成下面的代码，可以不用完全填满。
Note,youmaynothavetofillalloftheslots.
Code:
classAgedP{
____AgedP（）{}；______________________________________________
publicAgedP（intx）{
__________________________________________________
}
}
publicclassKinderextendsAgedP{
_________________________________________________________
publicKinder（intx）{
_______super___________________________________________（）;
}
}
代码块:
下面的代码块可以使用多次或者不使用。
AgedPsuperthis
（）{}
;
答案：
classAgedP{
AgedP（）{}；
publicAgedP（intx）{
}
}
publicclassKinderextendsAgedP{
publicKinder（intx）{
super（）;
}
}
Asthereisnodroppabletileforthevariablexandtheparentheses（intheKinderconstructor）,arealreadyinplaceandempty,thereisnowaytoconstructacalltothesuperclassconstructorthattakesanargument.Therefore,theonlyremainingpossibilityistocreateacalltotheno-argumentsuperclassconstructor.Thisisdoneas:
super（）;.Thelinecannotbeleftblank,astheparenthesesarealreadyinplace.Further,sincethesuperclassconstructorcalledistheno-argumentversion,thisconstructormustbecreated.Itwillnotbecreatedbythecompilerbecausethereisanotherconstructoralreadypresent.
（Objective5.4）
8.Given:
1.classPlant{
2.StringgetName（）{return"plant";}
3.PlantgetType（）{returnthis;}
4.}
5.classFlowerextendsPlant{
6.//insertcodehere
7.}
8.classTulipextendsFlower{}
Whichstatement（s）,insertedatline6,willcompile?
（Chooseallthatapply.）
A.FlowergetType（）{return
升级会员 