自考Java语言程序设计（一）课后习题及答案

自考Java语言程序设计(一)课后习题及答案

自考Java语言程序设计(一)第一章Java语言概述课后习题

-、Java语言概述

1.Java语言有哪些特点？

2.什么叫做类？什么叫做对象？

3.简述Java的运行机制。

4.简述Java应用程序的开发流程。

5.当初Sun公司发展Java的原因是

(a)要发展航空仿真软件

(b)要发展人工智能软件

(c)要发展消费性电子产品

6.Java是从哪种语言改进并重新设计？

(a)Ade

(b)C++

(c)Pascal

7.Java因为什么快速发展而走红？

(a)个人计算机与网络

(b)游戏软件

(c)系统软件

8.Java程序的种类有：

(a)内嵌于Web文件中，由浏览器来观看的

(b)可独立运行的

(c)服务器端的

9.Java是面向对象语言，对象是客观事物的，对象与之是一一对应的，它是很具体的概

念。

10.判断：用Javac编译Java源文件后得到代码叫字节码。()

参考答案

1.答：面向对象、简单、平台无关性、安全性、内存管理、分布式应用、多线程、动

态、解释运行，高效能

2.答：在面向对象编程中，具体的客观实体称为对象，对象就是数据加方法。对象在

程序中是通过一种抽象数据类型来描述的，这种抽象数据类型称为类。类是对具有相同属性

和方法的一组相似对象的抽象，或者说类是对象的模板。

3.答：Java程序的运行必须经过编写、编译、运行三个步骤。编写是指在Java开发环

境中进行程序代码的输入过程，最终形成后缀名为.java源文件。编译是指使用Java编译器

对源文件进行错误排查的过程，编译后将生成后缀名为.class的字节码文件。运行是指使用

Java解释器将字节码文件翻译成机器代码，在cpu上运行并显示结果的过程。这过程如

图所示。

4.Java应用程序的运行经过编写、编译、运行三个步骤。

第1步，编写程序。使用记事本或其他软件编写程序的源代码，将源代码保存为文件

filename.java文件。

第2步，编译程序.在MS-DOS命令窗口，将当前目录转换到Java源程序所在的保存

目录；输入“javame.java”形式的命令进行程序编译。

第3步，执行程序。在同样的命令窗口中输入“javame”形式的命令执行程序

完成了程序的开发，查看相应t目录，其中应该具有两个文件，分别是XXXX.java和

XXXX.clasSo

5.c

6.b

7,a

8.AppletApplicationServlets

9.软件模型

lO.true

自考Java语言程序设计(一)第二章数据类型和流程控制课后习题

二、数据类型和流程控制

1.现有语句：Strings二"Example”;则下面哪些语句是合法语句？

A.s»>=3;B.s[3]=nxn;

C.inti=s.length();D.Stringt="For"+s;

E.s=s+10;

2.下面哪些是保留字？

A.runB.defaultC.implementD.import

3.下面声明float变量的语句合法的有：

A.floatfoo=-1;B.floatfoo=1.0;

C.floatfoo=42el;D.floatfoo=2.02f;

E.floatfoo=3.03d;F.floatfoo=0x0123;

4.下面方法中的“返回类型无效”应该是什么？

publicclassReturnlt{

return无效methodA(bytex,doubley){

return(short)x/y*2;

}

)

5.以下哪两个表达式是等价的：

A.3/2B.3V2c.3*4

D.3«2E,3*2八2F.3«<2

6.指出正确的表达式

A、byte=128;

B、Boolean=null;

C、longl=0xfffL;

D、double=0.9239d;

7.分析下列程序的执行结果：

(1)publicclassTest{

publicstaticvoidmain(Stringargs[]){

inti=oxFFFFFFFl;

intj=~i;

System.out.println("j=M+j);

(2)publicclassTest{

publicstaticvoidmain(String[]args){

System.out.println(6A3);

)

}

(3)publicclassFooBar{

publicstaticvoidmain(String[]args){

inti=0,j=5;

tP：

for(;;i++){

for(;;-j)

if(i>j)

breaktp;

)

System.out.println("i=n+i+H,j="+j);

)

}

(4)publicclassTest{

publicstaticvoidmain(){

inti=1,j=10;

do{

if(i++>-j)

continue;

}while(i<5);

System.out.println(,'i=M+i+"j="+j);

}

}

(5)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);

}

)

8.选出合理的标识符

A、

B、2mail

C、$change

D、class

9.判断：一个方法最多能有一个return语句()

10.Java语言中一个Char类型的数据占用2个字节大小的内存空间()

参考答案

1.cde

2.b,d

3.a,d,f

4.double

5.c,d

6.d

7.(1)c(2)5(3)i=0,j=-l

(4)i=5j=6(5)15020

8.ac

9.true

lO.ture

自考Java语言程序设计(一)第三章类与对象课后习题

三、类与对象

1.什么叫引用类型，对象是引用类型吗？

2.什么是类成员，什么是实例成员？他们之间有什么区别？

3.判断：数组、类和接口都是引用数据类型()

4.判断：类A和类B位于同一个包中，则除了私有成员，类A可以访问类B的所

有其他成员()

5.下面哪个修饰符修饰的变量是所有同一个类生成的对象共享的()

A、publicB^privateC、staticD、final采集者退散

6.下面关于java中类的说法哪个是不正确的()

A、类体中只能有变量定义和成员方法的定义，不能有其他语句。

B、构造函数是类中的特殊方法。

C、类一定要声明为public的，才可以执行。采集者退散

D、一个java文件中可以有多个class定义。

7.下列哪个类声明是正确的0

AabstractfinalclassHl{…}

Babstractprivatemove(){…}

Cprotectedprivatenumber：

DpublicabstractclassCar{…}

8.下述哪些说法是正确的？(多选)

A、实例变量是类的成员变量

B、实例变量是用static关键字声明的

C、方法变量在方法执行时创建

D、方法变量在使用之前必须初始化

9.设计一个动物类，它包含动物的基本属性。例如名称、大小、重量等，并设计

相应的动作，例如跑、跳、走等。

10.设计一个长方形类，成员变量包括长和宽。类中有计算面积和周长的方法，并

有相应的set方法和get方法设置和获得长和宽。编写测试类测试是否达到预定功能。要求

使用自定义的包。

参考答案

1.答：引用类型是指该类型的标识符表示的是一片内存连续地址的首地址。对象

是引用类型。

2.答：Java中使用static修饰的变量和方法称为类变量(或称静态变量)和类方

法(或称静态方法)，没用static修饰符的变量和方法称为实例变量和实例方法。

类成员是指该成员属于这个类，山这个类所创建的所有对象共同拥有，该成员仅在

类的存储单元中存在，这个类所创建的所有对象中仅存储一个指向该成员的引用。任何一

个该类的对象改变了类成员，其他对象同样会发生改变。对于类成员既可以使用对象访问，

也可以使用类名直接进行访问，并且在类方法中只能访问类变量，而不能访问实例变量。

实例成员是指该成员由每一个对象个体独有，对象的存储空间中的确有一块空间用

来存储该成员，不同对象的实例成员不同，任何一个对象改变了实例成员，只会影响这个

对象本身，其他对象中的实例成员不会发生改变。对于实例成员只能通过对象来访问，不能

通过类名进行访问，在实例方法中既可以访问实例变量，也可以访问类变量。

3.true

4.true

5.C

6.C

7.D

8.ACD

9.答:

publicclassAnimal{

privateStringname;

privatedoubleweight;

privateintlength;

privateStringsex;

publicvoidrun(){

System.out.println("theanimalisrunning!");

publicvoidjump(){

System.out.println("theanimalisjumping!");

}

publicvoidwalk(){

System.out.println(,,theanimaliswalking!");

}

)

10.答：

packagemypackage.math;

classRectangle{

privateintlength;

privateintwidth;

publicRectangle(intlength,intwidth){

this.length=length;

this.width=width;

)

publicvoidset(intlength,intwidth){

this.length=length;

this.width=width;

}

publicvoidget(){

System.out.println("此长方形的长为"+length+"宽为"+width);

)

publicintgetLength(){

returnlength;

)

publicintgetWidth(){

returnwidth;

)

publicintcalculatePerimeter(){

return2*(length+width);

)

publicintcalculateArea(){

return(length*width);

)

publicvoidprint(){

System.out.println(n此长方形的周长为H+calculatePerimeter()+M面积为

"+calculateArea());

)

)

classTest{

publicstaticvoidmain(String[]args){

Rectanglemyrectangle=newRectangle(15,10);

myrectangle.get();

myrectangle.print();

myrectangle.set(20,15);

System.out.println("长方形的长是"+myrectangle.getLength()+,,宽是"+

myrectangle.getWidth());

myrectangle.print();

自考Java语言程序设计（一）第四章方法与构造函数课后习题

四、方法与构造函数

1.Java的访问限定修饰符有几种，各自的访问权限是什么？

2.如何创建自己的包，如何引入包？

3.下面口那一个是类Myclass的构造函数？

classMyclass{

publicvoidMyclass(){}

publicstaticMyclass(){}

publicMyclass(){}

publicstaticvoidMyclass(){}

4.判断：类体中private修饰的变量在本类中能访问，类生成的对象也能访问。（）

5.判断：一个类中，只能拥有一个构造器方法。（）

6.Java中类成员的限定词有以下几种：private,public,,。其中，

的限定的范围最大。

7、被关键字修饰的方法是不能被当前类的子类重新定义的方法

8.设计Point类用来定义平面上的•个点，用构造函数传递坐标位置。编写测试

类,在该类中实现Point类的对象。

9.编写程序说明静态成员和实例成员的区别。

10.设计雇员Employee类，记录雇员的情况，包括姓名、年薪、受雇时间，要求

定义MyDate类作为受雇时间，其中包括工作的年、月、日，并用相应的方法对Employee

类进行设置。编写测试类测试Employee类。要求使用自己的包。

参考答案

1.答：Java的访问限定修饰符有4种，分别使public、protected、private和默认修

饰符。用public修饰的类或成员拥有公共作用域，表明此类或类的成员可以被任何Java中

的类所访问，是最广泛的作用范围。用protected修饰的变量或方法拥有受保护作用域，可

以被同一个包中所有的类及其他包中该类的子类所访问。用private修饰的变量或方法拥有

私有作用域，只能在此类中访问，在其他类中，包括该类的子类也是不允许访问的，private

是最保守的作用范围。没有任何修饰符拥有默认访问权限（友好访问权限），表明此类或类

的成员可以被同一个包中的其它类访问本文

2.答：创建自己的包只要将package语句作为Java源文件的第一句就可以了。例

packagemyPackage;声明创建了一个名为myPackage的包。

Java使用import语句来引入包及其中的类。例如importmyPackage.*；就引入了

myPackage包中所有的类。

3.答：publicMyclass(){}是类Myclass的构造函数。

4.false

5.false

6.friendlyprotected>public

7.Private

8.答：

classPoint

{intx,y;

Point(inta,intb)

{x=a;

y=b;

)

)

publicclassA

{publicstaticvoidmain(String[Jargs)

{Pointpl,p2;

pl=newPoint(lOJO);

p2=newPoint(23,35);

}

)

9.答：

classStaticTest{

inti=5;

staticintj=5;

voidprint(){

System.out.println("i=n+i);

System.out.println(,,j=',+j);

)

staticvoidclassprint(){

//System.out.println("i="+i);

System.out.println(,'j=,'+j);

)

}

classTest{

publicstaticvoidmain(String[Jargs){

//System.out.println(StaticTest.i);

System.out.println(StaticTest.j);

//StaticTest.print();

StaticTest.classprint();

StaticTestst=newStaticTest();

System.out.println(st.j);

System.out.println(st.j);

st.print();

st.classprint();

10.答：

packagemypackage.employee;

classMyDate{

privateintyear;

privateintmonth;

privateintday;

publicMyDate(intyear,intmonth,intday){

this.year=year;

this.month=month;

this.day=day;

)

publicintgetYear(){

returnyear;

)

}

publicclassEmployee{

privateStringname;

privatedoublesalary;

privateMyDatehireDay;

publicEmployee(Stringname,doublesalary,MyDateday){

=name;

this.salary=salary;

hireDay=day;

)

publicvoidprint(){

System.out.println(name+""+salary+"n+hireYear());

)

publicinthireYear(){

returnhireDay.getYear();

)

}

classTestEmployee{

publicstaticvoidmain(String[Jargs){

Employeea=newEmployee(“李明”,20000,newMyDate(2000,10,1));

Employeeb=newEmployee("王强”,24000,newMyDate(1995,8,12));

a.print();

b.print();

自考Java语言程序设计(一)第五章类的继承课后习题

五、类的继承

1.什么是继承?什么是父类?什么是子类?继承的特性可给面向对象编程带来什么好

处?什么是单重继承?什么是多重继承？

2.观察下面的程序片断，指出其中的父类和子类，以及父类和子类的各个域和方

法。

classSuperClass

(

intdata;

voidsetData(intnewData)

(

data=newData-

)

intgetData()

{

returndata-

}

}

classSubClassextendsSuperClass

(

intsuhData;

voidsetSubData(intnewData)

{

suhData=newData;

)

intgetData()

{

returnsubData;

}

)

3.”子类的域和方法的数目一定大于等于父类的域和方法的数目”，这种说法是否

正确?为什么？

4.在Java程序中，通过类的定义只能实现单重继承()

5.下列哪些说法是正确的？

A、Java语言只允许单一继承

B、Java语言只允许实现一个接口

C、Java语言不允许同时继承一个类并实现一个接口

D、Java语言的单一继承使得代码更加可靠

6.Java中所有类都是类的子类。

7.请写出下面程序的运行结果。

publicclassTestextendsTT{

publicvoidmain(Stringargs[]){

Testt=newTest(nTomM);

publicTest(Strings){

super(s);

System.out.println(nHowdoyoudo?");

)

publicTest(){

this(nIamTom");

}

}

classTT{

publicTT(){

System.out.printlnC^Whatapleasure!M);

)

publicTT(Strings){

this();

System.out.println(HIam"+s);

)

}

结果：________

8,父类的成员在子类中的访问权限由决定。

9.对象的使用包括引用对象的成员变量和方法。通过运算符就能实现对对象成员变

量的访问和对象

10.Java是面向对象语言，对象是客观事物的，对象与之是一一对应的，它是很具

体的概念。

参考答案：

1.答：继承是面向对象程序设计中两个类之间的一种关系。当一个类获取另一个

类中所有非私有的数据和操作的定义作为它自己的部分或全部成分时,就称这两个类之间具

有继承关系。被继承的类称为父类或超类，继承了父类或超类的所有数据和操作的类称为子

类。

面向对象程序设计中的继承，可使得程序结构更加清晰，降低了编码和维护的工作

量。如果一个类只能有一个父类，则这种继承关系称为单重继承；如果一个类可以有多个父

类，则这种继承关系称为多重继承。

2.答:

父类SuperClass

父类的域data

父类的方法setData(),getData()

子类SubClass

子类的域data,subData

子类的方法setSubData。，setData。，getData。采集者退散

3.答：这种说法是错误的，因为子类不一定能继承父类的所有域和方法，它只能

继承所有非私有的域和方法。如果子类在继承之外自己定义的域和方法数目小于父类中私有

成员的数目，则子类的域和方法的数目小于父类的域和方法的数目

4.true

5.AD

6.Object

7.答：

Whatapleasure!

IamTom

Howdoyoudo?

8.访问权限修饰符

9.

10.软件模型

自考Java语言程序设计(一)第六章重载与多态课后习题

六、重载与多态

1.判断：接口中的所有方法都没有被实现。()

2.方法重载是指()

A.两个或两个以上的方法取相同的方法名，但形参的个数或类型不同

B.两个以上的方法取相同的名字和具有相同的参数个数，但形参的类型可以不同

C.两个以上的方法名字不同，但形参的个数或类型相同

D.两个以上的方法取相同的方法名，并且方法的返回类型相同

3.什么是方法的覆盖?方法的覆盖与域的隐藏有何不同?与方法的重载有何不同？

4.解释this和super的意义和作用。

5.什么是多态?面向对象程序设计为什么要引人多态的特性?使用多态有什么优点?

6.Java程序如何实现多态?有哪些方式？

7.根据下面的要求编程实现复数类ComplexNumber。

(1)复数类ComplexNumber的属性

•m_dRealPart实部，代表复数的实数部分。

•m_dlmaginPart虚部，代表复数的虚数部分。

⑵复数类ComplexNumber的方法

,ComplexNumber。构造方法，将实部、虚部都置为0。

,ComplexNumber(doubler,doublei)构造方法，创建复数对象的同时完成复数的实

部、虚部的初始化；r为实部的初值，i为虚部的初值。

,getRealPart()获得复数对象的实部。

,getlmaginaryPart()获得复数对象的虚部。

,selRealPart(doubled)把当前复数对象的实部设置为给定的形参的数字。

•setlmaginaryPart(doubled)把当前复数对象的虚部设置为给定形参的数字。

•complexAdd(ComplexNumberc)当前复数对象与形参复数对象相加，所得的结果

也是复数值，返回给此方法的调用者。

vomplexAdd(doublec)当前复数对象与形参实数对象相加，所得的结果仍是复数值,

返回给此方法的调用者。

,complexMinus(ComplexNumberc)当前复数对象与形参复数对象相减，所得的结

果也是复数值，返回给此方法的调用者。

8.什么是接口？为什么要定义接口?接口与类有何异同

9.•个类如何实现接口？实现某接口的类是否一定要重载该接口中的所有抽象方

法？

10.接U是否可以被继承?阅读下面的代码，试写出Subinterface中的抽象方法。

interfaceSupinterface

(

publicabstractintsupMethod()；

}

interfaceSubinterfaceextendsSupinterface

(

publicabstractstringsubMethod()；

}

参考答案：

1.true

2.A

3.答：子类重新定义父类中己经存在的方法，称为方法的覆盖。注意：方法覆盖

与域的隐藏不同。子类重新定义父类已有的域，并不能完全取代它从父类那里继承的同名

的域，这个域仍然占用子类的内存空间，在某些情况下会被使用；而当子类重新定义父类的

方法时，从父类那里继承来的方法将被新方法完全取代，不再在子类的内存空间中占一席

之地。与方法的覆盖不同，重载不是子类对父类同名方法的重新定义，而是在一个类中定义

了同名的不同方法。

4.答：关键字this指代当前类的当前对象，关键字super指代当前类的直接父类

对象。

5.答：一个类中存在多个同名的方法，称为多态。把抽象功能和目的相同，而具

体实现因不同情况而异的方法命名为同名方法，符合面向对象程序设计中抽象、提升概念，

封装、隐藏细节的特点，从而提高了程序的简洁性和可读性，降低了类和程序模块直接的相

互耦合和依赖。

6.答：Java程序通过覆盖和重载两种方式来实现多态。覆盖是子类重新定义父类

中已有的方法，重载是在•个类内部定义与已存在的方法同名但是参数列表不同的方法。

7.答：

publicclassch5_e5_12

(

publicstaticvoidmain(Stringargs[])

(

ComplexNumbercNumber_l=

newComplexNumber(3,-5);

ComplexNumbercNumber_2=

newComplexNumber(2,2);

doubled=10.0;

System.out.println(cNumber_l.toString()+*'加"

+cNumber_2.toString()+"等于"

+cNumber_plexAdd(cNumber_2).toString());

System.out.println(cNumber_l.toString()+n力口”

+d+”等于“

+cNumber_plexAdd(d).toStringO);

System.out.println(cNumber_I.toString()+"减”

+cNumber_2.toString()+"等于"

+cNumber_plexMinus(cNumber_2).toString());

System.out.println(cNumber_l.toString()+"减”

+d+”等于”

+cNumber_plexMinus(d).toString());

System.out.println(cNumber_l.toString()+n乘”

+cNumber_2.toString()+"等于"

+cNumber_plexMulti(cNumber_2).toString());

System.out.println(cNumber_l.toString()+"乘”

+d+”等于“

+cNumber_plexMulti(d).toSlring());

)

}

classComplexNumber

(

〃域

privatedoublem_dRealPart;

privatedoublem_d!maginPart;

〃构造方法

ComplexNumber()

(

m_dRealPart=0.0;

m_dImaginPart=0.0;

}

ComplexNumber(doubler,doublei)

{

m_dRealPart=r;

m_dImaginPart=i;

}

ComplexNumber(ComplexNumberc)

(

m_dRealPart=c.getRealPart();

m_dImaginPart=c.getImaginaryPart();

)

//get,set方法

doublegetRealPart()

(

returnm_dRealPart;

)

doublegetImaginaryPart()

(

returnm_dImaginPart;

voidsetRealPart(doubled)

m_dRealPart=d;

}

voidsetImaginaryPart(doubled)

(

m_dImaginPart=d;

)

//复数运算方法

ComplexNumbercomplexAdd(ComplexNumberc)

(

returnnewComplexNumber(

this.m_dRealPart+c.getRealPart(),

this.m_dImaginPart+c.getImaginaryPart());

}

ComplexNumbercomplexAdd(doublec)

(

returnnewComplexNumber(

this.m_dRealPart+c,this.m_dImaginPart);

I

ComplexNumbercomplexMinus(ComplexNumberc)

(

returnnewComplexNumber(

this.m_dRealPart-c.getRealPart(),

this.m_dImaginPart-c.getlmaginaryPartO);

)

ComplexNumbercomplexMinus(doublec)

{

returnnewComplexNumber(

this.m_dRealPart-c,this.m_dImaginPart);

)

ComplexNumbercomplexMulti(ComplexNumberc)

(

returnnewComplexNumber(

this.m_dRealPart*c.getRealPart()

-this.m_dImaginPart*c.getImaginaryPart(),

this.m_dRealPart*c.getImaginaryPart()

+this.m_dImaginPart*c.getRealPart());

)

ComplexNumbercomplexMulti(doublec)

(

returnnewComplexNumber(

this.m_dRealPart*c,this.m_dImaginPart*c);

//toStringO

publicStringtoStringO

returnn(n+m_dRealPart+”+

+m_dImaginPart+"i"+

)

8.答：接口是用来实现类间多重继承功能的结构。接口与类相似，但是接口中只

能包括常量和抽象方法。定义接口相当于定义了一组抽象的功能、属性集合，可以使了ava

程序的类层次结构更加合理，并实现多重继承。

9.答：使用关键字implements可以定义类实现某接口。实现某接口的类如果不是

抽象类，则需要通过重载来实现该接口中的所有抽象方法；如果这个类是抽象类，则它可以

不必实现该接口中的所有抽象方法。

10.答：接口可以被继承。

Subinterface中的抽象方法有:publicabstractintsupMethod()；和publicabstractstring

subMethod()；两个。

自考Java语言程序设计(一)第七章Java常用类库介绍课后习题

七、Java常用类库介绍

1.指出下列陈述是对还是错，并做出解释。

(1)当String对象用==比较时，如果String包括相同的值则结果为true。

(2)一个String类的对象在其创建后可被修改。

2.对于下列描述，各写出〜条语句完成要求的任务

(1)比较si中的串和s2中的串的内容的相等性；

(2)用+=向串si附加串；

(3)判断si中串的长度；

3.说明capacity。与length。用法上的差异？

4.如果ch为StringBuffer对象，ch="JavaApple",下列结果为何？

(1)ch.insert(3/p')(2)ch.append("Basic")

(3)ch.setlength(5)(4)ch.reverse()

5.Math类中提供用来常数灭和e的静态属性分别是什么？

6.下面关于Vecta•类的说法正确的是()

(1)类Vector在java,util包中。

(2)一个向量(Vector)对象存放的是一组有序的对象。

(3)一个向量(Vector)对象大小可以根据存放的元素个数的增加而自动增加。

(4)一个向量(Vector)对象中每个元素可以是不同类型的对象。

7.有三个字符串，编写程序找出其中最大者。

8.编写一个程序，设定一个有大小写字母的字符串，先将字符串的大写字符输出，

再将字符串中的小写字符输出。

9.设定5个字符串，要求只打印那些以字母“b”开头的串，编写程序完成。

10.设定一个有大小写字母的字符串和一个查找字符，使用类String方法IndexOfO

来判断在该字符串中该字符出现的次数。

参考答案

1.答：

(1)错。用==操作符比较String对象实际上是判断它们在内存中是否为同•对象,

并不是判断它们的值是否相同。

(2)错。String类的对象是常量。它们被创建后不可被修改。

2.答：

(1)sl.equals(sl,s2);

(2)sl+=s2;

(3)sl.length();

3.答：capacity()返回字符串对象的当前缓冲区的长度，length。返回字符串对象

字符的长度。

4.答：

(1)结果：JavpaApplet

(2)结果：JavpaAppletBasic

(3)结果：ch长度变为5

(4)结果:apvaJ

5.答：PLE

6.答：(3)

7.

publicclassmaxi

(

publicstaticvoidmain(Stringargs[])

(

Stringsl="HelloJava1,;

Strings2="JavaApplet”；

Strings3="Java";

Strings;

if(s1.compareTo(s2)<0)

s=s2;

elses=s1;

if(pareTo(s3)<0)

s=s3;

Systrm.out.println(,'big="+s);

)

}

8.

publicclassout

(

publicstaticvoidmain(Stringargs[J)

(

Stringsl="HelloJava1';

StringBufferbufup=newStringBuffer();

StringBufferbuflow=newStringBuffer();

for(intI=0;I

{if(s1.charAt(i)<97)

{bufup.append(sl.charAt(i));

bufup.appendC*);

)

else{

buflow.append(sl.charAt(i));

buflow.append(")；

}

I

System.out.println("s1=M+sl);

System.out.println(nuppercase=H+bufup);

System.out.println(nlowercase="+buflow);

)

)

9.

publicclassprin_b

{publicstaticvoidmain(Stringargs[])

(

Stringsl='hellon;

Strings2="been;

Strings3=ujava";

Strings4="brove";

Strings5="bag";

if(sl.indexOf('b')==0)

System.out.println(s1);

if(s2.indexOf(rb')==0)

System.out.println(s2);

if(s3.indexOf(,b')==0)

System.out.println(s3);

if(s4.indexOf(,b,)==0)

System.out.println(s4);

if(s5.indexOf(rb')==0)

System.out.println(s5);

)

}

10.

publicclassppp

(

publicstaticvoidmain(Stringargs[J)

(

Stringsl="abcdefghi";

intnum=0;

for(inti=0;i

{i=sl.indexof('e,,i);

num++;

System.out.print(nsl="+sl+ue=n);

if(num==0)

System.out.println(nnofound");

elseSystem.out.println(num);

自考Java语言程序设计(一)第八章Java异常处理及输入输出流简介课后习题

八、Java异常处理及输入输出流简介

I.列出5个常见的异常。

2.写出Java语言的异常处理机制的优点。

3.为什么异常处理技术不应该用于常规的程序控制？

4.引起异常产生的条件是什么？

5.异常没有被捕获将会发生什么？

6.编写一个程序，以说明catch(Exceptione)如何捕获各种异常。

7.下面的代码段中finally语句块会被执行吗？

publicclassExceplionExam3

{

publicstaticvoidmain(String[]args)

(

try

(

int[]a=newint[3];

System.exit(O);

)

catch(Array!ndexOutOfBoundsExceptione)

{System.out.println("发生了异常”);}

finally

{System.out.println("Finally");}

)

}

8.throws的作用是什么？

9.应在程序的什么地方使用异常处理？

10.下面的代码有什么错误吗？

classExceptionExamf,•,)

thrownewExceptionExam();

11.异常类型匹配的处理方式。程序功能：首先输出“这是一个异常处理的例子”,

然后在你程序中主动地产生一个ArithmeticException类型被0除而产生的异常，并用catch

语句捕获这个异常。最后通过ArithmeticException类的对象e的方法getMessage给出异常

的具体类型并显示出来•

12.根据所给创建自定义异常类的使用格式，编写一个自定义异常的小程序。

13.什么叫流？流式输入输出有什么特点？

14.Java流被分为字节流、字符流两大流类，两者有什么区别？

15.File类有哪些构造函数和常用方法？

16.利用文件输入输出流编写•个实现文件拷贝的程序，源文件名和目标文件名通

过命令行参数传入。

17.编写一个程序，在当前目录下创建一个子目录test,在这个新创建的子目录下

创建一个文件，并把这个文件设置成只读。

18.位置指针的作用是什么？RandomAccessFile类提供了哪些方法实现对指针的控

制？

19.编写一个程序，从键盘输入一串字符，统计这串字符中英文字母、数字、其他

符号的字符数。

20.编写•个程序，从键盘输入一串字符，从屏幕输出并将其存入a.txt文件中。

采集者退散

21.编写一个程序，从键盘输入10个整数，并将这些数据排序后在标准输出上输

出。

参考答案

1.答：内存耗尽、数组下标超出边界、被。除、非法的方法参数、算法溢出处。

2.答:(1)Java通过面向对象的方法进行异常处理，把各种异常事件进行分类，

体现了良好的层次性，提供了良好的接口，这种机制对于具有动态特性的复杂提供了强有

力的控制方式。(2)Java的异常处理机制使得处理异常的代码和“常规”代码分开，减少了

代码的数量，增强了程序的可读性。(3)Java的异常处理机制使得异常事件可以沿调用栈

自动向上传播，而不是C语言中通过函数的返回值来传播，这样可以传递更多的信息，并

且简化了代码的编写。(4)由于把事件当成事件处理，利用类的层次性我们可以把多个具

有相同父类的异常统一处理，也可以区分不同的异常分别处理，使用非常灵活。

3.答：a.异常处理用于不经常发生但通常导致程序终止的情况，因此要求编程人

员为编译器的优化执行实现异常处理。b.常规控制结构的控制流程通常比异常的更为清晰、

交流更高。c.在发生异常，并且没有释放异常发生之前分配的资源时，堆栈是展开的，所

以会出现一些问题。d.“额外的”异常会妨碍真正错误类型的异常。这种使程序员更难以

跟踪大量的异常。

4.答：异常产生的方式有3种。第一种是在某些内部错误时，Java虚拟机可以产

生异常，该异常不在你的程序控制范围内，通常不作处理。第二种是由程序代码中的错误引

起，这种异常需要你的程序处理。第三种是通过使用throw语句手动生成的异常。

5.答：未捕获的异常最终会导致程序非正常终止。

6.publicclassExceptionExam

{

publicstaticvoidmain(String[]args)

{

try

{

inti=0;

i=3/i;〃将产生算术异常。

catch(ArithmeticExceptione)〃找到了匹配的异常，执行该catch块。

System.out.println("发生了ArithmeticException异常")；

)

catch(AarryIndexOutOfBoundsExceptione)〃不是匹配的异常，且不会再捕获

〃异常，如果发生数组索引超出范围所产生的异常，将执行该catch块。

(

System.out.println("发生了AarrylndexOutOfBoundsException异常");

I

catch(Exceptior)e)

〃前两个catch块均无法捕获try块中发生的异常时，才会执行该catch块。

{

System.out.println("发生了异常，

}

finally

{System.out.println("执行dFinally");}

I

)

7.答：无论是出于何种原因，只要执行离开try/catch代码块，就会执行finally代

码块。即无论try是否正常结束，都会执行finally定义的最后的代码。如果try代码块中的

任何代码或它的任何catch语句从方法返回，也会执行finally代码块。但本题中在try代码

块中执行了“System.exit(O);”语句，执行了这一语句后，Java虚拟机(JVM)将被终止。

那么finally语句块一定不会被执行。

8.答：在某些情况下，如果一个方法产生自己不处理或无法处理的异常，它就必

须在throws子句中声明该异常。

9.答：通常，可以采用两种方式来报告错误：返回值和异常。在Java中异常处理

很常用，虽然返回错误代码在某些情况下是一种有效的方式，但是异常处理可以提供强大的

结构化方法来处理异常。所以需要处理代码中的错误时就可以采用异常的方法进行处理。

10.答：ExceptionExam不是继承(扩展)Throwable的子类，只有Throwable的子

类可以由throw抛出。所以，这一段代码会出错。

11.

publicclassExceptionExam1

(

publicstaticvoidmain(String[]args)

{

try

{inti=0;

i=3/i;

}

catch(ArithmeticExceptione)

(

System.out.println("异常是:"+e.getMessage());

finally

System.out.printlnC'finally