《JAVA语言程序设计》期末考试试题及答案3（应考必备题库）

选择题

1. 如下哪个是 Java 中的标识符？

选项：

  • A. public
  • B. super
  • C. 3number
  • D. width

答案： D. width

解释： Java 标识符必须以字母、下划线或美元符号 ($) 开头，且不能以数字开头。选项 A、B、C 都不是有效的标识符。public 和 super 是关键字，3number 以数字开头不符合标识符规则。width 是有效的标识符。

2. 如下哪个是 Java 中的标识符？

选项：

  • A. fieldname
  • B. super
  • C. 3number
  • D. #number

答案： A. fieldname

解释： fieldname 符合 Java 标识符的命名规则，其他选项要么是关键字（如 super），要么含有非法字符（如 # 和数字开头）。

3. 已知如下定义：String s = "story"; 下面哪个语句不是合法的？

选项：

  • A. s += "books";
  • B. s = s + 100;
  • C. int len = s.length;
  • D. String t = s + "abc";

答案： C. int len = s.length;

解释： s.length 应该写作 s.length()，因为 length 是字符串对象的一个方法，而不是一个属性。选项 C 缺少方法调用的圆括号。

4. 如下哪个是 Java 中有效的关键字？

选项：

  • A. name
  • B. hello
  • C. false
  • D. good

答案： C. false

解释： false 是 Java 中的关键字，表示布尔值 false。name、hello 和 good 不是 Java 的关键字。

5. 下面的代码段执行之后 count 的值是什么？

1
2
3
4
5
int count = 1;
for (int i = 1; i <= 5; i++) {
    count += i;
}
System.out.println(count);

选项：

  • A. 5
  • B. 1
  • C. 15
  • D. 16

答案： D. 16

解释： 初始值 count = 1。在循环中，count 会逐步增加。循环会执行 5 次，每次将 i 加到 count 上。具体计算过程如下：

  • 第一次：count = 1 + 1 = 2
  • 第二次：count = 2 + 2 = 4
  • 第三次：count = 4 + 3 = 7
  • 第四次：count = 7 + 4 = 11
  • 第五次：count = 11 + 5 = 16

所以最终 count 的值是 16。

6. 定义一个类，必须使用的关键字是？

选项：

  • A. public
  • B. class
  • C. interface
  • D. static

答案： B. class

解释： 定义一个类必须使用 class 关键字。其他选项是修饰符或与类定义不直接相关的关键字。

7. 定义一个接口必须使用的关键字是？

选项：

  • A. public
  • B. class
  • C. interface
  • D. static

答案： C. interface

解释： 定义接口时，必须使用 interface 关键字。class 用于定义类，static 用于修饰类成员，public 用于修饰访问权限。

8. 如果容器组件 p 的布局是 BorderLayout，则在 p 的下边中添加一个按钮 b，应该使用的语句是？

选项：

  • A. p.add(b);
  • B. p.add(b, "North");
  • C. p.add(b, "South");
  • D. b.add(p, "North");

答案： C. p.add(b, "South");

解释： 在 BorderLayout 布局中，容器的区域包括：North、South、East、West、Center。如果要在容器的下边添加按钮 b，应该使用 p.add(b, "South");。

9. 声明并创建一个按钮对象 b，应该使用的语句是？

选项：

  • A. Button b = new Button();
  • B. button b = new button();
  • C. Button b = new b();
  • D. b.setLabel("确定");

答案： A. Button b = new Button();

解释： 在 Java 中，创建按钮对象应该使用 new Button()，且 Java 是区分大小写的，所以 Button 必须大写。选项 B、C 错误，选项 D 是设置按钮标签的方法，不是创建按钮对象。

10. Frame 对象默认的布局管理器是？

选项：

  • A. FlowLayout
  • B. BorderLayout
  • C. CardLayout
  • D. null

答案： B. BorderLayout

解释： Frame 对象默认的布局管理器是 BorderLayout，它将组件划分为五个区域：North、South、East、West、Center。

11. 下列哪一个 import 命令可以使我们在程序中创建输入/输出流对象？

选项：

  • A. import java.sql.*;
  • B. import java.util.*;
  • C. import java.io.*;
  • D. import java.net.*;

答案： C. import java.io.*;

解释： java.io.* 包含了输入输出流相关的类，包括 FileInputStream、FileOutputStream、BufferedReader、PrintWriter 等，可以用于创建输入/输出流对象。

12. 下面哪一个 import 命令可以为我们提供编写网络应用程序的类？

选项：

  • A. import java.sql.*;
  • B. import java.util.*;
  • C. import java.io.*;
  • D. import java.net.*;

答案： D. import java.net.*;

解释： java.net.* 包含了用于编写网络应用程序的类，如 Socket、URL、URLConnection 等。

13. 如果需要从文件中读取数据，则可以在程序中创建哪一个类的对象？

选项：

  • A. FileInputStream
  • B. FileOutputStream
  • C. DataOutputStream
  • D. FileWriter

答案： A. FileInputStream

解释： FileInputStream 用于从文件中读取数据。FileOutputStream 用于写入数据，DataOutputStream 用于写入基本数据类型，FileWriter 用于写入字符数据。

14. 在编写 Java Applet 程序时，需在程序的开头写上哪个 import 语句？

选项：

  • A. import java.awt.*;
  • B. import java.applet.Applet;
  • C. import java.io.*;
  • D. import java.awt.Graphics;

答案： B. import java.applet.Applet;

解释： 在编写 Java Applet 程序时，需要导入 java.applet.Applet 类，它是创建 Applet 程序的基础。

15. 如何在框架（Frame）中显示标题？

选项：

  • A. 调用根窗格的 setTitle 函数显示
  • B. 调用内容窗格的 setTitle 函数显示
  • C. 调用框架对象的 setTitle 函数显示
  • D. 调用框架对象的 Border 对象的 setTitle 函数显示

答案： C. 调用框架对象的 setTitle 函数显示

解释： setTitle 是 Frame 类的方法，用来设置框架窗口的标题。选项 A、B 和 D 是错误的。

16. 下列各种 Java 中的构造函数定义，哪种形式是错误的构造函数定义？

选项：

  • A. class MyClass { public MyClass() { } }
  • B. class MyClass { public MyClass(int X) { } }
  • C. class MyClass { public int MyClass() { } }
  • D. class MyClass { public MyClass(int x, int y) { } }

答案： C. class MyClass { public int MyClass() { } }

解释： 构造函数没有返回类型。因此选项 C 是错误的，因为构造函数 MyClass() 不应该有 int 返回类型。

17. Java 属于哪种类型的语言？

选项：

  • A. 解释型
  • B. 编译型
  • C. 多线程性
  • D. 安全性

答案： A. 解释型

解释： Java 是一种解释型语言，因为它的字节码由 Java 虚拟机（JVM）解释执行。虽然 Java 也有编译过程，但它运行时需要 JVM 进行解释。

18. 下列哪项不是 Java 语言中所规定的注释样式？

选项：

  • A. // 单行注释
  • B. – 单行注释
  • C. /* ...... */ 注释若干行
  • D. /** …… */ 文档注释

答案： B. – 单行注释

解释： Java 使用 // 表示单行注释，/* ...... */ 表示多行注释，/** …… */ 用于文档注释。选项 B – 不是有效的注释符号。

19. 以下关于抽象类和接口的说法正确的是？

选项：

  • A. 抽象类可以用来定义接口
  • B. 定义抽象类时需要 abstract
  • C. 抽象类中的所有方法都是具体的
  • D. 抽象类可以是对接口的实现

答案： B. 定义抽象类时需要 abstract

解释： 定义抽象类时必须使用 abstract 关键字。选项 A 是错误的，抽象类不能用来定义接口；选项 C 是错误的，抽象类中的方法可以是抽象的，也可以是具体的；选项 D 是错误的，抽象类不能直接实现接口。

20. Applet 可以做下列哪些操作？

选项：

  • A. 读取客户端文件
  • B. 在客户端主机上创建新文件
  • C. 在客户端装载程序库
  • D. 读取客户端部分系统变量

答案： D. 读取客户端部分系统变量

解释： Applet 有一定的安全限制，通常不能直接操作客户端文件系统或创建新文件，但可以读取客户端的部分系统变量。

21. 下列说法中，错误的一项是？

选项：

  • A. 在 Java 中，若要处理某类事件，必须定义相关的事件处理类
  • B. 在对事件源实例化之后，要注册相应事件的监听器
  • C. 事件处理类必须实现与该类事件相对应的监听器接口
  • D. 事件源通常是一个构件，也称做监听器

答案： D. 事件源通常是一个构件，也称做监听器

解释： 事件源是指触发事件的对象，通常是 UI 组件（如按钮、文本框等），而监听器是用来响应事件的对象。选项 D 错误，事件源和监听器是两个不同的概念。

22. 下列哪项是不能改变线程状态的方法？

选项：

  • A. start()
  • B. sleep()
  • C. main()
  • D. stop()

答案： C. main()

解释： main() 是程序的入口点，不是用来改变线程状态的方法。start() 启动线程，sleep() 使线程暂停，stop() 停止线程。

填空题

1. 如果将类 MyClass 声明为 public，它的文件名称必须是（ MyClass.java ）才能正常编译。

答案： 正确

解释： 在 Java 中，如果一个类被声明为 public，那么类的名字必须与文件名完全一致，并且文件扩展名必须是 .java。

2. Java 程序中的单行注释符是（ // ），多行注释符是（ /* */ ）。

答案： 正确

解释： 在 Java 中，// 用于单行注释，/* */ 用于多行注释。文档注释使用 /** */。

3. Java 中布尔类型的常量有两种，它们是（ true ）和（ false ）。

答案： 正确

解释： 在 Java 中，布尔类型（boolean）有两个常量值：true 和 false。

4. Java 中用于定义小数的关键字有两个：（ float ）和（ double ），后者精度高于前者。

答案： 正确

解释： float 和 double 是 Java 中表示浮动小数点数的两种数据类型。double 的精度高于 float，因此 double 能表示更大的数值范围和更高的精度。

5. Java 中用于两个数相等比较的运算符是：（ == ），用于不相等比较的运算符是（ <> ）。

答案： 错误

解释： 在 Java 中，两个数相等比较的运算符是 ==，但是不相等比较的运算符应该是 !=，而不是 <>。<> 是 SQL 中的运算符。

6. 在 Java 中定义一个字符串类型的变量 str 的语句是：（ String str; ） ，定义一个具有 10 个元素的整型数组 a 的语句是：（ int[] arr = new int[10]; ）。

答案： 正确

解释： String str; 用于声明一个字符串类型的变量。int[] arr = new int[10]; 用于声明并初始化一个长度为 10 的整型数组。

7. 导入 mypackage 包中的所有类的命令是（ import mypackage.*; ）。

答案： 正确

解释： import mypackage.*; 用于导入 mypackage 包中的所有类。星号 * 表示导入该包中的所有类。

8. 当声明一个数组 int arr[] = new int[5]; 时，这代表这个数组所保存的变量类型是（ int ），数组名是（ arr ），数组的大小为（ 5 ），数组元素下标的使用范围是（ 0 到 4 ）。

答案： 正确

解释： int arr[] = new int[5]; 创建了一个保存 int 类型元素的数组，数组的大小为 5，因此下标范围是 0 到 4。

9. 假设 x = 13，y = 4，则表达式 x % y != 0 的值是（ true ），其数据类型是（ boolean ）。

答案： 正确

解释： x % y 表示 x 除以 y 的余数，即 13 % 4 等于 1，因为余数不为 0，表达式 x % y != 0 的值为 true，其数据类型是 boolean。

10. 异常处理是由（ try ）、（ catch ）和 finally 块三个关键字组成的程序块。

答案： 正确

解释： Java 中的异常处理通过 try 块来包含可能引发异常的代码，catch 块来捕获和处理异常，finally 块无论异常是否发生都会执行，用于执行清理操作。

11. 以下程序段的输出结果是（三角形）

1
2
3
4
5
int x = 5, y = 6, z = 4;
if (x + y > z && x + z > y && z + y > x)
    System.out.println("三角形");
else
    System.out.println("不是三角形");

答案： 三角形

解释： 该程序判断三个数 x = 5, y = 6, z = 4 是否能组成三角形。三角形的成立条件是任意两边之和大于第三边。在这里，x + y = 11 > 4，x + z = 9 > 6，y + z = 10 > 5，因此可以组成三角形，输出结果是 "三角形"。

12. 下面程序段的执行结果是（6 5 4 3 2）

1
2
3
int a[] = { 2, 3, 4, 5, 6 };
for (int i = a.length - 1; i >= 0; i--)
    System.out.print(a[i] + " ");

答案： 6 5 4 3 2

解释： 数组 a[] 中的元素是 2, 3, 4, 5, 6。i 从 a.length - 1 (即 4) 开始递减，打印数组元素。最终输出是从数组的最后一个元素到第一个元素，结果为 "6 5 4 3 2"。

13. 定义类的保留字是（ class ），定义接口的保留字是（ interface ）。

答案： 正确

解释： 在 Java 中，定义类使用关键字 class，定义接口使用关键字 interface。

14. 构造方法是一种特殊的成员方法，构造方法名与（ 类名 ）相同。

答案： 正确

解释： 构造方法的名字必须与类的名字完全相同，这是构造方法的特性。

15. Java 语言只允许单继承，指每个类只能有一个（ 父类 ），但通过接口的定义可以实现（ 多重 ）继承关系。

答案： 正确

解释： Java 中的类只能继承一个父类，形成单继承。但是，Java 支持通过接口来实现多继承，即一个类可以实现多个接口。

16. 在 Java 中，抽象类不能（ 被实例化 ）。

答案： 正确

解释： 抽象类不能直接实例化。它只能作为其他类的基类，通过继承来实现其抽象方法。

17. 在 Java 中，为了能监视到 ActionEvent 类型的事件，事件源必须使用 addActionListener() 方法获得监视器。

答案： 正确

解释： 为了监听 ActionEvent，事件源（例如按钮）必须调用 addActionListener() 方法来注册监听器。

18. 利用 DriverManager 类的 getConnection(String url) 静态方法创建数据库连接。

答案： 正确

解释： DriverManager.getConnection() 方法用于建立与数据库的连接。url 是数据库的连接地址，通常包括数据库类型、主机、端口等信息。

程序题

1. 以下程序的输出结果是 "Peter is 17 years old!"

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Person {
    String name;
    int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public static void main(String[] args) {
        Person c = new Person("Peter", 17);
        System.out.println(c.name + " is " + c.age + " years old!");
    }
}

答案： Peter is 17 years old!

解释： 该程序创建了一个 Person 类对象 c，其 name 为 "Peter"，age 为 17。System.out.println() 输出 c.name 和 c.age 的值，结果为 "Peter is 17 years old!"。

2. 阅读以下程序，输出结果是 "90and10"

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class ClassA {
    public int a;
}
class ClassB extends ClassA {
    public String b = "and";
}
class ClassC extends ClassB {
    public int c;
    public static void main(String[] args) {
        ClassC cc = new ClassC();
        cc.a = 90;
        cc.c = 10;
        System.out.println(cc.a + cc.b + cc.c);
    }
}

答案： 90and10

解释： ClassC 继承了 ClassB 和 ClassA，在 main 方法中，创建了 ClassC 类的对象 cc。通过 cc.a 访问 ClassA 中的 a 字段，cc.b 访问 ClassB 中的 b 字段，cc.c 访问 ClassC 中的 c 字段。最终输出拼接后的字符串 "90and10"。

3. 以下程序的输出结果为 "课程号:101 课程名:ASP 学分:3"

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class Course {
    private String cNumber;
    private String cName;
    private int cUnit;

    public Course(String number, String name, int unit) {
        cNumber = number;
        cName = name;
        cUnit = unit;
    }

    public void printCourseInfo() {
        System.out.println("课程号:" + cNumber + " 课程名:" + cName + " 学分:" + cUnit);
    }
}

class CourseTest {
    public static void main(String[] args) {
        Course c;
        c = new Course("101", "ASP", 3);
        c.printCourseInfo();
    }
}

答案： 课程号:101 课程名:ASP 学分:3

解释： Course 类的构造方法接收课程号、课程名和学分，存储到相应的成员变量中。调用 printCourseInfo 方法打印课程信息，结果为 "课程号:101 课程名:ASP 学分:3"。

4. 以下程序的输出结果为 "汤姆猫体重：20.0斤"

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class Tom {
    private float weight;
    private static String name;

    public void setWeight(float weight) {
        this.weight = weight;
    }

    private void out() {
        System.out.println(name + "体重：" + weight + "斤");
    }

    public static void main(String[] args) {
        Tom.name = "汤姆猫";
        Tom cat = new Tom();
        cat.setWeight(20);
        cat.out();
    }
}

答案： 汤姆猫体重：20.0斤

解释： Tom 类中 name 是静态变量，可以直接通过类名访问。setWeight() 方法设置体重，out() 方法输出体重和名称。最终输出 "汤姆猫体重：20.0斤"。

5. 以下程序的输出结果是 "姓名:Tom 年龄:15 家庭住址:金水区 电话:66123456 学校：九中"

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
public class Father {
    String name, address, tel;
    int age;

    public Father(String name, int age) {
        this.name = name;
        this.age = age;
    }

    void out() {
        System.out.print("姓名:" + name);
        System.out.print(" 年龄:" + age);
    }

    void outOther() {
        System.out.print(" 家庭住址:" + address);
        System.out.print(" 电话:" + tel);
    }
}

class Son extends Father {
    String school;

    public Son(String name, int age) {
        super(name, age);
    }

    void out() {
        super.out();
        super.outOther();
        System.out.println(" 学校：" + school);
    }

    public static void main(String args[]) {
        Son son = new Son("Tom", 15);
        son.address = "金水区";
        son.school = "九中";
        son.tel = "66123456";
        son.out();
    }
}

答案： 姓名:Tom 年龄:15 家庭住址:金水区 电话:66123456 学校：九中

解释： Son 类继承了 Father 类，调用父类的 out() 和 outOther() 方法，再输出学校信息。最终输出为 "姓名:Tom 年龄:15 家庭住址:金水区 电话:66123456 学校：九中"。

6. 下列程序的运行结果是 "12345"

1
2
3
4
5
6
7
8
9
10
11
12
13
public class MyClass {
    int a[] = { 1, 2, 3, 4, 5 };

    void out() {
        for (int j = 0; j < a.length; j++)
            System.out.print(a[j] + "");
    }

    public static void main(String[] args) {
        MyClass my = new MyClass();
        my.out();
    }
}

答案： 12345

解释： a[] 是一个包含 1 到 5 的整型数组，out() 方法遍历数组并打印每个元素。输出是所有元素拼接在一起，即 "12345"。

简答题

1. 简述Java中异常处理的机制？

答：
Java的异常处理机制是通过对象的方式来管理异常情况。异常处理的核心机制通过 try、catch、throw、throws 和 finally 关键字实现。

  • try：用于包含可能抛出异常的代码块。
  • catch：用于捕获在 try 块中抛出的异常，并进行处理。
  • throw：用于显式地抛出一个异常对象。
  • throws：用于在方法声明中标明该方法可能抛出的异常，调用者需要处理这些异常。
  • finally：无论是否发生异常，finally 块中的代码始终会执行，通常用于资源的释放。

解释：

  • try 块用于编写可能出现异常的代码，catch 块用于处理异常。如果 try 中的代码抛出异常，控制将转到 catch 块。finally 块确保清理工作（如关闭文件流等）始终执行。
  • throw 用于手动抛出异常，throws 用于方法声明，表示该方法可能会抛出某种异常。

2. 什么是继承？

答：
继承是面向对象编程中的一个基本概念，它允许一个类（子类）继承另一个类（父类）的属性和方法，从而实现代码的重用。继承实现了父类和子类之间的层次关系。

  • 父类：被继承的类。
  • 子类：继承父类的类，可以添加新的属性和方法，或者修改继承的方法。
  • 多层继承：子类还可以作为父类，形成更深的继承层次。

解释：
继承机制使得子类可以直接使用父类的公共成员（变量和方法），而不需要重新定义，从而提高了代码的复用性。通过继承，Java 支持单继承关系，一个类只能有一个直接父类，但可以通过接口实现多继承的效果。

3. 请简述重载和重写的区别？

答：

  • 重载（Overloading）：在同一个类中，方法名相同，但参数列表（参数的数量或类型）不同。重载是一个类内的多态表现。
  • 重写（Overriding）：子类重新定义父类中已经存在的方法，并对其进行修改，以满足子类的需求。重写发生在继承关系中，是父类和子类之间的多态表现。

解释：

  • 重载不要求方法的返回类型相同，只要求方法签名（方法名 + 参数列表）不同。重载通常用于实现同一操作的不同方式。
  • 重写要求子类方法与父类方法完全相同（方法签名相同），子类方法可以覆盖父类方法的实现，提供不同的功能。

4. Java规定类中的成员变量和方法具有4种访问控制符？哪四种？请列出。

答：

  • public：公开的，任何类都可以访问。
  • protected：保护的，只有同一包内的类和子类可以访问。
  • private：私有的，只有该类内部可以访问。
  • default（包级访问）：如果没有明确指定访问修饰符，则默认为包级访问，只有同一包中的类可以访问。

解释：
这些访问修饰符控制了类的成员变量和方法的可见性，提供了不同的访问权限，以帮助实现封装和访问控制。

5. 什么是实例变量和类变量及它们的区别？

答：

  • 实例变量：属于类的实例（对象）。每个对象都有自己的实例变量副本，实例变量的值可以在不同对象间不同。
  • 类变量：使用 static 关键字修饰的变量，属于类本身。类变量被所有实例共享，所有对象对类变量的修改都会影响其他对象。

解释：
实例变量属于对象，每创建一个实例，都会为实例变量分配内存空间。类变量属于类，在所有对象中共享，修改类变量的值会影响所有实例。

6. 用abstract修饰符修饰的类和方法有什么特点？

答：

  • abstract类：不能实例化，必须由其子类继承并实现其抽象方法。
  • abstract方法：只声明方法签名，没有方法体。抽象方法必须在子类中实现。

解释：
抽象类是用来表示一个类的共性，但不能直接实例化。它可以包含抽象方法（没有实现）和具体方法（有实现）。子类继承抽象类时，必须实现所有抽象方法，才能创建该类的实例。

编程题

1. 按以下要求编写程序：

  1. 创建一个 Rectangle 类，添加 width 和 height 两个成员变量。
  2. 在 Rectangle 中添加两种方法分别计算矩形的周长和面积。
  3. 编程利用 Rectangle 输出一个矩形的周长和面积。

解答：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public class Rectangle {
    float width, height;

    // 构造方法初始化矩形的宽和高
    public Rectangle(float width, float height) {
        this.width = width;
        this.height = height;
    }

    // 计算矩形的周长
    public float getLength(){
        return (this.width + this.height) * 2;
    }

    // 计算矩形的面积
    public float getArea(){
        return this.width * this.height;
    }

    public static void main(String [] args) {
        // 创建一个矩形对象，宽10，高20
        Rectangle rect = new Rectangle(10, 20);
        // 输出周长和面积
        System.out.println("周长是：" + rect.getLength());
        System.out.println("面积是：" + rect.getArea());
    }
}

解释：

  • Rectangle 类有两个成员变量 width 和 height，分别表示矩形的宽和高。
  • 构造方法用于初始化这两个变量。
  • getLength 方法计算并返回矩形的周长。
  • getArea 方法计算并返回矩形的面积。
  • main 方法创建了一个 Rectangle 对象，并调用 getLength 和 getArea 输出矩形的周长和面积。

2. 按以下要求编写程序：

  1. 编写 Animal 接口，接口中声明 run() 方法。
  2. 定义 Bird 类和 Fish 类实现 Animal 接口。
  3. 编写 Bird 类和 Fish 类的测试程序，并调用其中的 run() 方法。

解答：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public interface Animal {
    void run();
}

class Bird implements Animal {
    public void run() {
        System.out.println("鸟儿在飞...");
    }
}

class Fish implements Animal {
    public void run() {
        System.out.println("鱼儿在游...");
    }
}

public class TestAnimal {
    public static void main(String[] args) {
        // 创建 Bird 对象并调用 run 方法
        Bird bird = new Bird();
        bird.run();
        
        // 创建 Fish 对象并调用 run 方法
        Fish fish = new Fish();
        fish.run();
    }
}

解释：

  • Animal 接口声明了一个 run 方法，任何实现该接口的类都必须提供 run 方法的实现。
  • Bird 和 Fish 类分别实现了 Animal 接口，提供了具体的 run 方法实现。
  • 在 TestAnimal 类的 main 方法中，创建了 Bird 和 Fish 的对象，并分别调用了它们的 run 方法，输出相应的信息。

3. 编写一个 Frame 框架应用程序，要求如下：

  1. 在窗口设置两个菜单“文件”、“编辑”。
  2. 在“文件”菜单里添加三个菜单项“打开”、“保存”、“关闭”。
  3. 在“编辑”菜单里添加两个菜单项“复制”、“粘贴”。
  4. 点击关闭菜单项时，使程序关闭。

解答：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
import java.awt.Color;
import java.awt.Frame;
import java.awt.Menu;
import java.awt.MenuBar;
import java.awt.MenuItem;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

public class MyFrame extends Frame {
    private static final long serialVersionUID = 6895463895656626294L;
    
    private Frame frmMain;
    MenuBar mb;
    Menu mnuFile, mnuEdit;
    MenuItem miOpen, miSave, miClose, miCopy, miPaste;

    public MyFrame() {
        frmMain = new Frame("主窗体");
        mb = new MenuBar();
        mnuFile = new Menu("文件");
        mnuEdit = new Menu("编辑");
        
        miOpen = new MenuItem("打开");
        miSave = new MenuItem("保存");
        miClose = new MenuItem("关闭");
        miCopy = new MenuItem("复制");
        miPaste = new MenuItem("粘贴");
    }

    public void showFrame() {
        frmMain.setSize(800, 600);
        frmMain.setLocation(100, 100);
        frmMain.setBackground(Color.white);
        frmMain.setVisible(true);
        frmMain.setLayout(null);
        frmMain.addWindowListener(new WindowHandler());

        frmMain.setMenuBar(mb);
        mb.add(mnuFile);
        mb.add(mnuEdit);
        mnuFile.add(miOpen);
        mnuFile.add(miSave);
        mnuFile.add(miClose);
        mnuEdit.add(miCopy);
        mnuEdit.add(miPaste);

        miClose.setActionCommand("miClose_Clicked");
        miClose.addActionListener(new MenuHandler());
    }

    private class WindowHandler extends WindowAdapter {
        public void windowClosing(WindowEvent e) {
            System.exit(0);
        }
    }

    private class MenuHandler implements ActionListener {
        public void actionPerformed(ActionEvent e) {
            if (e.getActionCommand().equals("miClose_Clicked")) {
                System.exit(0);
            }
        }
    }
}

public class TestMyFrame {
    public static void main(String[] args) {
        MyFrame guiWindow = new MyFrame();
        guiWindow.showFrame();
    }
}

解释：

  • MyFrame 类继承自 Frame，并创建了菜单栏 MenuBar 和两个菜单 Menu，分别为“文件”和“编辑”。
  • 菜单项包括“打开”、“保存”、“关闭”、“复制”和“粘贴”。
  • 点击“关闭”菜单项时，通过 WindowHandler 内部类的 windowClosing 方法或 MenuHandler 内部类的 actionPerformed 方法触发关闭窗口的操作，调用 System.exit(0) 退出程序。