Java习题集3 - 图文

2 4 6 8 10 28 32 53 简答题 单选全部 判断题全部

1 2 3 5 6 7 10 21 写程序题 2 3 7 8 24 25 编程题

JAVA语言程序设计习题集

50-55接口。

一、简答题

1、Java程序分为哪两大类，它们之间有哪些相同点？主要区别有哪些？ 答：Java程序分为Java Application和Java Applet。

相同点有两个：（1）两类程序都由一个或多个以.class为后缀的文件组

成；（2）两类程序都需要用户系统安装Java虚拟机（JVM）。Java虚拟机能够载入并翻译Java程序，并且可以提供Java内核包的实现。

区别有：（1）Java Applet程序可以被嵌入HTML网页内，从而可以在网

络上发布，当网页被浏览时它们可以在浏览器中运行；而Java Application程序却不支持网页嵌入和下载。（2）Java Applet程序只能在与Java兼容的容器中运行，例如网络浏览器；而Java Application程序却没有这个限制。（3）一个Java Applet程序必须定义一个Applet类的子类，一个Java Application程序也可以定义一个Applet类的子类，但这不是必须的，一个 Java Application程序必须在一个类中定义一个main方法，而一个Java Applet 程序并不定义main方法，它的执行是由Applet类定义的多个方法控制的。

2、Java程序是由什么组成的？Java 源文件的命名规则是怎样的？

答：一个Java 程序是由若干个类组成的。但只能有一个类是public 类。Java源文件命名规则是：源文件名必须与其中的public 类的名字相同，扩展名是java；如果源文件中没有public 类，那么源文件的名字只要和某个类的名字相同，并且扩展名是java就可以了。

3、Java语言与Java技术的关系如何？Java语言包括哪两部分?

答：Java语言是Java技术的基础。Java语言包括语法规则和Java类库两部分。

4、开发与运行Java程序需要经过哪些主要过程? 答：源程序编辑、字节码编译和解释运行。

5、为什么一个Java文件编译后可以获得多个字节码文件?

答：这是因为一个源文件中可有多个类，文件经过编译后，每个类就生成一个字节码文件（扩展名为class）。

6、简述Java应用程序和Java小应用程序各用什么方式解释运行的？

答：Java应用程序和Java小应用程序的源代码编辑与字节码编译生成过程是一样的，而其执行也都是解释执行其编译好的字节码文件，只是Java应用程序需使用独立的Java解释器来解释执行其字节码文件，而Java小应用程序的字节码文件必须嵌入到HTML语言的文件中并由负责解释HTML文件的WWW浏览器充

- 1 -

当其解释器，来解释执行Java小程序的字节码文件。

7、面向对象的开发方法与传统的面向过程的开发方法有什么不同?

答：传统的面向过程的开发方法是把现实世界的问题转化成计算机逻辑，而面向对象技术是计算机逻辑来模拟现实世界的问题。

8、什么是对象、类和实体?它们之间的关系如何？试述下面的说法映射到面向对象的计算机逻辑中分别对应什么概念。

(1)计算机92班 (2)计算机92班的同学刘利 (3)大学生 (4)X大学的大学生 (5)班级

答：对象是现实世界中某个具体的物理实体在计算机逻辑中的映射和体现；类是同种对象的集合与抽象。

(1)班级类的对象 (2)大学生类的对象 (3)大学生类 (4)大学生类的子类 (5)班级类

9、对象有哪些属性？在计算机逻辑中如何描述这些属性？

答：对象有状态、行为、标志三个属性；在计算机逻辑中分别用对象的变量、方法和对象名来描述这三个属性。 10、面向对象的开发包括哪些过程？

答：面向对象的分析(OOA)、面向对象的设计(OOD)、面向对象的编程(OOP)、面向对象的测试。

11、面向对象程序设计方法有哪几个最重要的特点?

答：抽象、封装、继承、多态。

12、什么是父类(超类)?什么是子类?父类、子类间属性有何关系?

答：当两个类具有继承关系时，被继承的类称为父类或超类；继承了父类或超类的所有数据和操作的类称为子类。父类是所有子类的公共属性的集合，而每一个子类则是父类的特殊化，是在公共属性的基础上的功能、内涵的扩展和延伸。 13、什么是封装？

答：封装就是指利用抽象数据类型将数据和基于数据的操作封装在一起，数据被保护在抽象数据类型的内部，系统的其它部分只有通过包裹在数据外面的被授权的操作，才能够与这个抽象数据类型交流和交互。

14、使用继承有什么好处？什么是单重继承？什么是多重继承？Java采用的是单重继承还是多重继承？ 答：使用继承的主要好处是使得程序结构清晰，降低了编码和维护的工作量。只有一个单一父类称为单重继承。一个类可以有一个以上的父类称为多重继承。Java采用的是单重继承。

15、什么是多态？实现多态有哪些方式？

答：一个程序中同名的不同方法共存的情况称为多态。实现多态的方式有覆盖和重载。 16、什么是覆盖多态？什么是重载多态？覆盖多态和重载多态分别如何区分不同的同名方法？

答：子类对继承自父类的方法的重新定义就称为方法的覆盖，这种多态称为

- 2 -

覆盖多态；类对自身已有的同名方法的重新定义称为重载，这种多态称为重载多态。覆盖多态以对象名或类名为前缀来区分不同的同名方法；而重载多态则是使用不同的参数列表来区分不同的同名方法。 17、类及类成员的访问控制符有哪些?

答：public，protected，private，private protected。

????18、构造函数特殊在哪里？构造函数什么时候执行？被谁调用？

答：构造函数的特殊性在于它既可以从父类那里继承，也可以相互重载。

构造函数在创建新对象时执行，由系统自动调用。

19、类的访问说明符有哪些？

答：有public,final,abstract,protected（不加任何说明的缺省值） 20、方法访问说明符有哪些？

答：有public,protected,private,default。 21、关键字static可以修饰哪些类的组成部分？ 答：可以修饰属性、方法、静态初始化器。

22、什么是静态初始化器？静态初始化器与构造函数有什么不同？

答：静态初始化器是由关键字static引导的一对大括号括起的语句组，其作用与类的构造函数有些相似，都是用来完成初始化的工作，但静态初始化器在三点上与构造函数有根本的不同：

（1）构造函数是对每个新创建的对象初始化，而静态初始化器是对类自身进行初始化。

（2）构造函数是在用new运算符产生新对象时由系统自动执行，而静态初始化器则是在它所属的类加载入内存时由系统调用执行。

（3）不同于构造函数，静态初始化器不是方法，没有方法名、返回值和参数列表。

23、静态属性有什么特点？类对象可以访问或修改静态属性吗？

答：静态属性是类的属性，不专属于某个方法，类对象可以访问或修改静态属性。

24、设某程序创建了类MyClassl的两个对象，试写出静态初始化器和构造函数执行的前后次序与次数。

答：先执行类MyClassl的静态初始化器一次，再执行构造函数两次。 25、抽象方法有什么特点？抽象方法的方法体在何处定义？

答：抽象方法的特点是用abstract修饰符修饰，只有方法头没有具体的方法体。

抽象方法在定义该方法的抽象类的非抽象子类中定义。

26、final修饰符可以用来修饰什么？被final修饰符修饰后有何特点?

答：final修饰符可用来修饰类、属性、方法和终结器。

被final修饰符修饰的类没有子类。被final修饰符修饰的属性在程序整个执行过程中都不能改变。被final修饰符修饰的方法是功能和内部语句不能更改的最终方法。被final修饰符修饰的终结器（以称析构器——finalize()

- 3 -

方法，是在对象被删除前进行收尾工作的方法）也是不能更改的。 27、哪些修饰符不能组合使用？

答：abstract与private，abstract与final，abstract与static。 28、书写语句完成下面的功能。

(1）定义一个类，其名称为MyClass，类体为空，它可以被所有的其他类访问。

（2）将对象Objectl的属性fieldl在屏幕上显示出来。

答：（1）public class MyClass{}

（2）System.out.print(Object1.field1); 29、书写语句完成下面的功能。

(１)调用对象Objectl的方法methodl，把返回值赋值给变量Hold。 (２)定义一个整型属性Mine，使得只有这个类本身可以访问它。 答：(1) Hold=Object1.method1(); (2) private int Mine; 30、书写语句完成下面的功能。

(1)为类Classl定义一个整型变量field2，使得所有其他类都可以访问它。 (2)定义一个无形式参数无返回值的方法method2，使得使用类名Classl作前缀就可以调用它。

答：(1) public class Class1{public int field2;} (2) static void method2() 31、书写语句完成下面的功能。

(1)为类Class2编写构造函数的方法头，该构造函数不接受形式参数。 (2)为类Class2编写构造函数的方法头，该构造函数接受两个整型形式参数。

答：(1) Class2()

(2) Class2(int c1,int c2) 32、书写语句完成下面的功能。

(１)创建类Classl的一个对象Objectl，定义这个类的一个引用Refl，把对象Objectl的引用赋给Ref1。

(2)为类Classl创建一个静态整型变量s_data。

答：(1) Class1 Object1=new Class1();Class1 Ref1=Object1; (2) static int s_data;

33、Java中如何定义继承关系？写出定义类库中的类java.awt.Frame的子类MyFrame的类头的语句。

答：Java中是通过extends关键字定义继承关系的，其语句的一般格式是： class 子类 extends 父类。

import java.awt.*；

class MyFrame extends Frame

34、设父类SuperClass中定义了公共整型属性SuperProperty，SuperClass的

- 4 -

子类SubClass中定义了公共整型属性SubProperty，则属性SubClass.SuperProperty是否存在?来自何处?

答：存在，这个属性是从其父类那里继承来的。

35、什么是多重继承？Java是否支持多重继承？Java采取什么机制来替代多重继承？

答：一个子类有多个父类的情况称为多重继承，Java不支持多重继承，Java用实现接口的方法替代多重继承。 36、什么是属性（域）的隐藏?

答：子类重新定义一个与从父类那里继承来的属性完全相同的属性，称为属性的隐藏。

37、一个类里是否可以有同名属性共存的情况？是否最多只能有两个同名的属性。

答：子类重新定义父类的同名属性可以实现同名属性共存，若此子类的同名属性又被其子类所隐藏，可以有更多的同名属性共存。

38、一个类里有同名属性共存的情况下，如何分别操纵这些同名的属性?

答：使用子类定义的方法将操纵子类定义的属性；使用继承自父类的方法将操纵父类定义的属性。

39、子类重新定义与父类方法的方法头完全相同的方法，这种情况称为什么？此时子类中还能找到父类原来的方法吗？

答：这种情况称为方法的覆盖，

40、同名的不同方法共存的情况称为什么？如何区分这些同名方法？ 答：这种情况称为方法的重载。不同类的同名方法用类名区分，同类的同名方法用形式参数数目、顺序和类型区分。 41、Java中的多态有哪些方式？

答：Java中的多态有两种方式，第一种是子类对父类方法的覆盖，第二种是同类中方法的重载。 42、?重载中，两个同名方法只要返回类型或参数列表不同即可互相分辨?这种说法是否正确？为什么?

答：不正确，仅仅返回类型不同不能区分同名方法，必须参数列表不同。 43、试解释this和super两个关键字，其中this指代的是一个类还是一个具体的对象?

答：this表示的是当前对象本身，即this代表了当前对象的一个引用。super表示的是当前对象的父类对象，是当前对象的直接父类对象的引用。

this指代的是一个具体对象。

44、子类SubClass重新定义并覆盖了父类SuperClass中的方法methodl()，如何使子类能够调用父类原先定义的方法methodl()？ 答：super.methodl()；

45、构造函数可以继承吗？子类继承父类的构造函数应遵循哪些原则？

答：子类可以继承父类的构造函数，构造函数的继承原则有：

- 5 -

（1）子类无条件地继承父类的不含参数的构造函数；

（2）如果子类自己没有构造函数，则它将继承父类的无参数构造函数作为自己的构造函数，如果子类自己定义了构造函数，则在创建新对象时，它将先执行继承自父类的无参数构造函数，然后再执行自己的构造函数。

（3）对于父类的含参数的构造函数，子类可以通过在自己构造函数中使用super关键字来调用它，但这个调用语句必须是子类构造函数的第一个可执行语句。

46、一个构造函数如何调用同类的其他构造函数？如何调用父类的构造函数? 答：在同类中使用this，调用父类的构造函数使用super。 47、什么是包？如何创建包？为什么要使用包？包物理地对应什么?

答：包是相关类的松散集合。使用package语句可以创建包。使用包可以方便相关的类共同工作，也方便其他包中的类引用它们。包物理地对应文件夹，其中应保存包中类的字节码文件。

48、试写出一个语句创建一个名为MyPackage的包，这个语句应该放在程序的什么位臵?

答：package MyPackage；

应该在程序第一句。

49、试写出引用MyPackage中所有类的语句和引用MyPackage包中的一个类MyClassl。

答：引用MyPackage中所有类的语句是 import MyPackage.*；

引用MyPackage包中的一个类MyClass的语句是import MyPackage.MyClassl；

50、什么是接口？它起到什么作用？

答：接口是一种特殊的类，是用来实现类间多重继承功能的结构。 51、接口中包括什么?接口中的各成员的访问控制符是一样的吗?是什么?

答：接口中包括常量与抽象方法。接口中的属性成员的访问控制符都是public static final，接口中的所有方法的访问控制符都是public abstract，都是公共方法。 52、创建接口使用什么关键字？接口可以有父接口吗？试书写语句创建一个名为 MyInterface的接口，它是继承了MySuperInterfacel和MySuperInterface2两个接口的子接口。

答：创建接口使用interface关健字，接口可以有父接口。

Interface MyInterface extends

MySuperInterfacel,MySuperInterface2 53、一个类如何声明实现一个接口？

答：在类头处使用implements关键字。

54、实现接口的类是否必须覆盖该接口的所有抽象方法?

答：如果这个类是非抽象类的话，就必须覆盖该接口的所有抽象方法。

- 6 -

55、实现接口的抽象方法时，方法头应该与接口中定义的方法头完全一致，但是有时需要增加一个public修饰符，为什么?

答：接口的抽象方法的访问限制符都己指定为public，所以类在实现方法时，必须显式地使用public修饰符，否则将被系统警告为缩小了接口中定义的方法的访问控制范围。

56、程序中的错误分为哪两类? 答：编译错误和运行错误。

57、对于编译错误和运行错误，分别应如何排除?

答：排除编译错误可以借助于编译器的错误提示，排除运行错误要使用断点、单步运行等用户控制流程的调试手段。

58、写出三个常见的系统定义的异常，它们都是什么类的子类?

答：三个常见的系统异常是InterruptedException，ClassNotFoundException ，IOException 。它们都是Exception类的子类。 59、用户程序如何抛出自己的异常？系统定义的异常如何抛出?

答：用户程序使用throw关键字抛出异常。系统定义的异常由系统在合适的时刻自动抛出。

60、阅读下面的程序并写出类MyClass3的所有成员，并写明它们定义自哪里。 classMyClassl {

private int proll； double prol2； ’ }

class MyClass2 extends MyClassl {

private double prol2； int pr021； }

class MyClass3 extends MyClass2 {

private int pr021； double pr031；

}

答：pr012(MyClassl)，pr02l(MyClass3)，pr03l(MyClass3)。 61、阅读下面的程序片段并回答问题。 classClassl

{

int fieldl； int field2；

- 7 -

void methodl() {

System.out.println(?我是Classl的第一个方法?)； }

void method2() {

System.out.println(?我是Classl的第二个方法?)； } }

class Class2 extends Classl {

int field Childl； void methodChildl() {

System.out.println(?我是Class2的第一个方法?)； } }

（1）C1assl被称为是C1ass2的什么? C1ass2被称为是C1assl的什么?

(2)Classl有哪些方法和属性？Class2有哪些方法和属性？其中哪些与C1assl的方法和属性有关，是什么关系? 答：（1）父类，子类。

(2)Classl包括属性fieldl和field2，方法methodl和method2；Class2包括自身定义的属性fieldChildl和自身定义的方法methodChildl，以及它从父类继承来的属性与方法(本题中包括父类的所有属性和方法)。 62、阅读下面的程序片段并回答问题。 class Classl {

int fieldl；

private int field2； void methodl() {

System.out.println(?我是Classl的第一个方法?)； }

void method2() {

System.out.pdntln(?我是Classl的第二个方法?)； } }

- 8 -

class Class2 extends Classl {

int fieldChildl； int fieldl；

void methodChildl() {

System.out.pnntln(?我是Class2的第一个方法?)； }

void methodl() {

System.out.println(?我是Class2的第二个方法?)； }

}

（1）C1assl被称为是C1ass2的什么? C1ass2被称为是C1assl的什么? (2)Classl有哪些方法和属性？Class2有哪些方法和属性？其中哪些与C1assl的方法和属性有关，是什么关系?

答：（1）父类，子类。

(2)Classl包括属性fieldl和field2，方法methodl和method2；Class2包括自身定义的属性fieldChildl和fieldl以及从父类继承的属性fieldl，方法包括Class2自身定义的methodChildl和methodl及其从父类继承的method2。 63、说明下面两个程序片段中，parent类与child类之间的关系有何不同？分别是什么?

（1）class parent {

int fieldl； }

class child extends parent {

int fieldChild； }

(2)class child {

int fieldChild； }

class parent {

child myChild；

- 9 -

}

答：（1）两个类是继承关系。 （2）两个类是包含关系。

64、阅读下面的程序，说明其中的关键字this和super代表了谁？起到什么作用?

class Parent {

void printMe() {

System.out.pnntln(?I am parent!?)； } }

class Child extends Parent {

void printMe() {

System.out.println(?I am child！?)； }

void printAll() {

super.printMe()； this.printMe()； printMe()； }

}

答：super代表了父类对象，this代表了当前对象，使用super特指调用当前对象有直接父类对象的方法。使用this特指调用当前对象自身的方法。 65、Java中最基础的类库是什么？谁是所有类的根类？做算术运算应该使用什么类？

答：Java中最基础的类库是java.lang；Object类是所有类的根类；做算术运算应该使用Math类。

66、Applet的哪个方法仅在开始时执行一次？哪个方法在用户每次访问包含Applet的HTML文件时都被调用？Applet的哪个方法可以用来在其中画图？Applet的哪个方法可以自动调用前面的一个方法？哪个方法用来更新Applet的画面？哪个方法在用户离开Applet所在的HTML页面时被调用?

答：init方法仅在开始时执行一次;start方法在用户每次访问包含Applet的HTML文件时都被调用;paint方法可以用来在其中画图;repaint方法可以自动调用前面的一个方法;update方法用来更新Applet的画面;stop方法在用户离开

- 10 -

三、判断题 1、如果类里定义了一个或多个构造方法，那么Java不提供默认的构造方法。（√） 2、如果定义的类中没有给出构造方法，系统也不会提供构造方法。（╳） 系统给出与类同名的构造方法。 3、可以通过类名直接访问类变量。（√）

4、实例方法既能被对象调用，又能用类名直接调用。（╳） 实例方法只能通过对象来调用。

5、类方法既能被对象调用，又能用类名直接调用。（√） 6、一个类的所有对象共享类变量。（√）

7、类体的内容由两部分组成，一部分是变量的定义，一部分是方法的定义。（√） 8、方法的定义由两部分组成，方法的声明和方法体。（√） 9、Java类的继承允许一个子类可以有多个父类。（╳） Java只允许单重继承。

10、多态性就是指父类的某个方法被其子类重写时，可以各自产生自己的功能行为。（√）

11、Java不允许使用int型变量指定数组的大小。（╳）

与C语言不同，Java允许使用int型变量指定数组的大小。

12、容器本身也是一个组件，因此，可以把一个容器添加到另一个容器中实现容器的嵌套。（√）

13、Java Applet小程序必须由浏览器来运行。（√）

14、文本框(TextField类的对象)和文本区（textArea类的对象）的不同之处是二者对事件的处理不同。（╳）

二者的文本处理方式与方法也不同。

15、文本区（textArea类）的方法setText(String s)和append（String s）的功能是相同的。（╳）

SetText(String s)方法将在文本区中重写文本s并覆盖原先的文本，而append(String s)只是在文本区尾部追加文本s。 16、标签的功能只是显示文本,不能动态地编辑文本。（√） 17、Panel类的实例及它的子类的实例都是容器。（√） 18、Canvas类的实例及它的子类的实例都是容器。（╳） Canvas画布，可在其中绘画，不是容器类。

19、一个容器设臵布局的方法是setLayout(布局对象)。（√） 20、BorderLayout布局是将容器设臵成上、中、下三个区域。（╳） 该布局是将容器设臵成东、南、西、北、中五个区域。

21、用GridLayout布局的容器调用add方法将组件加入到容器中时，可以直接设定在某个网格单元中添加组件。（╳） 只能按网格顺序添加组件。

22、Java Applet小程序类及其子类所创建的对象默认的布局是BorderLayout。

- 16 -

（╳）

是FlowLayout布局。

23、Panel类及其子类所创建的对象默认的布局是FlowLayout。（√） 24、Frame类及其子类所创建的对象默认的布局是BorderLayout。（√） 25、Dialog类及其子类所创建的对象默认的布局是FlowLayout。（╳） 是BorderLayout布局。

26、选择框Checkbox类的方法setState(boolean b)只能将选择框设臵成选中状态。（╳）

参数b为false为未选中状态。

27、下拉列表Choice类的方法select(int index)可以把下拉列表中索引值是index的选项设臵成选中状态。（√）

28、组件调用方法setSize(int w,int h)可以设臵组件的大小。（√） 29、组件调用方法setLocation(int x,int y)可以设臵组件在容器中的位臵。（√） 30、组件调用方法setBounds(int x,int y,int w,int h)可以设臵组件在容器中的位臵和组件的大小。（√）

31、组件调用方法setBackground(Color c)可以设臵组件上的字体的颜色。（╳） 是设臵组件背景颜色。

32、组件调用repaint()方法时，会自动调用update()方法，而update()方法的功能是清除paint()以前所画的内容。（√）

33、将菜单条放在窗口上的方法是setMenuBar(MenuBar bar)。（√） 34、菜单放在菜单条里，菜单项放在菜单里。（√） 35、Menu 是MenuItem的子类。（√）

36、对话框必须要依赖于某个窗口或组件。（√）

37、有模式对话框处于激活状态时，程序仍能激活它所依赖的窗口或组件。（╳） 按有模式对话框定义，不能激活其依赖的窗口。 38、进程是程序的一次动态执行过程。（√）

39、一个进程在其执行过程中，可以产生多个线程。（√）

40、Java中编程实现多线程应用有两个途径：一种是用Thread类的子类创建线程，另一种是用Thread类创建线程。（√）

41、用Thread类创建线程时，创建目标对象的类必须实现Runnable方法。（√） 42、FileInputStream使用字节流读取文件，而FileReader使用字符流读取文件。（√）

43、RandomAccessFile类创建的流既可以作为源也可以作为目地的。（√） 44、客户端和服务器端呼叫的端口号必须相同。（√）

45、Java程序是由若干类定义组成的，类定义包括定义类头和定义类体。（√） 46、一个Java类可以有一个父类，并实现多个接口。（√）

47、如果try块中没有语句产生异常，则在执行完try块中的全部语句后，再进入try块后面的catch块。（╳） 不产生异常就不进入catch块。

- 17 -

48个try块都必须有至少一个catch块与之对应，当一个try块有多个catch块与之对应时，应该把参数为父类异常对象的catch块排在后面。（√） 49、Java中画圆和画椭圆使用的是相同的方法。（√）

50、调用画矩形方法需要给出的是矩形左上角和右下角的坐标。（╳） 给出左上角座标及矩形有长度和宽度。

51、在Applet中，绘制图形的语句不一定写在paint方法里，但是需要paint方法把其Graphics对象参数g传递给这个用户自己的绘图方法。（√）

52、在Applet中显示一幅图像，首先要把它调入内存，保存在一个Image对象中，然后调用drawImage()方法画出这个图像。（√）

53、用setVisible(false)方法可以使组件隐藏不可见，但是一旦隐藏便不能恢复显示。（╳）

可用setVisible(true)恢复可见。

54、Label、TextField和TextArea对象都拥有方法setText()，用来设臵其中的文本内容。（√）

55、对于一个Button对象，可以调用方法getLabel()获取其上的标签，从而判断是哪个按钮。（√）

56、一个Checkbox对象既可以作为一个复选按钮，也可以作为一个单选按钮组中的一个按钮。（√）

57、一个复选按钮实现的是?二选一?的结构，一个单选按钮组实现的是?多选一?的结构。（√）

58、List对象可以实现?多选一?结构，也可以实现?多选多?结构，完全由创建List对象时的参数确定。（√）

59、所有的鼠标事件都由实现了MouseListener监听接口的监听者来处理。（╳） 鼠标移动等由MouseMotionListener接口监听处理。

60、当用户鼠标移入Applet的区域范围时触发mouseEnter()方法，当用户鼠标移出Applet的区域范围时触发mouseExit()方法。（√）

61、调用KeyEvent对象的方法getKeyChar()可以获得用户操作的键盘按键的字符值，调用getKeyText()可以获得用户操作的一些特殊字符，例如?F3?等。（√） 62、鼠标点击在屏幕上任何位臵处，都可以激活mouseClicked()方法。（╳） 只在对鼠标事件监听的区域内可以。

63、使用BorderLayout的容器最多只能放臵5个组件，如果要放臵更多的组件，则需要使用多层容器。（√）

64、使用BorderLayout和GridLayout布局策略的容器，其中的所有空间都被组件占满，没有任何空隙。（╳）

组件间可以设臵横向和纵向空隙。

65、使用GridLayout布局策略的容器中，所有的组件都有相同大小。（√） 66、一个容器中可以混合使用多种布局策略。（√）

67、可以使用append()方法把一个字符串添加到一个TextField中原有字符串的后面。（√）

- 18 -

68、Canvas对象外观类似于Panel对象，也可以产生鼠标事件；但是它不是容器，不能在其中添加其它的组件；它拥有paint(Graphics g)方法，所以可以在其上画图。（√）

69、新创建的Frame窗框对象，会自动显示在屏幕上。（╳） 必须用setVisible(true)方法才能显示在屏幕上。

70、使用add()方法可以向容器中添加组件，使用remove（）方法可以将组件从容器中移出。（√）

71、Menu对象中只能加入MenuItem对象。（╳） 还可以加入Menu对象，以便设臵子菜单。 72、设一个窗口中包含一个按钮，当用户点击该按钮时会弹出一个无模式对话框，则当窗口关闭时该对话框也随之关闭。（√） 73、MenuItem也可以添加到MenuBar上。（╳） 只能添加到Menu上。

74、利用File对象不但可以判断一个文件或目录是否存在、是否可读可写、是否是文件、是否是目录，而且可以执行创建子目录、列举目录中的文件、获得文件长度、删除文件、修改文件名字等操作。（√）

75、打开一个文件输入输出流不需使用try-catch结构。（╳） 打开文件必须使用try-catch结构。

76、一个线程对象的具体操作是由run()方法的内容确定的，但是Thread类的run0方法是空的，其中没有内容；所以用户程序要么派生一个Thread的子类并在子类里重新定义run() 方法，要么使一个类实现Runnable接口并书写其中run()方法的方法体。（√）

77、下面的语句将线程对象mt的优先级设臵为12：mt.setPriority(12)；（√） 78、某程序中的主类不是Thread的子类，也没有实现Runnable接口，则这个主类运行时不能控制主线程睡眠。（╳）

79、sleep()和wait()方法都使当前运行线程放弃处理器和它所占用的同步资源管理。（╳）

sleep（）方法是，而wait()方法不是。

80、挂起、阻塞或等待的线程都能够恢复运行，但是停止运行的线程将不可能再复生。（√）

- 19 -

四、写出下列程序或程序片段的运行结果1、

public class E1 {

public static void main(String args[]) {

int sum=0;

for(int k=1;k<=10;k++) {

sum=sum+k; }

System.out.println(?sum=?+sum); } }

答：运行结果是 sum=55 2、

import java.awt.*; public class E2 {

public static void main(String args[]) {

int p=1;

for(int k=1;k<=5;k++) {

p=p*k; }

System.out,println(?p=?+p); } }

答：运行结果是 p=120 3、

public class Class1 {

public static void main (String[] args)

- 20 -

}

{ }

int a[]={23,67,11,40,15}; int b[]={47,23,29,10,15}; int c[]={1,1,1,1,1};

for(int i=0;i

for(int i=0;i

System.out.print(c[i]+\System.out.println();

答：运行结果：70，90，40，50，30，

4、

import java.util.*; public class E1 {

public static void main(String args[]) {

String s=?I am Wanglin,she is my friend,she is a student?; StringTokenizer fenxi=new StringTokenizer(s,? ,?); int n=fenxi.countTokens(); while(fenxi.hasMoreTokens()) {

String s1=fenxi.nextToken(); System.out.print(s1+? ?); }

System.out.println();

System.out.println(?count=?+n); } }

答：运行结果：I am Wanglin she is my friend she is a student count=11

5、int i;

- 21 -

for(i=0;i<5;i++) {

if(i==3) break;

System.out.print(i); }

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

答：运行结果：0 1 2 i=3 6、int i;

for(i=0;i<5;i++) {

if(i==3) continue;

System.out.print(i); }

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

答：运行结果：0 1 2 4 i=5

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

for(int j=0;j<3;j++) {

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

System.out.print(’*’); System.out.println(); }

System.out.println(); }

答：运行结果：********** ********** **********

********** ********** **********

8、public class UseRef

- 22 -

{

public static void main(String args[]) {

MyClass1 myobj,myref; myobj=new MyClass1(-1); myref=myobj;

System.out.println(?the original data is:?+myobj.getData()); myref.setData(10);

System.out.println(?now the data is:?+myobj.getData()); }

}

class MyClass1 {

int data;

MyClass1(int d) {

data=d;

}

int getData() {

return data; }

void setData(int d) {

data=d; } }

答：运行结果为：the original data is :-1 now the data is:10

9、 class Parent {

void printMe() {

System.out.println(?I am parent!?)； } }

class Child extends Parent

- 23 -

{

void printMe() {

System.out.println(?I am child!?)； }

void printAll() {

super.printMe()； this.printMe();

printMe()；

} }

public class Test_this {

public static void main(String args[]) {

Child myC=new Child()； myC.printAll()； }

}

答：运行结果为: I am parent! I am child! I am child!

10、public static void main(String args[])

{

int array[]={1,2,3,4,5}; printArray(array); could_modify(array); printArray(array)；

}

static void could_modify(int a[]) {

for(int i=0;i

static void printArray(int a[]) {

- 24 -

for(int i=0；i

}

答：运行结果为：1 2 3 4 5 0 2 6 12 20

11、public static void main(String args[]) {

char a[][]=new char[3][3]; for(int i=0;i

for(int j=0;j=j)

a[i][j]=’*’; else

a[i][j]=’’;

for(int i=0;i

for(int j=0;j

}

答：运行结果为：* * * * * *

12、public static void main(String arg[]) {

int array[]=new int[10]； for(int i=0;i<10;i++) array[i]=i+1;

System.out.println(sum(array,array.length))； }

static int sum(int a[],int n) {

if (n>1)

- 25 -

return a[n-1]+sum(a,n-1)； else

return a[0]；

}

答：运行结果为：55

13、public class CreateString

{

public static void main(String args[]) {

char cArray[]={‘一’,’路’,’顺’,’风’,’！’}; String sArray[]=new String[7];

StringBuffer sb=new StringBuffer(?很高兴见到您！?); String s=?别来无恙？?; sArray[0]=new String(s); sArray[1]=new String();

sArray[2]=new String(?节日快乐！?); sArray[3]=new String(cArray);

sArray[4]=new String(cArray,2,3); sArray[5]=new String(sb);

for(int i=0;i

答：运行结果为：别来无恙？ 节日快乐！ 一路顺风！ 顺风！

很高兴见到您！ Null 14、class Student

{

int number; String name;

Student(int number,String name) {

this.number=number;

- 26 -

this.name=name;

System.out.println(\ } }

class Univer_Student extends Student {

boolean 婚否;

Univer_Student(int number,String name,boolean b) {

super(number,name); 婚否=b;

System.out.println(\婚否=\婚否); } }

public class Class1 {

public static void main (String[] args) throws java.io.IOException {

int i;

Univer_Student zhang=new Univer_Student(5144,\李晓红\ i=System.in.read(); } }

答：运行结果为：I am 李晓红 my number is 5144 婚否=false

15、class Sum

{

int n; float f() {

float sum=0;

for(int i=1;i<=n;i++) sum=sum+i; return sum; }

}

- 27 -

class Average extends Sum {

int n; float f() {

float c; super.n=n; c=super.f(); return c/n; }

float g() {

float c;

c=super.f(); return c/2;

} }

public class Class1 {

public static void main (String[] args) throws java.io.IOException {

Average aver=new Average(); aver.n=100;

float result_1=aver.f(); float result_2=aver.g();

System.out.println(\ System.out.println(\ int i;

i=System.in.read();

} }

答：运行结果为：result_1=50.50 result_2=2525.0

16、

class Student {

- 28 -

float math,english,sum; float f(float k1,float k2) {

sum=k1*math+k2*english; return sum; } }

public class Average {

Student wanghong,lihong;

public static void main(String args[]) {

wanghong=new Student(); lihong=new Student(); wanghong.math=60.0f; wanghong.english=80f; lihong.math=70.0f; lihong.english=90.0f;

wanghong.sum=wanghong.f(2.0f,2.0f); lihong.sum=lihong.f(2.0f,2.0f);

System.out.println(\

System.out.println(\ } }

答：运行结果为：lihong sum=320.0 wanghong sum=280.0

17、

import java.awt.*; class Chengji {

float f(float x,float y) {

return x*y; } }

class Xiangjia extends Chengji {

- 29 -

//重写父类的f方法

float f(float x,float y) {

return x+y; } }

public class Class1 {

Xiangjia sum;

public static void main(String args[]) {

sum=new Xiangjia();

System.out.println(\

//此处对象sum是调用自已的方法f,得到两数的和. } }

答：运行结果为：sum=10.0

18、

public class Class1 {

float a[];

public static void main(String args[]) {

a=new float[5]; a[0]=23.9f; a[1]=34.9f; a[2]=45f; a[3]=56.98f; a[4]=100f;

System.out.println (\ System.out.println (\ System.out.println (\ System.out.println (\ System.out.println (\ } }

- 30 -

答：运行结果为： a[0]=23.9 a[1]=34.9 a[2]=45.0 a[3]=56.98 a[4]=100.0

19、

public class Class1 {

String tom=\ int x,y,z;

public static void main(String args[]) {

x=tom.indexOf(\

y=tom.indexOf(\ z=tom.indexOf(\ g.setColor(Color.red);

System.out.println(\ } }

答：运行结果为：2:7:13

20、

public class Class1 {

String jerry=\

public static void main(String args[]) {

s1=jerry.substring(2); s2=jerry.substring(2,5); g.setColor(Color.blue); System.out.println (s1); System.out.println (s2);

System.out.println (jerry.substring(jerry.indexOf(\ } }

答：运行结果为：love Tom

- 31 -

lov

love Tom

21、

import java.util.*; import java.awt.*; public class Class1 {

public static void main (String[] args) throws java.io.IOException {

String s1=\ String s2=\

StringTokenizer fenxi_1=new StringTokenizer(s1,\空格和逗号做分隔符

StringTokenizer fenxi_2=new StringTokenizer(s2,\空格和问号做分隔符

int n1=fenxi_1.countTokens(); int n2=fenxi_2.countTokens(); while(fenxi_1.hasMoreTokens()) {

String s=fenxi_1.nextToken(); System.out.print(s+? ?); }

System.out.println();

System.out.println(\有单词:\个\ while(fenxi_2.hasMoreTokens()) {

String s=fenxi_2.nextToken(); System.out.print(s+? ?); }

System.out.println();

System.out.println(\有单词:\个\ int i;

i=System.in.read(); } }

答：运行结果为：I am Geng.X.Y she is my girlfriend s1有单词：7个

- 32 -

Lowood what is that S2有单词：4个

- 33 -

五、程序填空，使之满足要完成的功能

1、下面的小程序中，有一个在文本框，在其内输入完字符并按回车键后，文本框内就会显示?欢迎您?的字符串，填空完成该功能。 import java.applet.*; import java.awt.*;

import java.awt.event.*;

public class Applet1 extends Applet implements ____________________ {

TextField text; public void init()

{

text=new TextField(20); add(text);

text.________________________________; //此处填写事件监听 }

public void _______________________________//此处填写事件处理方法 {

if(e.getSource()==text)

__________________________________; } }

答：ActionListener

addActionListener(this)

actionPerformed(ActionEvent e) text.setText(?欢迎您?)

2、下面的小程序中，有两个文本区，当在第一个文本区中输入文本时，第二个文本区会与第一个文本区同步显示相同的内容。 import java.awt.*; import java.applet.*; import java.awt.event.*;

public class Applet1 extends______________ implements____________ {

TextArea text1,text2; public void init() {

text1=new TextArea(\

- 34 -

text2=new TextArea(\ add(text1); add(text2);

______________________________;//此处填加事件监听 }

public void ______________________________//接口中的方法 {

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

text2.setText(text1.getText()); } } }

答：Applet

TextListener

text1.addTextListener(this); textValueChanged(TextEvent e)

3、用BordereLayout布局实现下图的效果，其中?东?和?西?两个是按钮，?上北?和?下南?是标签，中间是一个文本区域。

答：程序如下

import java.applet.*; import java.awt.*;

public class Applet1 extends Applet {

Button button1,button2; Label label1,label2; TextArea text;

public void init()

- 35 -

本文来源：https://www.bwwdw.com/article/37c7.html