面向对象程序设计复习题.docx
《面向对象程序设计复习题.docx》由会员分享，可在线阅读，更多相关《面向对象程序设计复习题.docx（16页珍藏版）》请在冰豆网上搜索。
面向对象程序设计复习题
面向对象程序设计复习题
一、填空题：
1.创建类的对象时，使用运算符___________给对象分配内存空间。
2.Java通过来区分重载函数。
3.在子类中使用保留字__可调用被子类覆盖的父类中的方法。
4.使用保留字可以从一个构造方法中调用同一个类的另一个构造方法。
5.抽象类用修饰符定义。
6.类的数据成员的访问权限修饰符一般为
7.访问权限修饰符按照访问权限的大小从大到小分别为、、
、。
8.定义类的构造方法不能有，其名称与名相同。
9.抽象方法是的特征是。
10.Java中的所有异常都是从继承来的。
11.对象引用中存储的内容是。
12.下列程序段执行后，
Stringstr1=newString（"Java"）;
Stringstr2=newString（"Java"）;
if（str1.equals（str2））{
System.out.println（"Theyareequal"）;
}else{
System.out.println（"Theyarenotequal"）;
}
输出结果为：
。
13.下面循环执行后的sun值为
intcount=0,sum=0;
while（count<10）{
sum+=count;
count++;
}
14.Java语言中关键字__表示双精度类型。
15.保留字__用于导入包中的类到程序中，供程序中使用。
16.Java语言中继承是用保留字表示。
17.面向对象程序设计中，类是指。
18.对象包含和。
19.若有类定义：
classBextendsA{
…
}
则类B是类A的_。
20.Java语言中,通常把可能发生异常的方法调用语句放到try块中，并用紧跟其后的_块来捕获和处理异常。
21.多态是指。
22.声明常量时使用修饰符。
23.Java中异常抛出使用保留字。
24.一个类成员或者方法前面加上了修饰符，那说明该数据成员和方法可以直接通过类名来访问和调用。
25.如果类成员前面没有访问权限修饰符，则该类成员具有访问权限。
26.下面构造方法是非法的
a）:
publicintClassA（intone）{
…
}
b）:
publicClassB（intone,inttwo）{
…
}
c）：
ClassC（）{
…
}
27.程序填空：
publicvoidgetData（）{
Stringstr=JoptionPane.showInputDialog（null,”Input:
”）;
if（str.equals（“”）{
thrownewIOException（）;
}
）
28.对象称为类的。
29.Java程序的源文件以为扩展名，编译后的文件以为扩展名。
二、简答题：
1.类和对象的概念和关系是什么？
2.请说明对象声明和对象生成之间的区别，并使用内存状态图举例说明这种区别。
3.this和super两个保留字的意义和作用是？
4.构造器方法有什么特点和作用？
5.保留字throw和throws有什么区别？
6.将下面的while循环改写为for循环
intcount=1,sum=0;
while（count<=30）{
sum+=count;
count+=3;
}
7.Java语言编译和执行的过程是？
8.检查型异常和非检查型异常有何区别？
9.请改造下面的构造方法，使第一个构造方法调用第二个构造方法。
publicClassOne（intalpha）{
this.alpha=alpha;
this.beta=0;
}
publicClassOne（intalpha,intbeta）{
this.alpha=alpha;
this.beta=beta;
}
10.Java有哪几个访问权限修饰符，各起到什么作用？
11.请说明实例方法、类方法和构造器方法的特点和区别。
三、请写出下面的代码段的输出结果：
1.classQ2main{
publicstaticvoidmain（string[]args）{
QuestionTwoq2;
q2=newQuestionTwo（）;
q2.init（）;
q2.increment（）;
q2.increment（）;
system.out.println（q2.getCount（））;
}
}
classQuestionTwo{
privateintcount;
publicvoidint（）{
count=1;
}
publicvoidincrement（）{
count=count+1;
}
publicintgetCount（）{
returncount;
}
}
2.intgradeLevel;
switch（gradeLevel）{
case1:
System.out.print（"Gotothe101"）;
case2:
System.out.print（"Goto202"）;
break;
case3:
System.out.print（"Goto303"）;
case4:
System.out.print（"Goto404"）;
break;
default:
System.out.print（"default"）;
}
如果变量gradeLevel在switch语句之前为以下数值，上述程序代码段执行后，将分别输出什么？
a）2
b）3
c）4
d）5
3.intx;
for（intwidth=1;width<=20,width++）{
for（intlength=5,length<=25,length+=5）{
x=width*length;
System.out.print（""+x）;
}
System.out.println（""）;
}
输出结果为：
4.classMyException1extendsException{
publicMyException1（）{}
publicMyException1（Stringmsg）{super（msg）;}
}
publicclassExceptionTest{
publicstaticvoidf（）throwsMyException1{
System.out.println（"The1stlineoff（）"）;
thrownewMyException1（"Exception1:
Originatedinf（）"）;
}
publicstaticvoidmain（String[]args）{
System.out.println（"The1stlineofmain（）"）;
try{
System.out.println（"The2ndlineofmain（）"）;
f（）;
System.out.println（"The3rdlineofmain（）"）;
}catch（MyException1e）{
System.out.println（e.getMessage（））;
}
finally{
System.out.println（"The4thlineofmain（）"）;
}
System.out.println（"The5thlineofmain（）"）;
}
}
输出结果为：
5.importjava.io.*;
classBase{
Base（）{
System.out.println（"Base（）"）;
}
voidm1（）{
System.out.println（"Base.m1（）"）;
}
}
classDerivedextendsBase{
Derived（）{
this（"default"）;
System.out.println（"Derived（）"）;
}
Derived（Stringss）{
System.out.println（ss）;
}
voidm1（）{
System.out.println（"Derived.m1（）"）;
}
}
publicclassApplication1{
publicstaticvoidmain（Stringargs[]）{
Baseb;
b=newDerived（）;
b.m1（）;
}
}
输出结果为：
6.classShape{
voiddraw（）{
System.out.println（"Shape.draw（）"）;
}
}
classCircleextendsShape{
voiddraw（）{
System.out.println（"Circle.draw（）"）;
}
}
classSquareextendsShape{
voiddraw（）{
System.out.println（"Square.draw（）"）;
}
}
publicclassShapes{
publicstaticvoidmain（String[]args）{
Shape[]s=newShape[3];
s[0]=newShape（）;
s[1]=newCircle（）;
s[2]=newSquare（）
for（inti=0;i<3;i++）
s[i].draw（）;
}
}
输出结果为：
7.try{
number=Integer.parseInt（“-30”）;
if（number<0）{
thrownewException（“Nonegative”）;
}
catch（NumberFormatExceptione）{
System.out.println（“Cannotcoverttoint”）;
}catch（Exceptione）{
System.out.println（“Error:
”+e.getMessage（））;
}finally{
System.out.println（“DONE”）;
}
输出结果为：
8.classValue{
inti=10;
}
classTester{
publicstaticvoidtest（intx）{
x=20;
}
publicstaticvoidtest（Valuev）{
v.i=20;
}
publicstaticvoidmain（String[]args）{
Valuev1=newValue（）;
intx=10;
Tester.test（x）;
Tester.test（v1）;
System.out.println（x）;
System.out.println（v1.i）;
}
}
9.classRock{
Rock（）{
System.out.println（"CreatingRock"）;
}
Rock（inti）{
System.out.println（"CreatingRocknumber"+i）;
}
}
publicclassSimpleConstructor{
publicstaticvoidmain（String[]args）{
for（inti=0;i<3;i++）
if（i==1）
newRock（）;
else
newRock（i）;
}
}
lassBicycleRegistration{
publicstaticvoidmain（String[]args）{
Bicyclebike1,bike2;
bike1=newBicycle（）;
bike2=newBicycle（“xxxx”）;
bike1.setOwnerName（"Test"）;
System.out.println（bike1.getOwnerName（）+"ownsabicycle."）;
System.out.println（bike2.getOwnerName（）+"alsoownsabicycle."）;
}
}
classBicycle{
privateStringownerName;
publicBicycle（）{
ownerName="Unknown";
}
publicBicycle（Stringname）{
ownerName=name;
}
publicStringgetOwnerName（）{
returnownerName;
}
publicvoidsetOwnerName（Stringname）{
ownerName=name;
}
}
输出结果为：
四、编程题：
1.编写一段Java程序代码，用一个对话在分开的两行中显示两条消息：
“ICanDesign”和“AndICanProgram”。
2.编写一个Java程序，对于给定的年份，回答“LeapYear”（闰年）或者“NotaLeapYear”（平年）。
如果一个年份能被4整除，但是不能被100整除，它是闰年；如果一个年份能被100整除，也能被400整除，它也是闰年。
需要定义名为LeapYear的服务提供类
3.编写一个do-while循环以计算正整数中前30个奇数的累加和。
4.编写可以根据用户年龄和身高给出推荐的体重的的Java程序，利用下面的公式计算出推荐的体重：
recommendedWeight=（height–100+age/10）*0.9
需要定义名为Height（身高）的服务提供类，它应该会有可以根据身高得到推荐提供的方法。
5.请按照以下要求写出完整的程序代码（要求能上机编译运行）：
1）创建一个抽象类AAbstractBase，该类至少包含一个抽象方法;
2）创建一个类TestClass，该类继承AAbstractBase，并包含两个构造器方法；
6.定义一个Vehicle类，类中包含一个Person类型的数据成员owner、一个获得owner值的访问方法和一个设置owner值的访问方法。
定义VehicleManage个类，该类包含主方法，并在主方法中创建Vehicle类的对象，并调用其设置owner和获取owner的方法。
参考答案
一、填空题：
1.new2.不同的参数列表
3.super4.this
5.abstract6.private
7.public、protected、包访问权限、private8.返回值类型、类
9.只有方法声明没有方法体10.Throwable
11.对象的存储地址12.Theyareequal
13.5014.double
15.import16.extends
17.一个或多个相似对象的抽象描述18.数据、执行在数据上的操作
19.子类（导出类）20.catch
21.允许一个变量指向不同类的对象22.final
23.throw24.static
25.包26.a
27.throwsException28.实例
29.java、class
二、简答题：
1.对象是系统中用来描述客观事物的一个实体，它是构成系统的一个基本单位。
一个对象由一组属性和对这组属性进行操作的一组服务组成，类是具有相同属性和服务的一组对象的集合。
类是对象的模板，对象是类的实例
2.对象声明是为对象的引用创建一个空间，而对象生成则是创建一个类的实例，即为对象分配空间，如果需要的话，其还会将对象空间的地址赋给其应用。
如Testert1;
t1
t1=newTester（）;
t1
:
Tester
3.this它代表当前对象名，可用来调用本类中另一种形成的构造函数（应该为构造函数中的第一条语句），在程序中易产生二义性之处，应使用this来指明当前对象；super:
它引用当前对象的直接父类中的成员，可以用来调用基类中的某一个构造函数（应该为构造函数中的第一条语句,）也可以用来在基类与派生类中有相同成员定义时直接访问父类中被隐藏的父类中成员数据或函数。
4.构造器一般用于对类进行初始化。
其特点如下：
a）其定义形式跟类中其他方法基本类似
b）其方法名与类名完全相同（包括大小写）。
c）其在对象被创建时自动被Java调用，而无需用户干预
d）其没有返回值类型。
e）一个类可以定义多个构造方法
5.throw用于抛出一个异常，throws则是用于声明未必处理的运行时异常。
6.sum=0;
for（intcount=1;count<=30;count+=3）
sum+=count;
7.Java编译器将以.java为后缀名的Java源代码文件编译成以.class结尾的字节码文件。
Java的虚拟机再根据不同的软硬件平台将.class文件翻译成机器码文件予以执行。
8.因为编程错误而导致的异常，或者是不能期望程序捕获的异常（解除引用一个空指针，数组越界，除零，等等），为了使开发人员免于处理这些异常，一些异常被命名为非检查型异常（即那些继承自RuntimeException的异常）并且不需要进行声明，而检查型异常如果没有捕获则需在方法头部进行声明。
9.publicClassOne（intalpha）{
this（alpha,0）;
}
publicClassOne（intalpha,intbeta）{
this.alpha=alpha;
this.beta=beta;
}
10.public：
表明该成员变量和方法是共有的，能在任何情况下被访问。
protected：
必须在同一包中或者该类的导出类中才能被访问；private:
只能在本类中访问；缺省的为包访问权限，在同一个包中可以访问
11.类方法前面有static保留字，其不需要创建类的实例，通过类名即可访问；实例方法则为普通方法，其需要创建类的实例后通过实例访问；构造方法的名称与类名完全相同，其在创建类的实例是自动执行。
三、请写出下面的代码段的输出结果：
1.3
2.
（a）Goto202
（b）Goto303
Goto404
（c）Goto404
（d）default
3.510152025
1020304050
1530456075
20406080100
255075100125
4.The1stlineofmain（）
The2ndlineofmain（）
The1stlineoff（）
Exception1:
Originatedinf（）
The4thlineofmain（）
The5thlineofmain（）
5.Base（）
default
Derived（）
Derived.m1（）
6.Shape.draw（）
Circle.draw（）
Square.draw（）
7.Error:
Nonegative
DONE
8.10
20
9.CreatingRocknumber0
CreatingRock
CreatingRocknumber2
10.Testownsabicycle.
xxxxalsoownsabicycle.
四、编程题：
1.importjavax.swing.*;
publicclassTest{
publicstaticvoidmain（String[]args）{
JOptionPane.showMessageDialog（null,"ICanDesign\nAndICanProgram"）;
}
}
2.publicclassTest{
publicstaticvoidmain（String[]args）{
LeapYearly=newLeapYear（）;
System.out.println（puteLeapYear（1998））;
System.out.println（puteLeapYear（1900））;
System.out.println（puteLeapYear（2000））;
}
}
classLeapYear{
publicbooleancomputeLeapYear（intyear）{
if（year%4==0&&year%100!
=0）returntrue;
if（year%100==0&&year%400==0）returntrue;
returnfalse;
}
}
3.publicclassTest{
publicstaticvoidmain（String[]args）{
intsum=0,i=0;
do{
sum=（i*2+1）;
i++;
}while（i<=30）;
System.out.println（sum）;
}
}
4.publicclassTest{
publicstaticvoidmain（String[]args）{
Weightw1=newWeight（）;
System.out.println（w1.getRecommendedWeight（30,170））;
}
}
classWeight{
publicdoublegetRecommendedWeight（intage,intheight）{
return（height-100+age/10）*0.9;
}
}
5.publicclassTest{
publicstaticvoidmain（String[]args）{
TestClasst1,t2;
t1=newTestClas
升级会员 