第一章 面向对象的程序设计基础
一、选择题
1．Java是一门（ ）语言。
A. 机器 B. 汇编 C. 面向过程的高级 D. 面向对象的高级
2．机器语言中的指令编码为（ ）编码。
A. 二进制 B. 符号 C. 十进制 D. 数字
3．更接近人类自然语言的计算机语言是（ ）语言。
A. 机器 B. 汇编 C. 高级 D. 数字
4．对象是构成现实世界的一个独立单位，它具有自己的静态特征和（ ）特征。
A. 颜色 B. 动态 C. 状态 D. 重量
5．类是对具有共同属性和行为的对象的抽象描述，每个对象称为该类的一个（ ）。
A. 产品 B. 元素 C. 成分 D. 实例
6．Java语言的主要特点不包括（ ）。
A. 面向对象 B. 自动垃圾回收 C. 处理文件 D. 可移植性
7．Java语言的主要特点不包括（ ）。
A. 处理字符串 B. 安全性 C. 多线程 D. 解释执行
8. 具有相同属性和服务的一组对象的模板称为（ ）。
A. 程序 B. 类 C. 代码 D. 概念
9. 把对象的属性和服务组合成一个独立的整体，尽可能隐蔽其内部的细节，这称为对象的（ ）。
A. 封装性 B. 多态性 C. 继承性 D. 开放性
10．使用JDK编译Java程序时使用的命令是（ ）。
A. java B. javac C. appletviewer D. javadoc
11．使用JDK运行Java程序时使用的命令是（ ）。
A. java B. javac C. appletviewer D. javadoc
12．Java开发工具包简称为（ ）。
A. JKD B. JRK C. JDK D. JRE
第2章 Java程序设计基础
一、选择题
1．组成Java程序的最小单位是（ ）。
A. 类 B. 方法 C. 变量 D. 常量
2．在Java程序中包含主方法的类被称为主类，主方法名为（ ）。
A. Main B. main C. void D. args
3．在Java程序中包含主方法的类被称为主类，主方法的访问控制修饰符为（ ）。
A. private B. protected C. public D. static
4．在Java程序中包含主方法的类被称为主类，主方法的存储控制属性应定义为（ ）。
A. final B. abstract C. short D. static
5．Java语言中的基本数据类型有9种，其中属于数值型的数据类型有（ ）种。
A. 5 B. 6 C. 7 D. 8
6．Java语言中的switch语句属于（ ）语句。
A. 数据输入 B. 数据输出 C. 分支处理 D. 循环控制
7．先执行循环体，后进行循环条件判断的语句是（ ）。
A. for B. while C. if D. do…while
8．当循环执行的次数已知时，最后使用（ ）语句。
A. for B. while C. do…while D. switch
9．在类的定义中，若需要把一个标识符定义为常量，则使用的修饰符为（ ）。
A. const B. final C. static D. class
10．在类的定义中，若需要把一个属性或方法定义为类成员，而不是实例成员，则使用的修饰符为（ ）。
A. const B. final C. static D. public
11．在程序中引入包的语句关键字为（ ）。C，把所定义的类包含于指定包中的语句关键字为package。
A. volatile B. pack C. import D. package
12．在程序中声明包的语句关键字为（ ）。
A. volatile B. pack C. import D. package
13．在派生类的定义中，继承父类子句所使用的关键字为（ ）。
A. extends B. implements C. public D. abstract
14．在类的定义中，实现接口子句所使用的关键字为（ ）。
A. extends B. implements C. public D. abstract
15．在一个方法的方法头（声明）中向调用它的上一层方法抛出异常的子句关键字为（ ）。
A. catch B. throw C. throws D. finally
16．Java语言中规定的转义字符，以（ ）字符作前缀。
A. ' B. " C. / D. /
17．Java语言中转义字符'/n'代表（ ）。
A. 回车 B. 换行 C. 换页 D. 空格
二、填空题
1．Java类库也称为Java API，它是Application Programming Interface的缩写，中文含义为________。
2．Java语言中的实数类型有两种，其类型关键字分别为________和________。
3．Java语言中的布尔类型的关键字为__________，它的两种取值分别为关键字________和________。
4．Java语言中的char和int的类型长度分别为________和________个二进制位。
5．当一个方法的返回类型被定义为________时，表明该方法不返回任何值。
6．Java语言中表示当前类和父类的关键字分别为________和________。
7．Java语言中用于修饰类的成员具有公共或保护访问属性的关键字分别为________和________。
8．Java语言中用于修饰类的成员具有保护或私有访问属性的关键字分别为________和________。
9．Java语言中用于修饰类的成员具有公共或私有访问属性的关键字分别为________和________。
10．Java语言中的方法Math.sqrt(x)是求x的________的值。
11．Java语言中的方法Math.pow(x,y)为求x的y________的值。
12．Java语言中的方法Math.random()返回0到________之间的一个随机小数。
13．Math.sqrt(16)和Math.pow(3,4)的值分别为________和________。
14．算术表达式25/6和25%6的值分别为________和________。
15．假定整数变量x的值为10，则执行y=2*x++赋值后，x和y的值分别为________和________。
16．假定整数变量x的值为10，则执行y=2*--x赋值后，x和y的值分别为________和________。
17．假定整数变量x和y的值分别为5和10，则逻辑表达式x>5 && y<=10的值为________。
18．假定整数变量x和y的值分别为5和10，则逻辑表达式x>5 || y<=10的值为________。
三、写出下列每个主函数运行后的输出结果。
1. public static void main(String[] args) {
int x, y=0;
for(x=1; x<5; x++) y+=x*x;
System.out.println("y="+y);
}
2. public static void main(String[] args) {
int x=1, y=1;
while(x++<5) y+=x*x;
System.out.println("y="+y);
}
3. public static void main(String[] args) {
int x=1, y=0;
do {y+=x*x;} while(++x<=5);
System.out.println("y="+y);
}
4. public static void main(String[] args) {
int x, y=0;
for(x=1; x<10; x++)
if(x%2==0) y+=x*x;
System.out.println("y="+y);
}
5. public static void main(String[] args) {
int c0=0, c1=0, c2=0;
for(int x=1; x<=20; x++) {
switch(x%3) {
case 0: c0++; break;
case 1: c1++; break;
case 2: c2++; break;
}
}
System.out.println("c0,c1,c2="+c0+","+c1+","+c2);
}
6. public static void main(String[] args) {
int i=1, s=0;
while(true) {
if(i%2==0) s+=i;
if(i++>=10) break;
}
System.out.println("s="+s);
}
第3章 类与对象
一、选择题
1．在类的定义中，每个成员的访问权限有（ ）种选择。
A. 2 B. 3 C. 4 D. 5
2．具有（ ）访问权限的成员能够被本类和同一包中的其他任何类中的成员所访问。
A. 公有 B. 保护 C. 私有 D. 缺省
3．具有（ ）访问权限的成员只能被本类中的成员所访问。
A. public B. protectd C. private D. 缺省
4．具有（ ）访问权限的成员能够被本类和任何其他类中的成员所访问。
A. public B. protectd C. private D. 缺省
5．在类定义首部的语法格式中，（ ）不能作为其中的修饰符。
A. public B. protectd C. extends D. abstract
6．在类定义首部的语法格式中，（ ）不能作为其中的修饰符。
A. abstract B. implements C. private D. final
7．在类定义首部的语法格式中，（ ）不能作为其中的修饰符。
A. extends B. implements C. public D. finally
二、填空题
1．假定一个类的类名为XXK1，则该类的构造方法的名称为________。
2．假定没有给一个类XXK2显式地定义任何构造函数，则利用new运算创建该类的一个对象时，自动调用的构造方法为________。
3．一个类的（ ）方法没有返回值。
4．创建一个类的对象需要使用的单目运算符为________。
5．假定要采用默认的构造方法定义和创建类XXK3的一个对象x，则使用的语句为________________。
6．类中一个方法定义的参数表中，每个参数的名称（允许/不允许）________与该类成员变量的名称相同。
7．假定类中定义的一个成员变量名为xyz，在一个方法定义的参数表中，一个参数名也为xyz，则把参数xyz的值赋给成员变量xyz的赋值语句为______________。
8．在一个类中定义的任何方法都允许重载，在重载的多个方法中，________是相同的，但_______是不同的。
9．当类中的成员定义采用static关键字修饰时，则称该成员为类的（静态/实例）________成员。
10．假定要在一个类中访问另一个类XXK4中的静态成员abc，则此访问应表示为________。
11．假定要在一个类XXK5中访问另一个类XXK4中的实例成员abc，则首先要在XXK5中创建________类的一个实例对象，然后通过这个对象进行访问。
12．假定要利用一个类XXK6的对象x访问成员方法size()，则应表示为__________。
13．假定要利用一个类XXK6访问类（静态）方法size()，则应表示为__________。
14．类中的成员变量还可以使用关键字________进行修饰，表示其值被初始化后不能够再被修改。
15．类中的成员方法也可以使用关键字________进行修饰，表示该方法在继承类中不能被重载。
16．方法定义中的参数表称为形式参数表，其中的参数称为形式参数，每个形式参数的定义（声明）包括________和________两个方面。
17．方法调用中的参数表称为________参数表，其中的参数称为实际参数，每个实际参数是一个________。
18．在方法调用中，首先需要实参表中的实参向形参表中的形参进行传递，此传递分为_______传递和_______传递两种方式。
19．在方法调用的参数传递中，对于基本数据类型的参数，则按照________进行传递，对于数组类型或类类型的参数则按照________进行传递。
20．在方法调用的参数传递中，若为________传递，则实参变量和形参变量所引用的是内存中的同一个存储空间，方法体对形参内容的修改实际上就是对实参内容的修改。
21．在方法调用的参数传递中，若为________传递，方法体中对形参内容的修改不影响实参的值。
三、写出下列每个主函数运行后的输出结果。
1. public class XXK2 {
private int a,b;
public XXK2(int aa, int bb) {a=aa; b=bb;}
public int f1(int x) {
if(x>10) return a+b+3*x;
else return a*b*x;
}
public static void main(String[] args) {
XXK2 x=new XXK2(3,4);
int y=x.f1(8);
System.out.println("y="+y);
}
}
2. public class XXK2 {
private int a,b;
public XXK2(int aa, int bb) {a=aa; b=bb;}
public int f1(int x) {
if(x>10) return a+b+3*x;
else return a*b*x;
}
public static void main(String[] args) {
XXK2 x=new XXK2(3,4);
int y=x.f1(12);
System.out.println("y="+y);
}
}
3. public class XXK2 {
private final int a;
public XXK2(int a) {this.a=a;}
public int f1(int x) {
if(x%2==1) return 2*(a+x);
else return 3*a+x;
}
public int get() {return a;}
public static void main(String[] args) {
XXK2 x=new XXK2(3);
int y=x.f1(10);
y+=x.get();
System.out.println("y="+y);
}
}
4. public class XXK2 {
private final int a;
public XXK2(int a) {this.a=a;}
public int f1(int x) {
if(x%2==1) return 2*(a+x);
else return 3*a+x;
}
public int get() {return a;}
public static void main(String[] args) {
XXK2 x=new XXK2(8);
int y=x.f1(20);
y+=x.get();
System.out.println("y="+y);
}
}
5. public class XXK2 {
private int a;
public XXK2(int aa) {a=aa;}
public int f1(int x) {
if(x%2==1) return 2*(a+x);
else return 3*a+x;
}
public int get() {return a;}
public static void main(String[] args) {
XXK2 x=new XXK2(5);
int y=x.f1(9);
y+=x.get()*x.get();
System.out.println("y="+y);
}
}
6. public class XXK2 {
private int a;
public XXK2() {a=3;}
public XXK2(int aa) {a=aa;}
public double f1() {
return 2*Math.pow(a,3)+a;
}
public static void main(String[] args) {
XXK2 x=new XXK2(), y=new XXK2(5);
System.out.println(x.f1()+", "+y.f1());
}
}
第4章 类的继承与多态
一、填空题
1．Java语言中的每个类都隐含着继承一个父类，这个父类为__________。
2．Java语言中的一个类只能有________个父类，可以有________个派生类。
3．Java语言中的类的层次结构为________结构。根节点为________类。
4．在派生类的构造方法中调用父类构造方法时，其语句关键字为________。
5．定义一个抽象类需要在类首部的关键字class前使用的修饰符为________。
6．定义一个终结类需要在类首部的关键字class前使用的修饰符为________。
二、判断题
1．一个新类可以从现有的类中派生，这个过程称为类继承。
2．根据已有类继承定义出的新类称为已有类的派生类（子类），已有类称为超类（父类）。
3．Java不支持类的多重继承，只支持类的单继承。
4．Java既支持类的单继承，又支持类的多重继承。
5．如果在派生类的构造方法的定义中没有明确调用父类的构造方法，则系统在执行派生类的构造方法时会自动调用父类的缺省（默认）构造方法。
6．如果在派生类的构造方法的定义中没有明确调用父类的构造方法，则系统在执行派生类的构造方法时也不会隐含调用父类的缺省构造方法。
7．如果在派生类的构造方法的定义中需要调用父类的构造方法，则super语句必须出现在派生类构造方法体中的第一行。
8．如果在派生类的构造方法的定义中需要调用父类的构造方法，则super语句可以出现在派生类构造方法体中的任何位置。
9．在一个派生类中，可以定义与上层父类中的成员同名的变量。
10．在一个派生类中，不能定义与上层父类中的成员同名的变量。
11．一个派生类的对象可以直接赋值给上层父类的对象。
12．一个父类的对象可以直接赋值给下层子类的对象。
13．一个父类的对象经过强制转换后，可以赋值给下层子类的对象。
14．任何一个派生类的引用变量（或对象）都可以被当成一个父类的引用变量（或对象）。
15．任何一个父类的引用变量（或对象）都可以被当成一个派生类的引用变量（或对象）。
16．派生类可以直接访问从父类中继承下来的所有成员变量及方法。
17．派生类不能直接访问从父类中继承下来的私有成员变量及方法。
18．在派生类中不能定义与父类中具有相同名称和参数表的方法。
19．在派生类中能够定义与父类中具有相同名称和参数表的方法。
20．在Java语言中，既可以根据一个类创建对象，也可以根据一个接口创建对象。
21．在Java语言中，只能根据一个类创建对象，不能根据一个接口创建对象。
22．在Java语言中，可以把实现了一个接口的类对象，赋给这个接口的变量。
23．在Java语言中，不能把实现了一个接口的类对象，赋给这个接口的变量。
24．Java中的动态多态性实现手段是覆盖基类中的同名成员函数，其调用规则是依据对象在实例化时而非定义时的类型调用对应类中的同名成员函数。
25．抽象类要包含一些抽象方法，这种抽象方法只有方法的声明，而没有方法的实现。
26．抽象类只允许包含抽象方法，不允许包含非抽象的方法。
27．在一个抽象类中，也可以包含成员变量和构造方法。
28．在一个抽象类中，不允许包含成员变量和构造方法。
29．接口中的所有方法都是抽象的，每个方法都只有方法声明，而没有方法体。
30．在Java语言中，既不能利用抽象类生成对象，也不能利用接口生成对象。
31．在Java语言中，既可以利用抽象类生成对象，也可以利用接口生成对象。
32．在Java语言中，能够利用抽象类生成对象，但不能利用接口生成对象。
33．接口中的所有成员方法都默认具有public和abstract修饰。
34．接口中的一些成员方法默认不具有public和abstract修饰。
35．定义接口使用的语句关键字为interface，一个接口还可以继承一个或多个接口，所使用的子句关键字为extends。
36．定义接口使用的语句关键字为interface，一个接口不能够继承任何其他接口。
37．一个类可以实现一个或多个接口，所使用的子句关键字为implements。
38．一个类只能实现一个接口，所使用的子句关键字为implements。
39．在Java语言中，允许将一个类声明置入另一个类声明中，称这种类为"内部类"。
40．在Java语言中，一个类不能被定义在另一个类之中，类与类之间没有包含关系。
41．在Java语言中，使用包提供了包一级的封装及存取权限。
42．一个包不仅可以包含若干个类字节码文件，还可以包含若干个包。
43．一个包只能包含若干个类字节码文件，不能够再包含其他包。
44．在Java语言中，声明包语句的关键字为package，引入包语句的关键字为import。
45．在Java语言中，声明包语句的关键字为import，引入包语句的关键字为package。
46．在Java语言中，声明包语句可以出现在一个Java程序文件的任何位置。
47．在Java语言中，声明包语句只允许是一个Java程序文件的第一条语句。
三、写出下列每个主函数运行后的输出结果。
1. class Rectangle {
private int a,b;
public Rectangle(int aa, int bb) {a=aa; b=bb;}
public int area() {return a*b;}
public int girth() {return 2*(a+b);}
}
public class XXK3 extends Rectangle {
private int c;
public XXK3(int aa, int bb, int cc) {super(aa,bb); c=cc;}
public int volume() {return area()*c;}
public int arrisLength() {return 2*girth()+4*c;}
public static void main(String[] args) {
XXK3 x=new XXK3(2,3,4);
int y1=x.volume();
int y2=x.arrisLength();
System.out.println(y1+", "+y2);
}
}
2. class Rectangle {
private int a,b;
public Rectangle(int aa, int bb) {a=aa; b=bb;}
public int area() {return a*b;}
public int girth() {return 2*(a+b);}
}
public class XXK3 extends Rectangle {
private int c;
public XXK3(int aa, int bb, int cc) {super(aa,bb); c=cc;}
public int volume() {return area()*c;}
public int arrisLength() {return 2*girth()+4*c;}
public static void main(String[] args) {
XXK3 x=new XXK3(1,3,5);
int y1=x.volume();
int y2=x.arrisLength();
System.out.println(y1+", "+y2);
}
}
3. abstract class Shape {
int a,b;
public Shape(int aa, int bb) {a=aa; b=bb;}
abstract public double area();
}
class Rectangle extends Shape {
public Rectangle(int aa, int bb) {super(aa,bb);}
public double area() {return a*b;}
}
class Triangle extends Shape {
public Triangle(int aa, int bb) {super(aa,bb);}
public double area() {return a*b/2;}
}
public class XXK3 {
public static void main(String[] args) {
Shape x,y;
x=new Rectangle(5,8);
y=new Triangle(5,8);
System.out.println(x.area()+", "+y.area());
}
}
4. abstract class Shape {
int a,b;
public Shape(int aa, int bb) {a=aa; b=bb;}
abstract public double area();
}
class Rectangle extends Shape {
public Rectangle(int aa, int bb) {super(aa,bb);}
public double area() {return a*b;}
}
class Triangle extends Shape {
public Triangle(int aa, int bb) {super(aa,bb);}
public double area() {return a*b/2;}
}
public class XXK3 {
public static void main(String[] args) {
Shape x,y;
x=new Rectangle(10,20);
y=new Triangle(10,15);
System.out.println(x.area()+", "+y.area());
}
}
5. interface Shape {
double area();
double girth();
}
class Rectangle implements Shape {
int a,b;
public Rectangle(int aa, int bb) {a=aa; b=bb;}
public double area() {return a*b;}
public double girth() {return 2*(a+b);}
}
public class XXK3 {
public static void main(String[] args) {
Shape x;
x=new Rectangle(6,10);
System.out.println(x.area()+", "+x.girth());
}
}
6. interface Shape {
double area();
double girth();
}
class Rectangle implements Shape {
int a,b;
public Rectangle(int aa, int bb) {a=aa; b=bb;}
public double area() {return a*b;}
public double girth() {return 2*(a+b);}
}
public class XXK3 {
public static void main(String[] args) {
Shape x;
x=new Rectangle(5,8);
System.out.println(x.area()+", "+x.girth());
}
}
第5章 字符串、数组与向量
一、填空题
1．在Java语言中，定义有两个字符串类，其类名分别为________和____________。
2．对于String类的字符串，其值和长度都不能被改变，所以被称为________字符串，对于StringBuffer类的字符串，其值和长度都可以被改变，所以被称为________字符串。
3．假定一个字符串对象x的值为"abcdef/n"，则x.length()的值为________。
4．假定一个字符串对象x的值为"abcdef/n"，则x.charAt(4)的值为________。
5．假定一个字符串对象x的值为"abcdef/n"，则x.substring(0,4)的值为________。
6．假定一个字符串对象x的值为"abc"，则x.concat("def")的值为________。
7．假定一个字符串对象x的值为"abc"，则x.compareTo("def")的值为________0。
8．假定一个字符串对象x的值为"abc"，则x.equals("acb")的值为________。
9．假定一个数组对象为x，则x.length的值为该数组所包含元素的________。
10．假定要定义一个int型的一维数组为x，并假定它的长度为10，则其定义语句为int [] x=________。
11．假定要定义一个int型的二维数组为x，并假定它的行数为5，列数为6，则其定义语句为int [][] x=________。
12．假定要访问一维数组x中的第k个元素，则对应的元素（下标变量）表示为________。
13．假定二维数组x中的一个元素为x[2][3]，则它的行下标和列下标分别为________和________。
14．假定一个一维数组的定义语句为"int[]x=new int[20];"，则x.length的值为________。
15．假定一个二维数组的定义语句为"int[][]x=new int[3][4];"，则该数组包含的元素个数为________。
16．假定一个二维数组的定义语句为"int[][]x=new int[3][4];"，则x.length和x[0].length的值分别为________和________。
17．基本数据类型int和double对应的包装类分别为________和________。
18．基本数据类型boolean和char对应的包装类分别为________和________。
二、判断题
1．数组的长度不能够被改变，而向量类(Vector)对象的长度可以被改变。
2．向量类(Vector)的对象同数组一样，即可以存储基本类型的数据，也可以存储对象类型的数据。
3．向量类Vector中的add(x)方法能够把x元素加入到当前对象的末尾。
4．向量类Vector中的add(x)方法能够把x元素加入到当前对象的开始位置。
5．向量类Vector中的size()方法能够返回向量中当前保存的元素的个数。
6．向量类Vector中的get(i)方法不能够返回向量中下标为i的元素值。
7．向量类Vector中的set(i,x)方法不能够把向量中下标为i的元素值修改为x的值。
三、写出下列每个主函数运行后的输出结果。
1. public class XXK4 {
public static void main(String[] args) {
int []a={2,5,8,10,15,20};
int s=0;
for(int i=0; i<a.length; i++) s+=a[i];
System.out.println("s="+s);
}
}
2. public class XXK4 {
public static void main(String[] args) {
int []a=new int[6];
int i,s=0;
for(i=1; i<a.length; i++) a[i]=a[i-1]+2;
for(i=0; i<a.length; i++) s+=a[i];
System.out.println("s="+s);
}
}
3. public class XXK4 {
public static void main(String[] args) {
String []a={"xxk","weirong","xucong","xuxiaohua","baojuan"};
int m=0;
for(int i=0; i<a.length; i++) {
int n=a[i].length();
if(n>m) m=n;
}
System.out.println("m="+m);
}
}
4. public class XXK4 {
public static void main(String[] args) {
int [][]a={{2,5,8},{3,6,9},{4,5,6}};
int s=0;
for(int i=0; i<a.length; i++)
for(int j=0; j<a[i].length; j++)
s+=a[i][j];
System.out.println("s="+s);
}
}
5. public class XXK4 {
public static void main(String[] args) {
int [][]a=new int[2][3];
int i,j,s=0;
for(i=0; i<a.length; i++)
for(j=0; j<a[i].length; j++)
a[i][j]=(i+1)*(j+1);
for(i=0; i<a.length; i++) s+=a[i][2];
System.out.println("s="+s);
}
}
6. public class XXK4 {
public static void main(String[] args) {
int [][]a={{2,5,8},{3,6,9},{4,5,6}};
int []b=new int[3];
int i,j;
for(i=0; i<a.length; i++)
for(j=0; j<a[i].length; j++)
b[i]+=a[i][j];
for(i=0; i<b.length; i++)
System.out.print(b[i]+" ");
}
}
7. class ABC {
int a,b;
public ABC(int a, int b) {this.a=a; this.b=b;}
public int compareTo(ABC x) {return a*b-x.a*x.b;}
}
public class XXK5 {
public static void main(String[] args) {
int [][]d={{3,8},{4,6},{5,6},{2,9},{3,7}};
ABC []ar=new ABC[5];
int i,k=0;
for(i=0; i<d.length; i++)
ar[i]=new ABC(d[i][0],d[i][1]);
for(i=1; i<ar.length; i++)
if(ar[i].compareTo(ar[k])>0) k=i;
System.out.println("k="+k);
}
}
8. class ABC {
int a,b;
public ABC(int a, int b) {this.a=a; this.b=b;}
public int compareTo(ABC x) {return a*b-x.a*x.b;}
}
public class XXK5 {
public static void main(String[] args) {
int [][]d={{3,8},{4,6},{5,6},{2,9},{6,7},{5,8}};
ABC []ar=new ABC[d.length];
int i,k=0;
for(i=0; i<ar.length; i++)
ar[i]=new ABC(d[i][0],d[i][1]);
for(i=1; i<ar.length; i++)
if(ar[i].compareTo(ar[k])>0) k=i;
System.out.println("k="+k);
}
}
9. class ABC {
String name;
double price;
public ABC(String na, double pr) {name=na; price=pr;}
public int compareTo(ABC x) {
if(price>x.price) return 1;
if(price<x.price) return -1;
else return 0;
}
}
public class XXK5 {
public static void main(String[] args) {
String []s={"apple", "pear", "tangerme", "banana", "grape"};
double []d={3.8, 2.5, 3.2, 4.3, 5.2};
ABC []ar=new ABC[s.length];
int i,k=0;
for(i=0; i<ar.length; i++)
ar[i]=new ABC(s[i],d[i]);
for(i=1; i<ar.length; i++)
if(ar[i].compareTo(ar[k])>0) k=i;
System.out.println(ar[k].name+" "+ar[k].price);
}
}
10. class ABC {
String name;
double price;
public ABC(String na, double pr) {name=na; price=pr;}
public int compareTo(ABC x) {
if(name.compareTo(x.name)>0) return 1;
if(name.compareTo(x.name)<0) return -1;
else return 0;
}
}
public class XXK5 {
public static void main(String[] args) {
String []s={"apple", "pear", "tangerme", "banana", "grape"};
double []d={3.8, 2.5, 3.2, 4.3, 5.2};
ABC []ar=new ABC[s.length];
int i,k=0;
for(i=0; i<ar.length; i++)
ar[i]=new ABC(s[i],d[i]);
for(i=1; i<ar.length; i++)
if(ar[i].compareTo(ar[k])>0) k=i;
System.out.println(ar[k].name+" "+ar[k].price);
}
}
11. class ABC {
private int []a;
public ABC(int []aa) {a=aa;}
public int maxValue() {
int max=a[0];
for(int i=1; i<a.length; i++)
if(a[i]>max) max=a[i];
return max;
}
}
public class XXK5 {
public static void main(String[] args) {
int []a={5,9,13,25,16,38,26,30};
ABC x=new ABC(a);
int max=x.maxValue();
System.out.println("max: "+max);
}
}
12. class ABC {
private int []a;
public ABC(int []aa) {a=aa;}
public int minValue() {
int min=a[0];
for(int i=1; i<a.length; i++)
if(a[i]<min) min=a[i];
return min;
}
}
public class XXK5 {
public static void main(String[] args) {
int []a={20,29,18,25,16,38,24,30};
ABC x=new ABC(a);
int min=x.minValue();
System.out.println("min: "+min);
}
}
第6章 异常处理
一、选择题
1．下列哪个类不是异常类的父类？（ ）。
A. Error B. Throwable C. Exception D. Object
2．下面的异常（ ）不属于非检查型异常。
A. 数组越界 B. 除零 C. 空值操作 D. IO异常
3．下面的关键字（ ）与异常处理无关。
A. throw B. void C. throws D. try
4．下面的关键字（ ）与异常处理无关。
A. throw B. throws C. import D. finally
5．下面的关键字（ ）与异常处理无关。
A. switch B. catch C. try D. finally
6．在Java语言中，捕获和处理异常的语句块为（ ）。
A. try…catch B. switch…case C. if…else D. do…while
7．下面的异常（ ）为数组下标越界异常。
A. ArithmeticException B. NullPointerException
C. ArrayIndexOutOfBoundsException D. FileNotFoundException
8．下面的异常（ ）为输入输出访问异常。
A. NullPointerException B. FileNotFoundException
C. ArrayIndexOutOfBoundsException D. IOException
9．下面的异常（ ）为文件没有找到异常。
A. NullPointerException B. FileNotFoundException
C. ArrayIndexOutOfBoundsException D. IOException
二、填空题
1．通常程序中的错误可以分为三种类型，即编译错误，运行错误和________错误。
2．在Java语言中，Exception下的异常分为两类：即检查型异常和________型异常。
3．在Java语言中，________型异常继承自RuntimeException类的异常。
4．在Java语言中，把生成异常对象并提交的过程称为________一个异常。
5．在Java语言中，从生成异常的方法开始进行回溯，直到找到包含相应异常处理的方法为止，我们把这一过程称为________一个异常。
6．在Java语言中，程序运行时发生的运行错误又分为致命性的严重错误和非致命性的一般错误两种，异常属于________错误。
7．Exception类是所有________类的父类，用户自定义的所有异常类都必须是________类的子类。
8．在一个方法的定义中，若不想在方法体内捕获和处理异常，把出现的异常抛给调用该方法的程序，则必须在方法头的末尾使用________子句抛出异常。
第7章 文件操作
一、选择题
1．下面（ ）既可以作为流的数据源，又可以作为流的目的地。
A. 键盘 B. 磁盘文件 C. 显示器 D. 扫描仪
2．进行文件输入输出操作时，最常用的系统包是（ ）。
A. java.io B. java.lang C. java.util D. java.awt
3．Java中有3个标准输入/输出流，下面的（ ）不包含在内。
A. System.in B. System.out C. System.err D. System.cur
4．在读字符文件 Employee.dat 时，使用该文件作为参数的类是（ ）。
A. BufferedReader B. DataInputStream
C. DataOutputStream D. FileInputStream
5．下列不是 InputStream 子类的是（ ）。
A. FileInputStream B. ObjectInputStream
C、 FileOutputStream D. ZipInputStream
二、填空题
1．读出器类(Reader)和写入器类(Writer)是java.io包中所有________流的抽象基类。
2．输入流类(InputStream)和输出流类(OutputStream)是java.io包中所有________流的抽象基类。
3．Java语言中的标准输入流为__________。
4．Java语言中的标准输出流为__________。
三、判断题
1．在Java中将信息的输入与输出过程抽象为输入/输出流。输入是指数据流入程序，输出是指数据从程序流出。
2．向文本文件中写入字符数据，在任何时候都只需要用到文件写入器类(FileWriter)，不需要用到缓冲写入器类(BufferedWriter)。
3．FileWriter和FileWriter类的构造函数的参数都需要一个文本文件名。
4．FileWriter和FileWriter类的构造函数的参数不需要一个文本文件名。
5．在对文件进行的输入/输出(I/O)方法的调用中，当遇到错误时通常会抛出一个IOException异常。
6．在对文件进行的输入/输出(I/O)方法的调用中，当遇到错误时通常会抛出除IOException异常之外的其他异常。
7．当一个方法进行文件访问操作可能生成一个IOException异常时，该方法必须在方法头声明抛出该异常，别无其他选择。
8．当一个方法进行文件访问操作可能生成一个IOException异常时，该方法可以在方法头声明抛出该异常，也可以采用try…catch块捕获并处理该异常。
9．输入流类(InputStream)和输出流类(OutputStream)是用来处理字节流的抽象基类。
10．输入流类(InputStream)和输出流类(OutputStream)是用来处理字符流的抽象基类。
11．Java.io包中的OutputStream及其子类专门用于把字节数据写入二进制数据文件中。
12．Java.io包中的InputStream及其子类专门用于从二进制数据文件中读出数据。
13．文件输出流类(FileOutputStream)和数据输出流类(DataOutputStream)不是OutputStream类的子类。
14．文件输入流类(FileInputStream)和数据输入流类(DataInputStream)不是InputStream类的子类。
15．DataOutputStream类的文件流能够把各种基本类型的数据写入到二进制数据文件中。
16．DataInputStream类的文件流只能够从二进制文件中读出一种基本类型的数据。
17．java.io包中提供的ObjectOutputStream类能够把对象信息存储到文件中。
18．java.io包中提供的ObjectInputStream类能够从文件中读取对象类型的信息。
19．在Java语言中，只能对文件存取字符或字节信息，不能存储对象信息。
20．在Java语言中，只能向文件存储对象类型的信息，不能够从中读取对象类型的信息。
第8章 Java应用示例
一、填空题
1．javax.swing包里的Swing组件归为三个层次：顶层容器、中间层容器和________。
2．javax.swing包里的Swing组件归为三个层次：顶层容器、________容器和原子组件。
3．Swing提供的三个顶层容器的类，分别是JFrame、JDialog和________。
4．Swing提供的三个顶层容器的类，分别是________、JDialog和JApplet。
5．Swing提供的三个顶层容器的类，分别是JFrame、________和JApplet。
6．对于原子组件，根据功能的不同，可以被分为________类。
7．原子组件被分为三类，其中一类为显示不可________信息的组件。
8．原子组件被分为三类，其中一类为具有控制功能，可以用来接收________输入信息的组件。
9．Java Applet是一种嵌入________文档中的Java程序。
10．每个线程具有四种基本状态：就绪状态、运行状态、死亡状态和________。
11．每个线程具有四种基本状态：就绪状态、运行状态、________和阻塞状态。
12．每个线程具有四种基本状态：就绪状态、________、死亡状态和阻塞状态。
13．每个线程具有四种基本状态：________、运行状态、死亡状态和阻塞状态。
14．进行网络应用的程序设计需要使用________包中提供的各种类。
15．进行数据库应用的程序设计需要使用________包中提供的各种类。
二、判断题
1．原子组件通常是在图形用户界面中和用户进行交互的组件。
2．原子组件在图形用户界面中是不能同用户进行交互的组件。
3．Applet程序是由Java源代码构成的，并被编译为class文件。
4．Applet程序是由Java源代码构成的，不会被编译成class文件。
5．当浏览器装入一个含有Applet的Web页时，Applet便被下载到该浏览器中。
6．当浏览器装入一个含有Applet的Web页时，Applet不会被下载到该浏览器中。
7．在Java程序中，只能创建单个线程，不能创建多个线程。
8．在Java程序中，既允许创建单个线程，也允许创建多个线程。
9．在Java程序中，用户创建的线程类必须继承java.lang.Thread类或者实现java.lang.Runnable接口。
10．在Java程序中，用户创建的线程类不能继承java.lang.Thread类。
11．在Java程序中，用户创建的线程类不能实现java.lang.Runnable接口。
12．JDBC隔离了Java与不同数据库之间的对话，使得 Java程序无须考虑不同数据库管理系统平台之间的差异。
13．JDBC隔离了Java与不同数据库之间的对话，使得 Java程序仍须考虑不同数据库管理系统平台之间的差异。
扫一扫
1150
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
