CoreJavaOOP考试题Word文档格式.docx
《CoreJavaOOP考试题Word文档格式.docx》由会员分享，可在线阅读，更多相关《CoreJavaOOP考试题Word文档格式.docx（17页珍藏版）》请在冰豆网上搜索。
publicstaticvoidmain（String[]args）{
Outero=newOuter（）;
Outer.Inneri=o.newInner（）;
o.print（）;
i.print（）;
程序运行的结果是102010，则空白处填写的代码是（D）
A.indexindexindex
B.indexOuter.indexindex
C.indexindexOuter.index
D.indexOuter.this.indexindex
5.classBase{
staticvoidtest（）{
System.out.println（“Base.test（）”）;
publicclassChildextendsBase{
staticvoidtest（）{
System.out.println（“Child.test（）”）;
Basebase=newChild（）;
Childchild=newChild（）;
base.test（）;
child.test（）;
程序运行的结果是（C）
A.Child.test（）Child.test（）
B.Child.test（）Base.test（）
C.Base.test（）Child.test（）
D.Base.test（）Base.test（）
6.类中用多重catch处理异常时，（B）异常类应最后列出。
A．NumberFormatException
B．Exception
C．ArrayIndexOutOfBoundsException
D．ArithmeticException
7.下列哪些叙述是正确的（CD）
A．在一个类中，方法不能与类名相同
B．astract可以修饰属性、方法和类
C．实例方法可直接调用本类的static方法和非static方法
D．static方法不能调用非static方法
8.以下说法正确的是（AC）
A．子类不能继承父类的构造方法
B．子类的构造方法可以访问父类的构造方法
C．子类不可直接访问父类的私有属性
D．子类可以重写父类的所有方法
9.关于接口，以下说法错误的是（ACD）
A．接口中可以定义非抽象方法
B．接口可以继承多个接口
C．接口中可以定义没有初始化的变量
D．接口可以实现接口
10.classBase{
privateintbase=10;
publicBase（）{
test（base）;
System.out.println（base）;
voidtest（intbase）{
++this.base;
publicclassChild{
privateintchild=20;
publicChild（）{
test（child）;
System.out.println（child）;
voidtest（intchild）{
--this.child;
newChild（）;
程序运行的结果是（D）
A.19
B.1119
C.1120
D.1019
11.publicclassInnerDemo{
privateintouter=20;
classInner{
privateintinner=30;
publicInner（）{
test（inner）;
voidtest（intinner）{
inner+=5;
System.out.println（inner）;
intouter=40;
Innerinner=newInner（）;
inner.test（outer）;
程序运行的结果是（C）
A．45
B．3045
C．3545
D．3540
12.关于异常，下列描述正确的是（ABC）
A．异常的基类为Exception，所有异常都必须直接或者间接继承它
B．异常可以用try{}catch（Exceptione）{}来捕获并进行处理
C．如果某异常继承RuntimeException，则该异常可以不被声明
D．异常可以随便处理，而不是抛给外层的程序进行处理
13.在Java中，关于final关键字的说法正确的是（AC）
A.final修饰的变量，一旦赋值就不能被更改
B.final修饰的类只能被一个子类继承
C.final修饰的方法，不能在子类中被覆盖
D.final修饰的方法，不能被子类继承
14.下列不属于接口的是（BC）
A．List
B．ArrayList
C．HashSet
D．Map
15.1）publicinterfaceTest{
2）staticpublicfinalintnum=10;
3）publicstaticvoidadd（）;
4）publicStringtest（）{};
5）publiclongdelete（）;
6）}
关于上面的代码，以下说法错误的是（ABD）
A．第2）行代码有编译错误
B．第3）行代码没有编译错误
C．第4）行代码有编译错误
D．第5）行代码有编译错误
16.下列哪一项不是面向对象的典型特征（D）
A．封装B.继承
C.多态D.抽象
17.关于类、抽象类和接口，以下说法正确的是（ACD）
A．接口可以继承多个接口
B．抽象类不能实现接口
C．一个类只能继承一个类，但可以实现多个接口
D．抽象类实现接口，可以不实现接口的方法
18.下面关于变量的说法正确的是（BC）
A．实例变量可以通过类名直接调用
B．类变量可以通过类名直接调用
C．Java中的参数传递都是值传递
D．在不同的作用域不能定义相同的变量
19.下列代码有编译错误的是第（D）行
1）publicclassTest{
2）publicstaticvoidmain（String[]args）{
3）int[]arr1=newint[12];
4）char[]arr2=newchar[];
5）int[]arr3={};
6）Object[]obj=newObject[4];
7）Objectobj1=newObject[9];
8）}
9）}
A.5）
B.5）7）
C.4）7）
D.4）
20.下列代码的运行结果是（A）
publicclassTest{
privateintnum;
privatestaticTesttest;
publicTest（intnum）{
this.num=++num;
static{
intnum=16;
test=newTest（num）;
++test.num;
test=newTest（13）;
System.out.println（test.num）;
A.14
B.15
C.16
D.17
二、填空题（2*6=12分）
1、publicinterfaceInterfaceDemo{
publicstaticfinalint
__abstract______voidadd（）;
abstractclassDemoimplementsInterfaceDemo{
___abstract_____intgetNumber（）;
//抽象方法
classInterfacetestextendsDemo{
publicintgetNumber（）{
return0;
}
publicvoidadd（）{}
2、publicclassUser{
privateStringname;
privateintage;
publicStringgetName（）{
Returnthis.name;
publicvoidsetName（Stringname）{
this.name=name;
publicintgetAge（）{
Returnthis.age;
publicvoidsetAge（intage）{
this.age=age;
publicbooleanequals（Objecto）{
if（__this==obj___）{
returntrue;
if（__obj==null___）{
returnfalse;
if（___objinstanceof_____）{
____Useruser=（User）obj______;
return（this.name.equals（other.getName（））&
&
this.age==other.getAge（））;
returnfasle;
publicinthashCode（）{
returnname.hashCode（）>
>
20+age*1000;
三、简答题（8+8+8=24分）
1.抽象类和接口有什么区别？
声明方法的存在而不去实现它的类被叫做抽象类（abstractclass），它用于要创建一个体现某些基本行为的类，并为该类声明方法，但不能在该类中实现该类的情况。
不能创建abstract类的实例。
然而可以创建一个变量，其类型是一个抽象类，并让它指向具体子类的一个实例。
不能有抽象构造函数或抽象静态方法。
Abstract类的子类为它们父类中的所有抽象方法提供实现，否则它们也是抽象类。
取而代之，在子类中实现该方法。
知道其行为的其它类可以在类中实现这些方法。
接口（interface）是抽象类的变体。
新型多继承性可通过实现这样的接口而获得。
接口中的所有方法都是抽象的，所有成员变量都是publicstaticfinal的。
一个类可以实现多个接口，当类实现接口时，必须实现接口的所有方法。
抽象类在Java语言中表示的是一种单继承的关系，对于interface来说则不然，并不要求interface的实现者和interface定义在概念本质上是一致的，仅仅是实现了interface定义的契约而已。
；
抽象类中可以定义自己的成员变量，也可以包含非抽象的方法，而在接口中只能有静态的常量，所有方法必须是抽象的；
实现抽象类时可以只实现其中的部分方法，而要是实现一个接口的话就必须实现这个接口中的所有抽象方法。
2.Overload和Override的区别，Overloaded的方法是否可以改变返回值类型
方法的重写Overriding和重载Overloading是Java多态性的不同表现。
重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。
如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写（Overriding）。
子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被“屏蔽”了。
如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载（Overloading）。
Overloaded的方法是可以改变返回值的类型。
3.final,finally,finalize的区别？
final—修饰符（关键字）如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。
因此一个类不能既被声明为abstract的，又被声明为final的。
将变量或方法声明为final，可以保证它们在使用中不被改变。
被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改。
被声明为final的方法也同样只能使用，不能重载。
finally—再异常处理时提供finally块来执行任何清除操作。
如果抛出一个异常，那么相匹配的catch子句就会执行，然后控制就会进入finally块（如果有的话）。
finalize—方法名。
Java技术允许使用finalize（）方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。
这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。
它是在Object类中定义的，因此所有的类都继承了它。
子类覆盖finalize（）方法以整理系统资源或者执行其他清理工作。
finalize（）方法是在垃圾收集器删除对象之前对这个对象调用的。
四、程序题（9+15=24分）
1、建立一个汽车类（Car），包括轮胎个数，汽车颜色，车身重量等属性。
并通过不同的构造方法创建事例。
至少要求：
汽车能够加速，减速，停车。
要求：
命名规范，代码体现层次，有友好的操作提示。
publicclassCar{
privateintwheels;
//轮胎个数
privateStringcolor;
//颜色
privatedoubleweight=50;
//重量默认50KG
privateintspeed=100;
//速度默认100KM/H
//无参构造函数
publicCar（）{
wheels=4;
color="
黑"
;
//车轮+颜色的车
publicCar（intwheels,Stringcolor）{
this.wheels=wheels;
this.color=color;
//车轮+颜色+重量的车
publicCar（intwheels,Stringcolor,doubleweight）{
this.weight=weight;
//车轮+颜色+重量+速度的车
publicCar（intwheels,Stringcolor,doubleweight,intspeed）{
this.speed=speed;
//加速
privatevoidspeedUp（）{
System.out.println（"
汽车开始加速"
）;
//减速
privatevoidspeedDown（）{
汽车减速"
//停车
privatevoidstop（）{
停车"
@Override
//重写toString（）方法...展示车子的详细信息
publicStringtoString（）{
return"
这是一辆有"
+wheels+"
个轮胎，"
+weight+"
千克重"
+"
，时速为"
+speed
KM/H的"
+color+"
色汽车。
"
publicstaticvoidmain（String[]args）{
//调用默认构造函数
Carcar=newCar（）;
//输出是一辆什么车
System.out.println（car）;
//分别调用加速、减速、停车方法
car.speedUp（）;
car.speedDown（）;
car.stop（）;
2、定义一个抽象的"
Role"
类，有姓名，年龄，性别等成员变量
◆要求尽可能隐藏所有变量（能够私有就私有,能够保护就不要公有），再通过GetXXX（）和SetXXX（）方法对各变量进行读写。
具有一个抽象的play（）方法，该方法不返回任何值，同时至少定义两个构造方法。
Role类中要体现出this的几种用法。
◆从Role类派生出一个"
Employee"
类，该类具有Role类的所有成员（构造方法除外），并扩展salary成员变量，同时增加一个静态成员变量“职工编号（ID）”。
同样要有至少两个构造方法，要体现出this和super的几种用法，还要求覆盖play（）方法，并提供一个finalsing（）方法。
◆"
Manager"
类继承"
类，有一个final成员变量"
vehicle"
◆在main（）方法中制造Manager和Employee对象,并测试这些对象的方法
Ø
packagedierti;
publicabstractclassRole{
//定义一个抽象的"
privateStringname;
privateintage;
privateStringsex;
//再通过GetXXX（）和SetXXX（）方法对各变量进行读写。
publicStringgetName（）{
returnname;
}
publicvoidsetName（Stringname）{
this.name=name;
publicintgetAge（）{
returnage;
publicvoidsetAge（intage）{
this.age=age;
publicStringgetSex（）{
returnsex;
publicvoidsetSex（Stringsex）{
this.sex=sex;
//具有一个抽象的play（）方法，该方法不返回任何值
publicabstractvoidplay（）;
//定义两个构造方法。
publicRole（）{
publicRole（Stringname,intage）{
System.out.println（"
姓名:
+this.name+"
"
+"
年龄:
+this.age）;
publicRole（Stringname,intage,Stringsex）{
+this.age+"
性别:
+this.sex）;
packagedierti;
publicclassEmployeeextendsRoleimplementssalary{
/*
*2.从Role类派生出一个"
类，该类具有Role类的所有成员（构造方法除外），
*并扩展salary成员变量，同时增加一个静态成员变量“职工编号（ID）”。
同样要有至少两个构造方法，要体现出this和super的几种用法，
*还要求覆盖play（）方法，并提供一个finalsing（）方法。
*/
publicintclerkId;
publicvoidplay（）{
System.out.println（"
游戏"
publicEmployee（Stringname,intage,Stringsex）{
super（name,age,sex）;
publicEmployee（Stringname
升级会员 