Java期末复习练习题2014版

Java期末复习练习题

一、 单选题

1. 事件监听接口中的方法的返回值是？ (c)

A. int B. String C. void D. Object E. AWTEvent

2. 设 x = 1 , y = 2 , z = 3，则表达式 y+=z--/++x-x 的值是？ (b)

A. 0 B. 1 C. 2 D. 3

3. 在类MyClass中定义了方法getResult()，其中包含语句：double myresult=Math.sqrt(1000)； 为了使此程序可用，需要导入什么包？ (b)

A. java.lang.* B. java.Math.* C. java.util.Math.*; D. 以上皆非

4. 在java中，哪一个关键字使类不能派生出子类。 (a)

A. final B. public C. private D. volatile

5. 在Java中，要处理Button类对象的事件，以下各项中，哪个是可以处理这个事件的接口。(选择一项) (d)

A. FocusListener B. ComponentListener C. WindowListener D. ActionListener

6. 编译，运行下列Java代码后的结果是（d）。

public class Test{

public static void main(String args []){

int age;

age=age+1;

System.out.println(“The age is”+age);

} }

A. 编译，运行后没有输出 B. 编译，运行后输出：The age is 1

C. 能通过编译，但运行时产生错误 D. 不能通过编译

7. 在Java语言中，类Worker是类Person的子类，Worker的构造方法中有一句“super(c)”，

该语句（）。

A. 调用类Worker中定义的super()方法 B. 调用类Person中定义的super()方法

C. 调用类Person的构造方法 D. 语法错误

8. 下列整型的最终属性 i 的定义中，正确的是。 (c)

A. final i; B. static int i; C. static final int i=234; D. final float i=3.14f;

9. 算术表达式1+2/3-4*5的值为。 (b)

A. 1 B. -19 C. -5 D. 0

10. 哪个关键字可以抛出异常？ (c )

A transient B finally C throw D static

11. 哪个关键字可以对对象加互斥锁？ (b)

A transient B synchronized C serialize D static

12. 下列哪些语句关于内存回收的说明是正确的? (b)

A 程序员必须创建一个线程来释放内存； B 内存回收程序负责释放无用内存

C 内存回收程序允许程序员直接释放内存 D 内存回收程序可以在指定的时间释放内存对象

13. 欲构造List类的一个实例，此类继承了List接口，下列哪个方法是正确的 ？ (b)

A List myList=new Object（）； B List myList=new List（）；

C List myList=new List（）； D List myList=new List（）；

14. paint()方法使用哪种类型的参数? (a)

A Graphics B Graphics2D C String D Color

15. 指出正确的表达式 (c)

A byte=128; B Boolean=null; C long l=0xfffL; D double=0.9239d;

16. 要从文件" file.dat"文件中读出第10个字节到变量C中,下列哪个方法适合? (a)

A FileInputStream in=new FileInputStream("file.dat"); in.skip(9); int c=in.read();

B FileInputStream in=new FileInputStream("file.dat"); in.skip(10); int c=in.read();

C FileInputStream in=new FileInputStream("file.dat"); int c=in.read();

D RandomAccessFile in=new RandomAccessFile("file.dat"); in.skip(9); int c=in.readByte();

16. 容器被重新设置大小后，哪种布局管理器的容器中的组件大小不随容器大小的变化而改变？ (b)

A CardLayout B FlowLayout C BorderLayout D GridLayout

17. 下列那种java组件为容器组件 (c)

A. List列表框 B. Choice下拉式列表框 C. Panel面板 D. MenuItem 命令式菜单项

18. 如下那种Java的控件将不会引发动作事件（ActionEvent）? (c)

A. Button B. MenuItem C. Panel D. CheckboxMenuItem

19. 编译java Applet源程序文件将产生相应的结果文件，这些结果文件的扩展名是什么？(b)

A. .java B. .class C. .html D. .exe

20. 将一个十六进制数赋值给一个long类型的变量，正确的表达式是： (d)

A. long number = 345L; B. long number = 0345;

C. long number = 0345L; D. long number = 0x345L.

21. JPanel组件的默认布局管理器是哪一项？ (d)

A. GridLayout B. CardLayout C. BorderLayout D. FlowLayour

22. 下列哪一项不属于面向对象程序设计的基本要素？ (d)

A. 类 B. 对象 C. 方法 D. 安全

23. 下面程序的输出结果是。 (a)

public class ex2 {

public static void main(String[] args)

{

for(int cnt=0;cnt<10;cnt++)

{

if(cnt==5)

break;

System.out.print(cnt);

}

}

}

A. 0 1 2 3 4 B. 6 7 8 9 C. 0 1 2 3 4 6 7 8 9 D. 5

24.指出正确的表达式（ C）

A、 byte=128;

B、 Boolean=null;

C、 long l=0xfffL;

D、 double=0.9239d;

25.MAx_LENGTH是int型public成员变量, 变量值保持为常量100，用简短语句定义这个变量。 （D）

A、 public int MAx_LENGTH=100;

B、 final int MAx_LENGTH=100;

C、 final public MAx_LENGTH=100;

D、public final int MAx_LENGTH=100；

26.哪个关键字可以抛出异常？ （C）

A、 transient

B、 finally

C、 throw

D、 static

27.main()方法的返回类型是： （B）

A、 int

B、 void

C、 boolean

D、 static

28.System类在哪个包中? （D）

A、 java.util

B、 java.io

C、 java.awt

D、 java.lang

29.下面关于Applet的说法正确的是 （B）

A、 Applet也需要main方法

B、 Applet必须继承自java.awt.Applet

C、 Applet能访问本地文件

D、 Applet程序不需要编译

30.下面哪个单词是Java语言的关键字（B）

A、Float B、this C、string D、unsigned

31.下面哪个修饰符修饰的方法只能被本类中的其他方法使用（C）

A、protected B、static C、private D、public

32.下面哪个是对字符串String的正确定义 （A）

A、String s1=null;B、String s2=’null’ ;

C、String s3=(String)’abc’ ;D、String s4=(String)’\uface’

33.编译java程序时出现error: cannot read: aaa.java，则下列原因最正确的是（A）

A、原因是执行的当前目录下没有找到aaa.java文件。

B、原因是没有安装JDK开发环境。

C、原因是java源文件名后缀一定是以 .txt 结尾。

D、原因是JDK安装后没有正确设置环境变量PATH和Classpath 。

34.下面哪项可以得到数组元素的个数，java中定义数组名为 abc，（B）

A、abc.length( ) B、abc.length C、len(abc) D、ubound(abc)

35.下面哪个修饰符修饰的变量是所有同一个类生成的对象共享的（C）

A、public B、private C、static D、final

36.下面关于java中类的说法哪个是不正确的（C）

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

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

C、类一定要声明为public的，才可以执行。

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

37.关于构造函数的说法不正确的是（B

A、构造函数也属于类的方法，用于创建对象的时候给成员变量赋值。

B、构造函数不可以重载。

C、构造函数没有返回值。

D、构造函数一定要和类名相同。

38.数组中可以包含什么类型的元素？（D）

A、int型 B、 string型 C、 数组 D、 以上都可以

39.方法重载是指 (A)
A、两个或两个以上的方法取相同的方法名，但形参的个数或类型不同

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

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

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

40.下面哪个语句是正确的(A)

A、Object o=new Button(″A″); B、Button b=new Object(″B″);
C、Panel p=new Frame(); D、Frame f=new Panel();

41.Frame的默认的布局管理器是下列哪一个(B)

A、FlowLayout B、BorderLayout C、GridLayout D、CardLayout

42、对象使用时，下面描述错误的是(B)

A、通过“.”运算符调用成员变量和方法 。

B、通过成员变量的访问权限设定限制自身对这些变量方法的调用 。

C、将一个对象申明为类的成员时，必须在使用前为其分配内存。

D、在方法中使用对象作为参数时，采用引用调用。

43．编译JavaApplet 源程序文件产生的字节码文件的扩展名为(B)

A、java B、class C、html D、exe

44．main方法是JavaApplication程序执行的入口点，关于main方法的方法头以下哪项是合法的（B）？

A、public static void main（ ）

B、public static void main（String args[] ）

C、public static int main（String[] arg ）

D、public void main（String arg[] ）

45．为AB类的一个无参数无返回值的方法method书写方法头，使得使用类名AB作为前缀就可以调用它，该方法头的形式为(A)

A、static void method( ) B、public void method( )

C、final void method( ) D、abstract void method( )

46．下列哪个是合法的Java标识符？（C）

A、Tree&Glasses B、class

C、_$theLastOne D、273.5

47．Java的字符类型采用的是Unicode编码方案，每个Unicode码占用（B）个比特位

A、8 B、16 C、32 D、64

48．下面哪一种是基本类型标识符(A)

A、byte B、String C、array D、interface

49．在编写JavaApplication程序时，若需要使用到标准输入输出语句，必须在程序的开头写上(C)语句

A、import java.awt.* ; B、importjava.applet.Applet ;

C、importjava.io.* ;D、importjava.awt.Graphics ;

50．对于构造函数，下列叙述不正确的是（B）

A、构造函数是类的一种特殊函数，它的方法名必须与类名相同。

B、构造函数的返回类型只能是void型。

C、构造函数的主要作用是完成对类的对象的初始化工作。

D、一般在创建新对象时，系统会自动调用构造函数。

51．设有下面两个类的定义：

class Person {……}

class Student extends Person {

longid;// 身份证号

intscore;// 入学总分

Stringname;// 姓名

……}

问：类Person和类Student的关系是（B）

A、包含关系 B、继承关系 C、关联关系D、无关系，上述类定义有语法错误

52． 执行下面的程序结果是(A).

class AA {

void Show(){ System.out.println("我喜欢Java!"); }}

class BB extends AA {

void Show(){ System.out.println("我喜欢C++!");}}

public class Testa{

public static void main(String[] args)

{

AA a=new AA();

BB b=new BB();

a.Show();

b.Show();

}}

A、我喜欢Java! 我喜欢C++! B、我喜欢C++! 我喜欢Java!

C、我喜欢Java! 我喜欢Java! D、我喜欢C++!我喜欢C++!

53．在Java中，一个类可同时定义许多同名的方法，这些方法的形式参数的个数、类型或顺序各不相同，传回的值也可以不相同。这种面向对象程序特性称为（C）

A、隐藏B、覆盖C、重载 D、Java不支持此特性

54．在JavaApplet程序用户自定义的Applet子类中，常常重载(D)方法在Applet的界面中显示文字、图形和其它界面元素

A、start( ) B、stop( ) C、init( ) D、paint( )

55．在Java中，存放字符串常量的对象属于（B）类对象

A、Character B、String C、StringBuffer D、Vector

56．在Java图形用户界面编程中，若显示一些不需要修改的文本信息，一般是使用（A）类的对象来实现

A、Label B、Button C、TextAreaD、TextField

57．在编写JavaApplet程序时，若需要对发生的事件作出响应和处理，一般需要在程序的开头写上(D)语句

A、import java.awt.* ;B、importjava.applet.* ;

C、import java.io.* ; D、importjava.awt.event.* ;

58列类定义中，不正确的是(C)。

A) class x { .... }

B) class x extends y { .... }

C) static class x implements y1,y2 { .... }

D) public class x extends Applet { .... }

59．下列方法定义中，正确的是(A)。

A) int x( ){ char ch='a'; return (int)ch; }

B) void x( ){ ...return true; }

C) int x( ){ ...return true; }

D) int x( int a, b){ return a+b; }

60．用于定义类成员的访问控制权的一组关键字是(D)。

A) class, float, double, public

B) float, boolean, int, long

C) char, extends, float, double

D) public, private, protected

61．现有两个类A、B，以下描述中表示B继承自A的是(D)。

A) class A extends B B) class B implements A

C) class A implements B D) class B extends A

62．下列的变量定义中，错误的是( D)。

A) int i; B) int i=Integer.MAx_VALUE; C) int i=100; D) int 123_$;

63．既能作为类的修饰符, 也能作为类成员的修饰符的是(A)。

A) public B) extends C) Float D) static

64．若一个类中对某个方法进行了重载，能够区分这些重载方法的手段是 ( C)。

A)它们的返回值类型的不同 B)它们的名称的不同

C) 它们的参数表的不同 D) 它们的修饰符不同

65．以public修饰的类如：public class fish{…}则fish(A)

A)可被其它程序包中的类使用 B)仅能被本程序包中的类使用

C)不能被任意其它类使用 D)不能被其它类继承

66．布尔型变量假值表示为（B）

A) true B) false C)1 D) 0

67．在Java中，关于final关键字的说法正确的是（C）。

A)如果修饰变量，则表明变量可赋值2次。

B)如果修饰类，则该类只能被一个子类继承

C)如果修饰方法，则该方法不能在子类中被覆盖

D)如果修饰方法，则该方法所在的类不能被继承

68．在Java中,下列选项表示字符”a”值的是(A)。

A)'a' B)"a" C) new Character(a) D)\000a

69．在 JAVA编程中，Java编译器会将Java程序转换为（A）。

A)字节码 B)可执行代码 C)机器代码 D)以上所有选项都不正确

70．在Java中，下面关于包的陈述中正确的是（A）。

A) 包的声明必须是源文件的第一句代码

B) 包的声明必须紧跟在import语句的后面

C) 只有公共类才能放在包中

D) 不可以将多个源文件中的类放在同一个包中

71．在Java中，要想使只有定义该类所在的包内的类可以访问该类，应该用（A）关键字。

A)不需要任何关键字 B)private C)final D)protected

72．包pack1的类class1中有成员方法：

protected void method_1(){…}，private void method_2(){…},

public void method_3(){…}和void method_4(){…},

在包pack2中的类class2中可以调用方法（C）。

A)method_1 B)method_2 C)method_3 D)method_4

73．JAVA中，为了辨别用户关闭窗口的事件，要实现监听器接口（C）。

A) MouseListener B)ActionListener C)WindowListener D)以上都要

74．在Java事件处理模型中，当按下鼠标按钮时，处理（D）事件。

A)mouseReleased B)mouseExited C)mousePressed D)mouseDown

18．在Java语言中，Panel默认的布局管理器是（B）。

A)BorderLayout B)FlowLayout C)GridLayout D)GridBagLayout

75．String s1=new String(“Hello”);

String s2=new String(“there”);

String s3=new String("0");

上面是JAVA程序的一些声明，以下选项中能够通过编译的是（A）。

A) s3=s1+s2 B) s3=s1&s2 C) s3=s1||s2 D) s3=s1&&s2

76．在java中，下列赋值语句正确的是（A）。

A)char c='a'; B)char c="a"; C)char c=new String(“a”); D)char c=new Character('a');

77．有一段java 应用程序,它的主类名是a1，那么保存它的源文件名可以是（A）

Ａ)a1.java B)a1.class C) a1 D)都对

78．下面说法正确的是（C）

A)java Applet程序必须在浏览器中执行 B)java 应用程序必须在浏览器里执行

C)java Applet程序不一定在浏览器中执行 D)java应用程序可以在浏览器中执行

79．整型数据类型中，需要内存空间最少的是（B）

A)short B) long C) int D) byte

80．在浏览器中执行applet 程序的四个方法的最先执行的是（A）

A) init() B)start() C)destroy() D) stop()

81．JAVA 中（C）

A) 一个子类可以有多个父类，一个父类也可以有多个子类

B)　一个子类可以有多个父类，但一个父类只可以有一个子类

C)　一个子类可以有一个父类，但一个父类可以有多个子类

D)　上述说法都不对

82．JavaApplication源程序的主类是指包含有（A）方法的类。

A、main方法B、toString方法 C、init方法D、actionPerfromed方法

83．在编写JavaApplication程序时，若需要使用到标准输入输出语句，必须在程序的开头写上(C)语句。

A、importjava.awt.* ;B、importjava.applet.Applet ;

C、importjava.io.* ;D、importjava.awt.Graphics ;

84．若a的值为3时，下列程序段被执行后，c的值是多少？（C）

c = 1;

if( a>0 )

if( a>3 )c = 2;

else c = 3;

else c = 4;

A、1 B、2 C、3 D、4

85、回车换行是下面哪一种转义字符？(A)

A. ‘\n’B. ‘\r’ C. ‘\b’D. ‘\t’

86．下面的是关于类及其修饰符的一些描述，不正确的是：（B）

A、abstract类只能用来派生子类，不能用来创建abstract类的对象。

B、final类不但可以用来派生子类，也可以用来创建final类的对象。

C、abstract不能与final同时修饰一个类。

D、abstract方法必须在abstract类中声明，但abstract类定义中可以没有abstract方法。

87．若需要定义一个类域或类方法，应使用哪种修饰符？（A）

A、static B、package C、private D、public

88．若在某一个类定义中定义有如下的方法： abstract void performDial( );该方法属于（D）。

A、本地方法B、最终方法C、静态方法D、抽象方法

89．下面哪一个语句表示结束本次循环（不是结束整个当前循环），执行

下一次循环（B）

A、 break语句 B、 continue语句 C、 return语句 D以上都不是

90．对于构造函数，下列叙述不正确的是（C）

A、构造函数也允许重载。

B、子类无条件地继承父类的无参构造函数。

C、子类不允许调用父类的构造函数。

D、在同一个类中定义的重载构造函数可以相互调用。

91．在使用interface声明一个接口时，只可以使用（D）修饰符修饰该接口

A、private B、protected

C、privateprotected D、public

92．在Java中，开发图形用户界面的程序需要使用一个系统提供的事件类库，这个类库就是（D）包。

A、java.io B、java.awt C、java.applet D、java.awt.event

93．在Java图形用户界面编程中，若显示一些不需要修改的文本信息，一般是使用（A）类的对象来实现。

A、Label B、Button C、TextArea D、TextField

94．创建一个标识有"关闭"按钮的语句是(D)

A、TextFiel db = new TextField("关闭");B、Labelb = newLabel("关闭");

C、Checkboxb = newCheckbox("关闭");D、Button b = new Button("关闭");

95．在编写异常处理的Java程序中，每个catch语句块都应该与(C)语句块对应，使得用该语句块来启动Java的异常处理机制。

A、if – else B、switch C、try D、throw

96．Java语言的类间的继承关系是( B)。

A) 多重的 B) 单重的 C) 线程的 D) 不能继承

97．下列选项中，用于在定义子类时声明父类名的关键字是(C )。

A）interface B) package C) extends D) class

98．下列语句序列执行后，k 的值是(C)。

int i=10, j=18, k=30;

switch( j - i )

{ case 8 : k++;

case 9 : k+=2;

case 10: k+=3;

default : k/=j;

}

A) 31 B) 32 C) 2 D) 33

99．能修饰类的修饰符是( C)。

A) private B) static C) abstract D) protected

5．下列最终属性 i 的定义中，正确的是(A )。

A) static final int i=100; B) final int i=1.2;

C) final i='w'; D) final char i;

100．设 x为已定义的类名，下列声明x类的对象x1的语句中正确的是(A)。

A) static x x1; B) public x x1=new x(int 123);

C) abstract x x1;D) x x1=x( );

101．设有定义 int i=123; long j=456L; 下面赋值不正确的语句是(D)。

A) j=i; B) j=(long)i; C) i=(int)j; D) i=j;

102．定义 Java Applet程序时，必须有的 import语句是(A )。

A) import java.applet.Applet; B) import java.io.*;

C) import java.awt.event; D) import java.lang.*;

103．下列方法定义中，不正确的是(D )。

A) public int x( ){ ... } B) public static int x( double y ){ ... }

C) void x( double d ) { ... } D) public static x( double a ){ ... }

104．在一个应用程序中有如下定义：int a[]={1,2,3,4,5,6,7,8,9,10};,为了打印输出数组a的最后一个元素，下面正确的代码是(B )。

A) System.out.println(a[10]);B) System.out.println(a[9]);

C) System.out.println(a[a.length]);D) System.out.println(a(8));

105．下面说法正确的是( A)。

A) final 可修饰类、属性、方法。B) abstract可修饰类、属性、方法。

C) 定义抽象方法需有方法的返回类型、名称、参数列表和方法体。

D) 用final修饰的变量，在程序中可对这个变量的值进行更改。

106．一个可以独立运行的Java应用程序(D)。

A)可以有一个或多个main方法 B)最多只能有两个main方法

C)可以有一个或零个main方法 D)只能有一个main方法

107．在Java中，下面关于构造函数的描述正确的是（D）。

A)类必须有显式构造函数 B)它的返回类型是void

C)它和类有相同的名称，但它不能带任何参数

D)以上皆非

108．在类的说明符中，被指定为私有的数据可以被以下（C）访问。

A)程序中的任何函数 B)其他类的成员函数

C)类中的成员函数 D)派生类中的成员函数

109．在JAVA编程中，以下（B）命令用来执行java类文件。

A)javac B)java C)appletviewer D)以上所有选项都不正确

110．下列标识符中，非法的标识符有（B）
A . Var_x　B . 4date　C.$_Money　D.class1

111．为AB类的一个无形式参数无返回值的方法method书写方法头，使得使用类名AB作为前缀就可以调用它，该方法头的形式为(A)

A、static void method( ) B、public void method( )

C、final void method( ) D、abstract void method( )

112．下列哪个是合法的Java标识符？（C）

A、Tree&Glasses B、class C、_$theLastOne D、273.5

113、以下标识符中哪项是不合法的( C )

A、BigMeaninglessName B、$int      C、1 s     D、$1

114．JavaApplication源程序的主类是指包含有（A）方法的类。

A、main方法B、toString方法

C、init方法D、actionPerfromed方法

115．对于构造函数，下列叙述不正确的是（B）。

A、构造函数是类的一种特殊函数，它的方法名必须与类名相同。

B、构造函数的返回类型只能是void型。

C、构造函数的主要作用是完成对类的对象的初始化工作。

D、一般在创建新对象时，系统会自动调用构造函数。

116．若在某一个类定义中定义有如下的方法： abstract void performDial(D );该方法属于（）。

A、本地方法B、最终方法C、静态方法D、抽象方法

117．不使用static修饰符限定的方法称为对象（或实例）方法，下列哪一个说法是正确的（B）

A、实例方法可以直接调用父类的实例方法。

B、实例方法可以直接调用父类的类方法。

C、实例方法可以直接调用其他类的实例方法。

D、实例方法不可以直接调用本类的类方法。

118、执行完以下代码int[ ] x = new int[25]；后，以下哪项说明是正确的（ A）
A、x[24]为0 B、x[24]未定义　　C、x[25]为0 D、x[0]为空

119、以下代码段执行后的输出结果为（B）
int  x=3； int  y=10；
System.out.println(y%x);
A、0 B、1 C、2 D、3

120、关于被私有访问控制符private修饰的成员变量，以下说法正确的是（ C）
A．可以被三种类所引用：该类自身、与它在同一个包中的其他类、在其他包中的该类的子类
B．可以被两种类访问和引用：该类本身、该类的所有子类
C．只能被该类自身所访问和修改
D．只能被同一个包中的类访问

121、容器Panel缺省使用的布局编辑策略是（B ）
A、BorderLayout B、FlowLayout C、GridLayout D、CardLayout

122、以下哪个表达式是不合法的（D）
A、String   x="Hello";   int  y=9;   x+=y;
B、String  x="Hello";   int  y=9;  if(x= =y)  { }
C、String   x="Hello";  int  y=9;  x=x+y;
D、String   x=null;  int  y=(x!=null)&&(x.length()>0) ? x.length : 0

123．在编写JavaApplet程序时，若需要对发生的事件作出响应和处理，一般需要在程序的开头写上(D)语句。

A、importjava.awt.* ;B、importjava.applet.* ;

C、importjava.io.* ;D、importjava.awt.event.* ;

124．对于子类的构造函数说明，下列叙述中不正确的是（D）。

A、子类无条件地继承父类的无参构造函数。

B、子类可以在自己的构造函数中使用super关键字来调用父类的含参数构造函数，但这个调用语句必须是子类构造函数的第一个可执行语句。

C、在创建子类的对象时，将先执行继承自父类的无参构造函数，然后再执行自己的构造函数。

D、子类不但可以继承父类的无参构造函数，也可以继承父类的有参构造函数。

125.Java语言具有许多优点和特点，下列选项中，哪个反映了Java程序并行机制的特点(B).

A)安全性　　B)多线性　　C)跨平台　　D)可移植
126.下列哪个类声明是正确的(D)

A)abstract final class HI{···｝ B)abstract private move(){···} C)protected private number; D) public abstract class Car{···}

异常包含下列那些内容( C )

A)程序中的语法错误　　B)程序的编译错误　　 C)程序执行过程中遇到的事先没有预料到的情况　　D)程序事先定义好的可能出现的意外情况
127.Character流与Byte流的区别是( C).

A)每次读入的字节数不同　　B)前者带有缓冲，后者没有　　
C)前者是块读写，后者是字节读写　　D)二者没有区别，可以互换使用
128.监听事件和处理事件(B)
A)都由Listener完成　　B)都由相应事件Listener处登记过的构件完成　　
C)由Listener和构件分别完成　　D)由Listener和窗口分别完成
129.Applet可以做下列那些操作(A)
A)读取客户端文件　　B)在客户端主机上创建新文件　　
C)在客户端装载程序库　　D)读取客户端部分系统变量
130.下列哪个属于容器的构件(A)
A)JFrame B)JButton C)JPnel D)JApplet
131.如果希望所有的控件在界面上均匀排列，应使用下列那种布局管理器(B)
A)BoxLayout B)GridLayout C)BorderLayout D)FlowLouLayout
132.Java是从哪一种语言改进并重新设计的（B）.

A、Ada B、C++ C、Pascal D、Basic

133.下列语句哪一个正确(C).

A、Java只能用来写Applet，不能写Application。 B、Java不分大小写。C、Java程序中的起始类名称必须与存放该类的文件名相同。D、Java Applet由main( )方法开始运行。

134.下列哪一个是Java合法的标识符(B).

A、new B、$Usdollars C、1234 D、car.taxi

135.synchronized修饰符可以修饰__(C).

A、类B、变量 C、方法D、接口

136.Java语言中唯一自动引入程序中的类包是(A)。

A、lang B、util C、awt D、applet

137.用_(D)_修饰的域或方法只能被该类本身访问和调用，而不能被其他任何类，包括它的子类访问和调用。

A、public B、protected C、abstract D、private

138.static修饰符不能与___(A)__修饰符混合使用。

A、abstract B、final C、private D、public

139._(D)_是最灵活、同时也是最复杂的一种布局，它把容器中的每个组件按行列放置，但每个组件所占用的空间可以互不相同。

A、顺序布局 B、边界布局 C、网格布局D、网格包布局

140.Java提供了__(B)类用于制作对话框，当用户需要改变一些数据或需要一个提示窗口事就可以使用定义对话框。

A、Frame B、Dialog C、Windows D、Panel

141.Java提供了__(A)_类来决定要显示文字的字体、大小和位置，使输出的文字更丰富。

A、Graphics B、 Canvas C、Font D、Awt

142.Java中可以用两种方法来创建线程，一种是继承Thread类，另一种是实现___(B)_接口。

A、Throws B、 Runnable C、Component D、 Container

143.Java中线程的优先级共分为_(C)_级？

A、6 B、 8 C、10 D、 12

144.Java的网络类库支持多种Internet协议，但不包括__(A)__。

A、BT B、FTP C、Telnet D、HTTP

145._(A)是指把某些数据成员和方法用类包裹对外隐藏起来，以免被不正当的存取。

A、封装 B、包裹 C、隐藏 D、重载

146.Java不允许多重继承，而利用__(B)___的设计来达到多重继承的目的。

A、类 B、接口 C、对象 D、方法

147.下列软件中哪一项不是Java语言开发工具___（C）__。

A．Freejava         B．Eclipse       C．Office 2003      D．Java2 SDK

148.关于数据类型转换下面描述错误的是__（C）__。

A．byte类型数据可以转换为short、int、long类型数据

B．long类型数据有可能转换为byte、short、int类型数据

C．在语句int i = (int)78.67;中，变量i的值为79。

D．当两个数据的类型不同一时，必须先进行数据类型的转换，再运算或赋值

149.定义一个双精度型变量num的语句是___（B）__。

A．int num;     B．double num;     C．float num;     D．boolean num；

150.下列哪一个是合法的Java标识符__（C）___。

A．#123#     B．@yahoo.com     C．_date     D．10years

151.使用__（D）__修饰符修饰的方法和变量只可以被类本身访问和调用。

A．public            B．protected          C．friendly         D．private

152.定义String变量s的值为"How are you"，则s.substring( 1,9 )的返回值为__（A）_。

A．"ow are yo"     B．"ow are you"   C．"how are you"   D．"How are yo"

153．有下面的类定义：

public class Myclass{

public void setVar(int a, int b, float c ){}

}

下面哪些方法是对setVar（）方法的重载？（ ）

A 、public void setVar(int a,float c,int b){}

B 、protected void setVar(int x,inft y,float z){}

C 、public int setVar(int a,float c,int b){return a;}

D 、public int setVar(int a,float c){return a;}

答：A、C、D

154．选出能与aMethod()方法重载的方法。（）

public class Myclass{

public floataMethod(float a,float b){

}

//下面哪个方法的定义可以放在该位置

}

A 、public int aMethod(int a,int b){}

B 、public float aMethod(float x,float y){}

C 、public float aMethod(float a,float b,int c){}

D 、public float aMethod(int a,int b，int c){}

E 、public float aMethod(float a,float b){}

答：A、C、D

155．有下面的类定义：

public class Myclass{

public MyClass(int x,int y,int z){}

}

下面哪两个方法重载了构造方法MyClass()?（ ）

A 、MyClass(){}

B 、protected int MyClass(){}

C 、public void MyClass(byte x,byte y,byte z){}

D 、public Object MyClass(int x,int y,int z){}

答：A、C

156．关于实例变量、类变量、实例方法和类方法，下面叙述哪个是不正确的？（ ）

A 、实例方法可以访问实例变量和类变量

B 、类方法不能访问实例变量

C 、实例变量和类变量都可以通过类名访问

D 、类方法只能访问类变量

答：A、C

157．设有Circle类，执行下面语句后，哪个对象可以被垃圾回收器回收？（ ）

Circle a = new Circle();

Circle b = new Circle();

Circle c = new Circle();

A=b;

A=c;

C=null;

A 、原来a所指的对象 B 、原来b所指的对象

B 、原来b和c所指的对象 D 、原来c所指的对象

答：A

157. 下列程序运行结果为（A）

class Super{

//public Super(){

//}

public int i = 0;

public Super(String text){

i=1;

}

}

public class Sub extends Super{

public sub(String text){

i=2;

}

public static void main(String[] args){

Sub sub = new Sub("hello");

System.out.println(sub.i);

}

}

A.编译错误 B.编译成功，输出0

C.编译成功，输出1 D.编译成功，输出2

说明：答：子类的构造方法中没有调用超类的构造方法，故自动调用超类的默认构造方法，而超类中又没有定义默认的构造方法，找不到Super()，产生编译错误。

158．有下面类的定义，下面哪个方法放在划线处会发生编译错误？（B ）

Class Super{

Public float getNum(){

Return 3.0f;

}

}

Public Class Sub extends Super{

}

A.Public float getNum(){return 4.0f;}

B.Public float getNum(){}

C.Public float getNum(double d){}

D.Public double getNum(float d){return 4.0d;}

159．下面哪4种类型对象可以使用throws子句抛出？（A、D、E、F）

A. Error B. Event C. Object D. Exception

E. Throwable F. RuntimeException

160．Thread类的那个方法用来启动线程的运行？（B）

A.run() B.start() C. Begin() D. run(Runnable r) E. execute(Thread t)

160．对下列程序，下面哪个选项是正确的？（C）

import java.awt.*;

import java.swing.*;

public class Test extends JFrame{

public Test(){

add(new JLabel (“Hello”));

add(new JTextField (“Hello”));

add(new JButton (“Hello”));

pack();

setVisible(true);

}

public static void main(String[] args){

new Test();

}

}

A. 显示一个窗口，但没有标签、文本框或按钮

B. 显示一个窗口，上端是一个标签，标签下面是文本框，文本 框下面是按钮

C. 显示一个仅有一个按钮的窗口

D. 显示一个窗口，左面是标签，标签右面是文本框，文本框右 面是按钮

二、 程序解析题

1． 编译如下代码可能出现的结果是 （c）

public class Holt extends Thread{

private String sThreadName;

public static void main(String argv[]){

Holt h = new Holt();

h.go();

}

Holt(){}

Holt(String s){

sThreadName = s;

}

public String getThreadName(){

return sThreadName;

}

public void go(){

Holt first = new Holt("first");

first.start();

Holt second = new Holt("second");

second.start();

}

public void start(){

for(int i = 0; i < 2; i ++){

System.out.println(getThreadName() +i);

try{

Thread.sleep(100);

}catch(InterruptedException e){

System.out.println(e.getMessage());

} } } }

A 编译时出错 B 输出 first0, second0, first0, second1

C 输出 first0, first1, second0, second1 D 运行时出错

2． 完成程序中循环，实现把变量i赋值给数组ia[]的元素

public class Lin{

public static void main(String argv[]){

Lin l = new Lin();

l.amethod();

}

public void amethod(){

int ia[] = new int[4];

____ for(int i=0; i< ia.length;i++) ___

{

ia[i]=i;

System.out.println(ia[i]);

} } }

3．下面程序运行的结果是__10 __

public class Oct{

public static void main(String argv[]){

Oct o = new Oct();

o.amethod();

}

public void amethod(){

int oi= 012;

System.out.println(oi);

}

}

4．下列程序段运行结果是__10 ___

public class Example{

public static void main(String args[]){

Integer b= new Integer(10);

System.out.println(b.intValue());

}

5． 写出下列代码执行的结果是 i=-2 i=-1 i=1

public class Test1 {

public static void main(String[] args) {

for (int i=-2; i<2; i++) {

if (i==0) continue;

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

} } }

6． 给定如下代码，程序输出的结果是是（The_value_is_10 ）

public class Test {

void printValue(int m){

do { System.out.println("The_value_is_"+m);

}

while( --m > 10 )

}

public static void main(String arg[]) {

int i=10;

Test t= new Test();

t.printValue(i);

} }

7．写出下列程序的结果是Java Applet

public class Test{

public static void main(String args[]){

String s1="Henry Lee";

String s2="Java Applet";

String s3="Java";

String st="";

if(st.compareTo(s2)<0)

st=s2;

else

st=s1;

if(st.compareTo(s3)<0)

st=s3;

System.out.println("big="+st);

} }

8．写出下面程序运行的结果是（abs_class_length_size ）

import java.util.s;

public class Sort {

public static void main(String args[]) {

String[] str = {"size", "abs","length","class"};

s.sort(str);

for (int i=0; i

System.out.print(str[i]+"_");

} }

9． 定义A,B如下：

class A

{

int a=1;

double d=2.0;

void show( )

{

System.out.println("Class A:a="+a +" d="+d);

} }

class B extends A

{float a=3.0f;

String d="Java program.";

void show( )

{ super.show( );

System.out.println("Class B:a="+a +" d="+d);

} }

(1) 若在应用程序的main方法中有以下语句：

A a=new A();

a.show();

则输出的结果如何？

(2) 若在应用程序的main方法中定义类B的对象b：

A b=new B();

b.show();

则输出的结果如何？

(1)Class A:a=1 d=2.0 (2)Class A:a=1 d=2.0 Class B:a=3.0 d=Java program.

10．以下程序段的输出结果为Value is two.Value is three 。

int j=2;

switch ( j ) {

case 2:

System.out.print(“Value is two.”);

case 2+1 :

System.out.println(“Value is three.”);

break;

default:

System.out.println(“value is “+j);

break;

}

11．阅读以下程序段:

class Parent

{

void printMe()

{

System.out.println(“parent”);

}

}

class Child extends Parent

{ void printMe()

{System.out.println(“child”); }

void printAll()

{ super.printMe();

this.printMe();

printMe(); } }

public class Test_this

{ public static void main(String args[ ])

{Child myC=new Child();

myC.printAll(); } }

输出结果为: parent child child

12．public class AppTest{

public static void main(String args[]){

int i=10,j=5;

System.out.println(i+“\t”+j);

boolean test=false;

i=test?i:j;

System.out.println(i+“\t”+j);

}}

输出结果：

10 5

5 5

13．public class WhileTest{

public static void main(String args[]){

int i=10;

while(i>0){

System.out.print(i);

i--;}}}

输出结果：10987654321

14．

public class Lx{

public static void main(String args[]){

try{

System.out.println(“执行try”);

}

catch(Exception e){

System.out.println(“执行catch”);

}

finally{

System.out.println(“执行finally”);

}}}

输出结果：

执行try

执行finally

15．

class MainTest{

public static void main(String args[]){

if(args.length==0)

System.out.println(“没有参数”);

else{

System.out.println(“参数的个数:”+args.length);

for(int i=0;i

System.out.println(args[i]+ “ ”);

System.out.println(“\n”);

}}}

如果输入命令：java MainTest

则输出结果：没有参数

如果输入命令：java MainTest 1 2 3

则输出结果：参数的个数3

1

2

3

16．

class Value1{

int x,y;

Value1(int a, int b){

x=a+10;

y=b;

}}

class Value2 extends Value1{

Value2(int a, int b){

super(a,b);}}

public class AddTest{

public static void main(String args[]){

int t;

Value2 no=new Value2(10,20);

t=no.x+no.y;

System.out.println(“add=”+t);

}}

输出结果：Add=40

17．

public class AppTest{

public static void main(String args[]){

System.out.println(“Hello World!”+“\nI am a java newer!”);

System.out.println(“Hello World!\nI am a java newer!”);

}}

输出结果：

Hello World!

I am a java newer!

18．

public class ExceptionTest{

public static void main(String args[]){

int i=0;

String greetings[]={“你好!”, “你好!!”};

While(i<3){

try{

System.out.println(greetings[i]);}

catch(IndexOutOfBoundException e){

System.out.println(“产生异常”);}

finally{

System.out.println(“执行finally”);

}i++;}}}

输出结果：

你好!

执行finally

你好!!

执行finally

产生异常

执行finally

19．

class Value1{

int x,y;

Value1(int a, int b){

x=a;

y=b;}}

class Value2 extends Value1{

Value2(int a, int b){

super(a,b);}}

public class AddTest{

public static void main(String args[]){

int t;

Value2 no=new Value2(10,20);

t=no.x+no.y;

System.out.println(“add=”+t);}}

输出结果：add=30

20.

public class Fib{

pubic static void main(String args[]){

int i;

int arr[]=new int[10];

arr[0]=arr[1]=1;

for(i=2;i<10;i++)

arr[i]=arr[i-1]+arr[i-2];

for(i=1;i<10;i++)

System.out.println(“F[”+i+“]=”+arr[i-1];}}

运行结果为：1 1 2 3 5 8 13 21 34 55

21、

public class AppTest{

public static void main(String args[]){

System.out.println(“Hello World!”+“\nI am a java newer!”);

System.out.println(“Hello World!\nI am a java newer!”);

}}

输出结果：

Hello World!

I am a java newer!

Hello World!

I am a java newer!

22．

public class ForTest{

public static void main(String args[]){

int sum=0;

for(int i=10;i>0;i--)

sum+=i;

System.out.println(“The sum of 1 to 10 is:”+sum);

}

}

输出结果：

The sum of 1 to 10 is:55

23．

public class Lx{

public static void main(String args[]){

try{

System.out.println(“执行try”);

}

catch(Exception e){

System.out.println(“执行catch”);

}

finally{

System.out.println(“执行finally”);

}}}

输出结果：

执行try

执行finally

24．

class MainTest{

public static void main(String args[]){

if(args.length==0)

System.out.println(“没有参数”);

else{

System.out.println(“参数的个数:”+args.length);

for(int i=0;i

System.out.println(args[i]+ “ ”);

System.out.println(“\n”);}}}

如果输入命令：java MainTest

则输出结果：没有参数

如果输入命令：java MainTest 1 2 3

则输出结果：参数的个数：3

1 2 3

25．

class Value1{

int x,y;

Value1(int a, int b){

x=a;

y=b;}}

class Value2 extends Value1{

Value2(int a, int b){

super(a,b);}}

public class AddTest{

public static void main(String args[]){

int t;

Value2 no=new Value2(10,50);

t=no.x+no.y;

System.out.println(“add=”+t);}}

输出结果：

add=60

26．

class TestThis{

int day = 1;

void setDay(int day){

this.day = day;

}

public static void main(String[] args)

{

TestThis aa=new TestThis();

TestThis bb=new TestThis();

aa.setDay(10);

System.out.println("aa.day="+aa.day);

bb.setDay(20);

System.out.println("bb.day="+bb.day);

}

}

运行结果：

aa.day=10

bb.day=20

27.

class UseBook{

String name;

float price;

static int count=0;

static int bookNumber=100;

UseBook(String n,float p){

name = n;

price = p;

count++;

bookNumber++;

}

void output(){

prt("name: " + name + "\t" + "price: " + price + "\t");

prt("bookNumber: " + bookNumber + "\t" + "count: " + count + "\t") ;

System.out.println();

}

public static void prt(String s){

System.out.print(s);

}

public static void main(String[] args){

UseBook b1,b2,b3;

b1=new UseBook("java2",36.0f);

b1.output();

b2=new UseBook("c++",40.0f);

b2.output();

b3=new UseBook("vb",20.0f);

b3.output();

}

}

运行结果为：

name: java2 price: 36.0 bookNumber: 101 count: 1

name: c++ price: 40.0 bookNumber: 102 count: 2

name: vb price: 20.0 bookNumber: 103 count: 3

28.

public class Test{

private static int j = 0 ;

public static boolean methodB(int k){

J += k;

return true;

}

public static void methodA(int i){

boolean b;

b = i > 10 & methodB(1);

b = I > 10 && methodB(2);

}

public static void main (String args){

MethodA(0)

System.out.println(“j = +i”);

}

}

答：j=1

29. public class Test{

static void leftshift(int i,int j){

i<<=j;

}

public static void main(String[] args){

int i=4,j=2;

leftshift(i,j);

Systerm.out.println(“i = ” +i);

}

}

答：i=4

30.

public class Myclass{

private static int a = 100;

public static void main(String[] args){

modify(a);

Systerm.out.println(a);

}

public static void modify(int a){

a ++;

}}

答：100

31．

public class InitDemo{

InitDemo (){

j=1000;

Systerm.out.println(“j=”+j);

}

int i;

static int j=50;

{

i=5;

j=10;

Systerm.out.println(“i=”+i);

Systerm.out.println(“j=”+j);

}

Static{

J=100;

Systerm.out.println(“j=”+j);

}

Public static void main (String[] args){

Systerm.out.println(“InitDemo.j=”InitDemo.j”);

InitDemo aa=new InitDemo();

InitDemo.j=500;

Systerm.out.println(“aa.j=”+aa.j);

}}

答：j = 100

InitDemo.j = 100

i = 5

j = 10

j = 1000

aa.j = 500

32．

class Animal{

public Animal（）{

System.out.println(“I’m an animal”);

}

}

class Bird extends Animal{

public Bird(){

System.out.println(“I’m a bird.”);

}

}

public class AnimalTest{

public static void main(String[]args){

Bird b = new Bird();

}

}

运行结果为：

I'm an animal

I'm a bird.

33．

class A{

int x,y;

void setXY(int x,int y){

this.x = x;

this.y = y;

}

int multiply(){

return x * y;

}

}

class B extends A{

int x,z;

B(int x,int z){

super();

this.x =x;

this.z =z;

}

int multiply(){

return x * y * z;

}

}

public class ABTest{

public static void main(String[]args){

A a = new B(5,10);//x=5,z=10

a.setXY(10,20);//x=10,y=20

System.out.println("m="+a.multiply());//m=1000(5*10*20)?

B b=new B(6,9);//x=6.z=9

b.setXY(7,8);//x=7,y=8

b.z=10;//z=10

System.out.println("m="+b.multiply());//m=480(6*8*10)

}

}

运行结果为：

m=1000

m=480

34．class Parent{

void printMe(){

System.out.println("I'm a parent.");

}

}

class Child extends Parent{

void printMe(){

System.out.println("I'm a child.");

}

void printAll(){

super.printMe();

this.printMe();

printMe();

}

}

public class Test{

public static void main(String[]args){

Child myC = new Child();

myC.printAll();

}

}

运行结果为：

I'm a parent.

I'm a child.

I'm a child.

Press any key to continue...

34．

abstract class AA{

abstract void callme();

void metoo(){

System.out.println("Inside AA's metoo.");

}

}

class BB extends AA{

void metoo(){

System.out.println("Inside BB's metoo.");

}

void callme(){

System.out.println("Inside BB's callme.");

}

}

public class AbstractTest{

public static void main(String[]args){

AA aa = new BB();

aa.callme();

aa.metoo();

}

}

运行结果：

Inside BB's callme.

Inside BB's metoo.

Press any key to continue...

35．

class Employee{}

class Manager extends Employee{}

class Secretary extends Employee{}

class Programmer extends Employee{}

public class Test24{

public static void method(Employee e){

if (e instanceof Manager)

System.out.println("He is a Manager.");

else if (e instanceof Secretary)

System.out.println("He is a Secretary.");

else if (e instanceof Programmer)

System.out.println("He is a Programmer.");

}

public static void main(String[] args){

Manager m = new Manager();

Secretary s = new Secretary();

Programmer p = new Programmer();

method(m);

method(s);

method(p);

}

}

输出结果为：

He is a Manager.

He is a Secretary.

He is a Programmer.

36．

public class Test{

public static void main(String [] args){

try{

for(int i = 3 ; i >= 0 ; i--){

System.out.println("The value of i : "+i);

System.out.println(6 / i);

}

}catch(ArithmeticException ae){

System.out.println("Divided by zero.");

}

}

}

输出结果为：

The value of i : 3

2

The value of i : 2

3

The value of i : 1

6

The value of i : 0

Divided by zero.

37．

public class Foo{

public static void method(int i){

try{

if(i >0){

return;

}else{

System.exit(1);

}

} finally{

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

}

public static void main(String [] args){

method(5);

method(-5);

}

}

输出结果为：

Finally

38．

public class Test1{

public static String output="";

public static void foo(int i){

try {

if(i==1){

throw new Exception();

}

output +="1";

}catch (Exception e){

output +="2";

return ;

}finally{

output +="3";

}

output +="4";

}

public static void main(String[] args){

foo(0);

foo(1);

System.out.println("output="+output);

}}

运行结果为：

output=13423

39．

public class ExceptionDemo{

public static void methodA(){

try{

System.out.println(“inside methodA”);

throw new RuntimeException(“demo”);

}finally{

System.out.println(“methodA’s finally”);

}

}

public static void methodB(){

try {

System.out.println(“inside methodB”);

return;

}finally{

System.out.println(“methodB’s finally”);

}

}

public static void methodC(){

try {

System.out.println(“inside methodC”);

return;

}finally{

System.out.println(“methodC’s finally”);

}

}

public static void main(String[] args){

try {

methodA();

}catch(Exception e){

System.out.println(“Exception caught”);

}

methodB();

methodC();

}

}

运行结果：

inside methodA

methodA’s finally

Exception caught

inside methodB

methodB’s finally

inside methodC

methodC’s finally

40．

public class Messager implements Runnable{

public static void main(String[] args){

new Thread(new Messager("Tiger")).start();

new Thread(new Messager("Lion")).start();

}

private String name;

public Messager (String name){

this.name=name;

}

public void run (){

message(1);

message(2);

}

public synchronized void message (int n){

System.out.print(name+":"+n+" ");

}}

运行结果为：

Tiger:1 Tiger:2 Lion:1 Lion:2

41．

三.填空题

1、main方法的声明格式包括_public static void main(String [] args)。

2、Java中类成员的访问限定词中，_public__的限定的范围最大。

3、Java中所有类都是类__Object_的子类。

4、在Java中有一种叫作构造方法的特殊方法，我们在程序中用它来对类的对象成员进行初始化。

5、静态方法只能处理用关键字static修饰的变量。

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

7、基本数据类型int对应的封装类是Integer。

8、每个java程序到要使用到的包是java.lang。

9、通过关键字可以访问父类的成员super。

10、Java程序中，类的继承属于单继承。

11、Java程序的种类有：内嵌于Web文件中，由浏览器来观看的__Appket

，可独立运行的__Applacation。

12.在一个类中可同时定义很多同名的方法，但其___参数个数___以及___类型__不能相同，传回值也可能不同。这种面向对象程序特性称为__多态_。

13、__抽象abstract_类只能定义但不能被实例化，_最终类final类不能被继承，_Object_类是所有类的共同父类。

14、Java语言源程序的扩展名为_.java_，编译后的字节码文件扩展名为,class。

15、Java语言中___util_类包中包含一些低级的使用工具类，__awt_类包中提供了创建图形用户界面的全部工具。

16、Applet的生命周期中，四个方法对应着四个阶段，分别是__ init、 start、 stop、_ destroy _。

17、___ Throwable、_是所有异常类的共同父类、_ Exception _、Error_是它的直接子类。

18、菜单是用户图形界面的重要组成部分，是由__菜单条_菜单、_菜单项、菜单复选项__等对象组成。

19、System类提供输入输出功能，该类中有三个数据成员__ in、 out、err__。

20、线程的生命周期由四种状态组成，这四种状态可以转换，分别为___建立、__运行、_不可运行、_死亡__。

21．每个Java应用程序都要有且只有一个__main()_方法，它是程序运行的开始点。该方法的格式是_public static void main(String[] args)__。

22．如果要在程序中使用键盘输入语句，则需要预先导入_java.io___包。

23．在switch语句中，表达式的值必须是__字符___或者__整型__数据。

24．在面向对象概念中，每一个对象都是由__成员（状态）_和_方法（行为）____两个最基本的部分组成的。虽然同一类对象的__行为__都是一样的，但是每个对象的__状态__都是独立与其他对象的。

25．关键字_interface____是用来定义接口的；关键字__class__是用来定义类的。使用关键字__implements__来定义某个类的接口。

26．表示开始编写HTML语言程序，___表示编写结束。__用来标记启动字节码文件的位置。

27．在Java语言中，_包_是组织Java程序中类的一种手段，其作用与Windows系统中的__文件夹__类似。

28．__continue___语句可以终止当前一轮的循环，不再执行其下面的语句，直接进入下一轮的循环。_break__语句通可以使程序从一个语句体的内部跳出去，继续执行该语句体下面的语句。

29．_showMessageDialog()， ___对话框用来显示对用户的提示信息，__ showInputDialog()___对话框允许用户在若干个项目中进行选择或者直接键入所需的内容。

30．对象串行化可以很容易地扩展成支持Java对象的 持续存储或持久存储，它提供了对象从流中重建的补充方式.
31.Vector类的对象是通过capacity和capacityIncrement两个值来改变集合的容量，其中capacity表示集合最多能容纳的元素个数 ，capacityIncrement表示每次增加多少容量，不是一个一个增加.

35.构造函数_没有___返回值。

36．Java语言中的浮点型数据根据数据存储长度和数值精度的不同，进一步分为float和 ___double___两种具体类型。

37．创建类对象的运算符是_new_____。

38．Java 源程序文件编译后产生的文件的扩展名为 _.class____ 。

39．声明并创建类MyClass的一个对象，其名称为obj，可通过以下语句实现：__Myclass obj=new Myclass()___。

40．设有整型数组的定义：int a[]=new int[8]; ，则a.length的值为__8___。

41．在转向语句中　__continue_____语句使得程序结束本次循环，回到循环的条件测试部分继续执行。

42．在第一次加载Applet时，默认最先执行的方法是_init()__。

43．___ CheckboxGroup_类用于创建一组单选按钮。

44．Java异常中无论发生不发生异常都会被执行的代码段是_finally__代码段。

四．判断题

1、Java中类的构造函数只能有一个。（x）

2、程序中抛出异常时(throw …)，只能抛出自己定义的异常对象。（x）

3、语句import java.applet.Applet；最后的Applet是代表类(class)。（√）

4、一个异常处理中 finally语句块只能有一个或者可以没有。（√）

5、用Javac编译Java源文件后得到代码叫字节码。（√）

6、数组、类和接口都是引用数据类型。（√）

7、一个Applet编译后的类名是Test.class，运行此小程序的命令是Java Test。（x）

8、Java语言中一个Char类型的数据占用2个字节大小的内存空间。（√）

9、抽象类不能实例化。（√）

10、一个方法最多能有一个return语句。（x）

11．面向对象的软件开发方法用类把数据和基于数据的操作封装在一起，并且类之间可以存在继承关系。(√)

12．一个类中用private 修饰符修饰的属性成员，可被该类的方法和它的子类的方法访问。(x)

13．Java 源程序的文件名必须和公共类的类名相同。(√)

14．属性的隐藏是指子类重新定义从父类继承来的同名变量。(√ )

15．用static修饰的方法称为静态方法，它不属于类的一个具体对象，而是整个类的类方法。(√ )

16．声明为final的方法不能在子类中重载。(√ )

17．类的public类型的成员变量不可以被继承。(x )

18．Java源程序文件中是不区分字母的大小写的。(x)

19．子类可以继承父类所有的成员变量及成员方法。(x )

20．Java类中不能存在同名的两个成员方法。（x）

21．字符串 "\’a\'" 的长度是5。(√)

22．同一个类中定义多个参数列表不同的同名方法,叫做方法的重载。(√ )

23．一个程序里可以有多个父类，也可以有多个主类。(x)

24．在父类中声明为 final 的方法，也可以在其子类中被重新定义(覆盖)。(x )

25．接口中所有方法均为抽象方法。(√)

26．False 是合法的 Java 标识符。(x )

27．保留字 this 代表当前对象。(√ )

28．类的构造函数名必须和类名相同。(√)

29．子类的对象能直接向其父类对象赋值。(√)

30．应用程序一定要有main()方法，小程序一定要继承于Applet 类。(√ )

31．构造方法名必须与类名相同，但一般方法就不能与类同名(√)。

32．被final修饰的域可被看作是常量，完全用大写字母表示(√)。

33．静态初始化器是构造方法之前加上static修饰符(x)。

34．数组是用来存放一批相同类型的对象或数据，当数据的顺序和个数经常变动时就要用到向量来存放(√)。

35．Application不能单独运行，需要嵌入在HTML文件中，借助浏览器来解释执行(x)。

36．AWT事件都不处理自己的事件，而是将事件处理委托给外部的处理实体，这种处理模型称为事件的授权处理模型(√)。

37．线程是程序在处理机中的一次运行，是程序单一而连续控制流程(x)。

38．线程运行状态由start()方法激活，并分配了他所需系统资源(√)。

39．Java语言设计C/S程序时，应注意服务器使用Socket类来处理客户机的连接请求(x)。

40．一个线程对象运行的目标代码是由run()方法提供的，但Thread类的run()方法是空的，其中没有内容，所以用户程序要么继承Thread类并覆盖其run()方法，要么使一个类实现Runnable接口，并实现其中的run()方法。(√)

41．某程序中的主类不是Thread类的子类，也没有实现Runnable接口，则这个主类运行时不能控制主线程睡眠。(×)

42．一个正在执行的线程对象调用yield()方法将把处理器让给与其同优先级的其他线程。(√)

43．下面的语句将线程对象mt的优先级设置为12：mt.setPriority(12);。(×)

44．Java语言的线程调度采用抢占式调度策略，即优先级高的线程可以抢占优先级低的线程获得处理器的时间。(√)

45．一个线程由于某种原因（如睡眠、发生I/O阻塞）从运行状态进入阻塞状态，当排除阻塞原因后即重新进入运行状态。(×)

G一个线程因为I/O操作发生阻塞时，执行resume()方法可以使其改变到可运行状态。(×)

五.程序设计题

1．定义一个名为Person的类，其中含有一个String类型的成员变量name和一个int类型的成员变量age，分别为这两个变量定义访问方法和修改方法，另外再为该类定义一个名为speak的方法，在其中输出name和age的值。编写一应用程序，使用上面定义的Person类，实现数据的访问、修改。

参考程序如下：

public class Person {

String name;

int age;

public void setName(String name){

this.name = name;

}

public String getName(){

return name;

}

public void setAge(int age){

this.age = age;

}

public int getAge(){

return age;

}

public void speak(){

System.out.println("Name="+name);

System.out.println("Age="+age);

}

public static void main(String[]args){

Person p = new Person();

p.setName("LiMing");

p.setAge(20);

p.speak();

System.out.println(p.getName());

System.out.println(p.getAge());

}

}

2．型的成员变量表示矩形的长和宽。要求为每个变量定义访问方法和修改方法，定义求矩形周长的方法perimeter()和求面积的yyifarea()。编写一个类测试这个矩形类。

参考程序如下：

public class Rectangle{

double length;

double width;

public void setLength(double length){

this.length = length;

}

public double getLength(){

return length;

}

public void setWidth(double width){

this.width = width;

}

public double getWidth(){

return width;

}

public double perimeter(){

return 2*(length+width);

}

public double area(){

return length*width;

}

}

public class RectDemo{

public static void main(String args[]){

Rectangle rect = new Rectangle();

rect.setLength(20);

rect.setWidth(10);

System.out.println("该矩形的长为："+rect.getLength());

System.out.println("该矩形的宽为："+rect.getWidth());

System.out.println("该矩形的周长为："+rect.perimeter());

System.out.println("该矩形的面积为："+rect.area());

}

}

3．为上题的Rectangle类编写一个带参数构造方法，通过用户给出的长、宽创建矩形对象，再编写一个默认构造方法，在该方法中调用有参数构造方法，将矩形长宽都设置为0.0。编写一个类测试这个矩形类。

参考程序如下：

public class Rectangle{

double length;

double width;

public Rectangle(double length,double width){

this.length = length;

this.width = width;

}

public Rectangle(){

this(0.0,0.0);

}

public void setLength(double length){

this.length = length;

}

public double getLength(){

return length;

}

public void setWidth(double width){

this.width = width;

}

public double getWidth(){

return width;

}

public double perimeter(){

return 2*(length+width);

}

public double area(){

return length*width;

}

}

public class RectDemo{

public static void main(String args[]){

Rectangle rec1 = new Rectangle(20,10);

System.out.println("该矩形的长为："+rec1.getLength());

System.out.println("该矩形的宽为："+rec1.getWidth());

System.out.println("该矩形的周长为："+rec1.perimeter());

System.out.println("该矩形的面积为："+rec1.area());

System.out.println();

Rectangle rec2 = new Rectangle();

System.out.println("该矩形的长为："+rec2.getLength());

System.out.println("该矩形的宽为："+rec2.getWidth());

System.out.println("该矩形的周长为："+rec2.perimeter());

System.out.println("该矩形的面积为："+rec2.area());

System.out.println();

rec2.setLength(100);

rec2.setWidth(50);

rec2.setColor("YELLOW");

System.out.println("该矩形的长为："+rec2.getLength());

System.out.println("该矩形的宽为："+rec2.getWidth());

System.out.println("该矩形的颜色："+rec2.getColor());

System.out.println("该矩形的周长为："+rec2.perimeter());

System.out.println("该矩形的面积为："+rec2.area());

}

}

4．定义一个Triangle类表示三角形，其中包括3个double型变量a、b、c，用于表示3条边长。为该类定义两个构造方法：默认构造方法设置三角形的3条边长都为0.0；带3个参数的构造方法通过传递3个参数创建三角形对象。定义求三角形面积的方法area()，面积计算公式为area=Math.sqrt(s*(s-a)*(s-b)*(s-c))，其中s=(a+b+c)/2。编写程序测试该类。

参考程序如下：

public class Triangle{

double a,b,c;

public Triangle(){

this.a = 0; this.b = 0; this.c = 0;

}

public Triangle(double a, double b, double c){

this.a = a; this.b = b; this.c = c;

}

public double area(){

double s = (a + b + c) / 2.0;

return Math.sqrt(s * (s-a) * (s-b) * (s-c));

}

public static void main(String[] args){

Triangle ta = new Triangle(3, 4, 5);

System.out.println(ta.area());

}

}

5．编写一个名为Input的类，该类属于com.tools包。使用该类实现各种数据类型（字符型除外）数据输入，其中的方法有readInt()、readDouble()、readString()等。在用户程序中通过调用Input.readDouble()即可从键盘上输入double型数据。例如，下面程序可以读入一个doouble型数据：

import com.tools.Input;

public class Test{

public static void main(String [] args)

double d = Input.readDouble();

System.out.printIn(“d = ”+d);

}

}

提示：使用java.util包中的Scanner类实现

参考程序如下：

import java.util.Scanner;

public class Input{

static Scanner sc = new Scanner(System.in);

public static byte readByte(){

System.out.print("Please input a byte value:");

return sc.nextByte();

}

public static short readShort(){

System.out.print("Please input a short value:");

return sc.nextShort();

}

public static int readInt(){

System.out.print("Please input a int value:");

return sc.nextInt();

}

public static long readLong(){

System.out.print("Please input a long value:");

return sc.nextLong();

}

public static float readFloat(){

System.out.print("Please input a float value:");

return sc.nextFloat();

}

public static double readDouble(){

System.out.print("Please input a double value:");

return sc.nextDouble();

}

public static boolean readBoolean(){

System.out.print("Please input a boolean value:");

return sc.nextBoolean();

}

public static void main(String args[]){

double d = Input.readDouble();

System.out.println("d = " + d);

}

}

6．编写一个名为ComplexNumber类，实现复数概念及其运算，它的UML图如下图所示。编写一个程序测试ComplexNumber类的使用。

参考程序如下：

public class ComplexNumber{

private double realPart;

private double imaginaryPart;

public ComplexNumber(){ // 默认构造方法

}

public ComplexNumber(double r,double i){

this.realPart = r;

this.imaginaryPart = i;

}

public double getRealPart(){

return realPart;

}

public double getImaginaryPart(){

return imaginaryPart;

}

public void setRealPart(double d){

this.realPart=d;

}

public void setImaginaryPart(double d){

this.imaginaryPart=d;

}

public ComplexNumber complexAdd(ComplexNumber c){

ComplexNumber temp=new ComplexNumber(0.0,0.0);

temp.setRealPart(this.getRealPart()+c.getRealPart());

temp.setImaginaryPart(this.getImaginaryPart()+

c.getImaginaryPart());

return temp;

}

public ComplexNumber complexMinus(ComplexNumber c){

ComplexNumber temp=new ComplexNumber(0.0,0.0);

temp.setRealPart(this.getRealPart()-c.getRealPart());

temp.setImaginaryPart(this.getImaginaryPart()-

c.getImaginaryPart());

return temp;

}

public ComplexNumber complexMulti(ComplexNumber c){

ComplexNumber temp=new ComplexNumber(0.0,0.0);

temp.setRealPart(this.getRealPart()*c.getRealPart()+

this.getImaginaryPart()*c.getImaginaryPart());

temp.setImaginaryPart(this.getImaginaryPart()*c.getRealPart()+

this.getRealPart()*c.getImaginaryPart());

return temp;

}

public String toString(){

if(realPart==0.0)

return imaginaryPart+"i";

if(imaginaryPart==0.0)

return realPart+"";

if(imaginaryPart<0.0)

return realPart+""+imaginaryPart+"i";

else

return realPart+"+"+imaginaryPart+"i";

}

}

注，原程序代码没有测试段，由吴老师增补如下：

public class TestComplexNumber{

public static void main(String[] args)

{

ComplexNumber c1=new ComplexNumber(3,2);

ComplexNumber c2=new ComplexNumber(3,4);

c2.complexAdd(c1);

System.out.println("complexAdd="+c2.complexAdd(c1));

System.out.println("complexAdd="+c2.complexMulti(c1));

System.out.println("complexAdd="+c2.complexMinus(c1));

}

}

7．定义一个名为Student的类，它继承Person类，其中定义sno（表示学号）和major（表示专业）两个成员变量和封装这两个变量的方法。编写主程序，检查新建类中的所有变量和方法。

参考程序如下：

public class Student extends Person{

String sno;

String major;

public void setSno(String sno){

this.sno = sno;

}

public void setMajor(String major){

this.major = major;

}

public String getSno(){

return sno;

}

public String getMajor(){

return major;

}

public static void main(String[] args){

Student stud = new Student();

stud.setName("LiuMing");

stud.setAge(20);

stud.setSno("200215121");

stud.setMajor("Information Science");

System.out.println(stud.getName());

System.out.println(stud.getAge());

System.out.println(stud.getSno());

System.out.println(stud.getMajor());

}

}

8.设计一个汽车类Auto，其中包含一个表示速度的double型的成员变量speed和表示启动的start()方法、表示加速的speedUp()方法以及表示停止的stop()方法。再设计一个Auto类的子类Bus表示公共汽车，在Bus类中定义一个int型的、表示乘客数的成员变量passenger，另外定义两个方法gotOn()和gotOff()表示乘客上车和下车。编写一个应用程序，测试Bus类的使用。

参考程序如下：

public class Auto{

private double speed;

public void start(){

System.out.println("The auto is started.");

}

public void speedUp(double speed){

this.speed = speed;

System.out.println("The auto is speed up to "+speed+"kilo/h.");

}

public void stop(){

this.speed = 0;

System.out.println("The auto is stoped.");

}

}

public class Bus extends Auto{

private int passenger;

public void gotOn(int n){

passenger = passenger+n;

System.out.println("The person on bus is:"+passenger);

}

public void gotOff(int n){

passenger = passenger-n;

System.out.println("The person on bus is:"+passenger);

}

}

public class BusTest{

public static void main(String []args){

Bus bus = new Bus();

bus.start();

bus.speedUp(60);

bus.stop();

bus.gotOn(10);

bus.gotOff(5);

}

}

9.定义一个名为Triangle的三角形类，使其继承Shape抽象类，覆盖Shape类中的抽象方法perimeter()和area()。编写一个应用程序，测试Triangle类的使用。

参考程序如下：

public abstract class Shape{

private String name;

public Shape(){}

public Shape(String name){

this.name = name;

}

public void setName(String name){

this.name = name;

}

public String getName(){

return name;

}

public abstract double perimeter();

public abstract double area();

}

public class Triangle extends Shape{

double a,b,c;

public Triangle(){

this.a = 0; this.b = 0; this.c = 0;

}

public Triangle(double a, double b, double c){

this.a = a; this.b = b; this.c = c;

}

public double area(){

double s = (a + b + c) / 2.0;

return Math.sqrt(s * (s-a) * (s-b) * (s-c));

}

public double perimeter(){

return a + b + c;

}

public static void main(String[] args){

Triangle ta = new Triangle(3, 4, 5);

System.out.println(ta.area());

}

}

10.定义一个名为Cuboid的长方体类，使其继承Rectangle类，其中包含一个表示高度的double型成员变量height，定义一个构造方法Cuboid(double length,double width,double height)和一个求长方体体积的volume()方法，编写一个应用程序，在其中求一个长、宽和高分别为10、5、2的长方体的体积。

参考程序如下：

public class Cuboid extends Rectangle{

private double height;

public Cuboid(double length,double width, double height){

super(length,width);

this.height = height;

}

public Cuboid(){

this(0,0,0);

}

public void setHeight(double height){

this.height = height;

}

public double getHeight(){

return height;

}

public double volume(){

return area() * height;

}

}

public class CuboidTest{

public static void main(String[]args){

Cuboid cb = new Cuboid();

cb.setLength(10);

cb.setWidth(5);

cb.setHeight(2);

System.out.println("volume="+cb.volume());

}

}

11.设计一个抽象类CompareObject，其中定义一个抽象方法compareTo()，用于比较两个对象，然后设计一个从CompareObject类派生的类Position，该类用x和y两个成员变量表示坐标，并实现compareTo()方法，用于比较两个Position对象到原点（0，0）的距离之差。

参考程序如下：

public abstract class CompareObject{

public abstract int compareTo(Object obj);

}

public class Position extends CompareObject{

private int x;

private int y;

public Position(){}

public Position(int x, int y){

this.x = x;

this.y = y;

}

public void setX(int x){

this.x = x;

}

public void setY(int y){

this.y = y;

}

public int getX(){return x;}

public int getY(){return y;}

//实现compareTo()方法

public int compareTo(Object obj){

Position pos = (Position)obj;

double dist1 = Math.sqrt(x*x + y*y);

double dist2 = Math.sqrt(pos.x * pos.x + pos.y * pos.y);

return (int)(dist1-dist2);

}

public static void main(String[]args){

Position pos1 = new Position(0,0);

Position pos2 = new Position(3,4);

System.out.println(pos1.compareTo(pos2));

}

}

12.设计一个日期类MyDate，要求构造MyDate类的对象时，如果没有给出参数，则日期设定为1970年1月1日；如果给出参数，则需要给出年月日。编写一个equals()方法，判断两个日期是否相等；以及一个compareTo()方法进行日期的比较，该方法返回两个日期相差的天数。

参考程序如下：

import java.util.Date;

public class MyDate {

private int year;

private int month;

private int day;

public MyDate() {

year = 1970;

month = 1;

day = 1;

}

public MyDate(int year,int month,int day){

this.year = year;

this.month = month;

this.day = day;

}

public int getYear(){ return year;}

public int getMonth(){ return month; }

public int getDay(){ return day; }

public boolean eauals(Object obj){

MyDate md = (MyDate)obj;

if(this.year== md.year && this.month==md.month &&

this.day == md.day)

return true;

else

return false;

}

public int compareTo(MyDate md){

//这里使用Date类计算两个日期差的天数

Date d = new Date(year,month,day);

Date d2 = new Date(md.year,md.month,md.day);

long days =(d.getTime()-d2.getTime())/1000/60/60/24;

return (int)days;

}

public static void main(String []args){

MyDate md1 = new MyDate(2007,12,20);

MyDate md2 = new MyDate(2008,12,20);

System.out.println(md2.compareTo(md1));

}

}

13.定义一个名为TrafficLight的enum类型，它包含3个常量：GREEN，RED和YELLOW，表示交通灯的3种颜色。通过values()方法和ordinal()方法循环并打印每一个值及其顺序值.编写一个switch语句，为TrafficLight的每个常量输出有关信息。

参考程序：

public enum TrafficLight{

GREEN, RED, YELLOW;

public static void main(String[]args){

TrafficLight[] tl = TrafficLight.values();

for(TrafficLight light:tl){

System.out.print(light);

System.out.println(" "+light.ordinal());

}

TrafficLight red = TrafficLight.RED;

switch(red){

case RED:

System.out.println("RED, stop."); break;

case GREEN:

System.out.println("GREEN, go."); break;

case YELLOW:

System.out.println("YELLOW, do not know."); break;

}

}

}

14．编写一个程序，要求从键盘输入一个double型的圆的半径，计算并输出其面积。测试当输入的数据不是double型时（如字符串“abc”）会产生什么结果，并时行相应处理。

当输入数据不是字符串时抛出InputMismatchException异常，程序中应对该异常处理，程序如下：

import java.util.*;

public class Test{

public static void main(String args[]){

Scanner sc = new Scanner(System.in);

System.out.print("Input a radius:");

try{

double radius = sc.nextDouble();

double area = Math.PI*radius*radius;

System.out.printf("area = %.2f%n",area);

}catch(InputMismatchException e){

System.out.println(e);

System.out.println("Number Format Error.");

}

}

}

15．编写一个程序，在main（）方法中使用try块抛出一个Exception

类的对象，为Exception的构造方法提供一个字符串参数，在catch块内捕获该异常并打印出字符串参数。添加一个finally块并打印一条消息。

参考程序如下：

public class Test{

public static void main(String args[]){

try{

throw new Exception("demo exception");

}catch(Exception e){

System.out.println(e.getMessage());

}finally{

System.out.println("Program finished.");

}

}

}

16．编写一个程序，定义一个static方法methodA（），令其声明抛出一个IOException，异常，再定义另一个static方法methodB（），在该方法中调用methodA（）方法，在main（）方法中调用methodB（）方法。试编译该类，看编译器会报告什么？对于这种情况应如何处理？由此可得到什么结论？

参考程序如下：

public class Test{

public static void methodA() throws IOException{

System.out.println("In method A");

}

public static void methodB(){

methodA();

System.out.println("In method B");

}

public static void main(String args[]){

methodB();

}

}

17．创建一个自定义的异常类（该类继承Exception类），并为该类写一个构造方法，在构造方法带一个String类型的参数。再写一个方法，令其打印出保存下来的String对象。再编写一个类，在main（）方法中使用try-catch结构创建一个MyException类的对象并抛出，在catch块中捕获该异常并打印出传递的String消息。

参考程序如下：

public class MyException extends Exception{

public MyException() {

}

public MyException(String message){

super(message);

}

public void output(){

System.out.println(getMessage());

}

public static void main(String[] args){

try{

throw new MyException("My Exception.");

}catch(MyException e){

e.output();

System.out.println(e.getMessage());

}

}

}

18．编写一个实现下面功能的Java小程序：当单击“开始”按钮时随机产生一个两位整数，在文本框中不断显示，单击“停止”按钮时，停止显示并将当前产生的数显示在一个标签中，如下图1。

//

//

import java.awt.*;

import java.awt.event.*;

import javax.swing.*;

public class BonusDemo extends JApplet

implements ActionListener, Runnable{

JTextField tf=new JTextField(10);

JButton b1=new JButton("开始"),

b2=new JButton("停止");

JLabel l=new JLabel(" ");

Thread t;

String s="";

boolean run=true;

public void init(){

setLayout(new FlowLayout());

add(tf);add(b1);add(b2);

add(l);

b1.addActionListener(this);

b2.addActionListener(this);

}

public void actionPerformed(ActionEvent e){

if(e.getSource()==b1){

run = true;

t = new Thread(this);

t.start();

} else if(e.getSource()==b2){

run = false;

l.setText(s = s+tf.getText()+" ");

}

}

public void run(){

while(run){

try{

int i=(int)(Math.random()*90+10);

tf.setText(""+i);

Thread.sleep(200);

}catch(InterruptedException e){}

}

}

}

19．编写一个Java小程序，要求从HTML文件中传递3个整数，在小程序中以这3个整数创建一个Color对象，并将小程序的背景设置为该颜色。

参考程序：

import java.awt.*;

import javax.swing.*;

public class ParamDemo extends JApplet {

Container cp;

public void init(){

int r = Integer.parseInt(getParameter("r"));

int g = Integer.parseInt(getParameter("g"));

int b = Integer.parseInt(getParameter("b"));

Color c = new Color(r,g,b);

cp = getContentPane();

cp.setBackground(c);

}

}

下面是HTML代码：

code = "ParamDemo.class"

width = "300" height = "150" >