Java试卷B

单选择题解答：

  1. 编译 Java Application 源程序文件将产生相应的字节码文件，这些字节码文件的扩展名为（B）。

    • A. .java
    • B. .class （正确答案）
    • C. .html
    • D. .exe

    解释：Java 源文件编译后生成的文件扩展名是 .class，这些文件包含 JVM 可以执行的字节码。

  2. 设 x = 1 , y = 2 , z = 3，则表达式 y += z-- / ++x 的值是（A）。

    • A. 3 （正确答案）
    • B. 3.5
    • C. 4
    • D. 5

    解释：首先，++x 将 x 变为 2，然后 z-- 使用 z 的值 3 进行计算，之后 z 变为 2。y += z-- / ++x 变为 y += 3 / 2，即 y = 2 + 1 = 3。

  3. 在 Java Applet 程序用户自定义的 Applet 子类中，一般需要重载父类的（D）方法来完成一些画图操作。

    • A. start()
    • B. stop()
    • C. init()
    • D. paint() （正确答案）

    解释：paint() 方法是用于在 Applet 中进行绘图操作的，因此需要重载这个方法来完成自定义绘图。

  4. 不允许作为类及类成员的访问控制符的是（C）。

    • A. public
    • B. private
    • C. static （正确答案）
    • D. protected

    解释：static 不是访问控制符，它是一个修饰符，用来标识类的成员属于类本身，而不是实例。public、private 和 protected 是访问控制符，控制类及成员的访问权限。

  5. 为 AB 类的一个无形式参数无返回值的方法 method 书写方法头，使得使用类名 AB 作为前缀就可以调用它，该方法头的形式为（A）。

    • A. static void method() （正确答案）
    • B. public void method()
    • C. final void method()
    • D. abstract void method()

    解释：静态方法可以使用类名作为前缀调用，因此方法需要声明为 static。

填空题解答：

  1. 开发与运行 Java 程序需要经过的三个主要步骤为：

    • 编辑源程序
    • 编译生成字节码
    • 解释运行字节码

  2. 如果一个 Java Applet 源程序文件只定义有一个类，该类的类名为 MyApplet，则类 MyApplet 必须是：

    • Applet 类的子类
    • 存储该源程序文件的文件名为 MyApplet.java

  3. 如果一个 Java Applet 程序文件中定义有 3 个类，则使用 Sun 公司的 JDK 编译器 javac.exe 编译该源程序文件将产生：

    • 3 个文件名与类名相同而扩展名为 .class 的字节码文件

  4. 在 Java 的基本数据类型中，char 型采用 Unicode 编码方案，每个 Unicode 码占用：

    • 2 字节内存空间， 这样，无论是中文字符还是英文字符，都是占用 2 字节内存空间。

  5. 设 x = 2 ，则表达式 (x++)／3 的值是：

    • 0

  6. 若 x = 5，y = 10，则 x < y 和 x >= y 的逻辑值分别为：

    • true
    • false

  7. 抽象 (abstract) 方法是一种仅有方法头，没有具体方法体和操作实现的方法，该方法必须在抽象类之中定义。最终 (final) 方法是不能被当前类的子类重新定义的方法。

  8. 创建一个名为 MyPackage 的包的语句是：

    • package MyPackage; 该语句应该放在程序的位置为：
    • 程序的第一句

  9. 设有数组定义：int MyIntArray[] = {10, 20, 30, 40, 50, 60, 70}; 则执行以下几个语句后的输出结果是：

    • 120
    1
    2
    3
    4
    5
    6
    int s = 0;
    for (int i = 0; i < MyIntArray.length; i++) {
        if (i % 2 == 1) 
            s += MyIntArray[i];
    }
    System.out.println(s);

    解释：在这个循环中，i % 2 == 1 的条件是 i 为奇数，符合条件的数组元素是 20、40、60，累加结果为 120。

  10. 在 Java 程序中，通过类的定义只能实现：

    • 单重继承， 但通过接口的定义可以实现：
    • 多重继承关系。

程序功能说明

1. 程序功能：

1
2
3
4
5
6
7
8
9
public class Sum {
    public static void main(String args[]) {
        double sum = 0.0;
        for (int i = 1; i <= 100; i++) {
            sum += 1.0 / (double) i;
        }
        System.out.println("sum=" + sum);
    }
}

功能说明：
该程序计算并输出前 100 个倒数之和，即： $ = + + + + $ 最后打印出结果。

2. 程序功能：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import java.io.*;

public class Reverse {
    public static void main(String args[]) {
        int i, n = 10;
        int a[] = new int[10];
        for (i = 0; i < n; i++) {
            try {
                BufferedReader br = new BufferedReader(
                        new InputStreamReader(System.in));
                a[i] = Integer.parseInt(br.readLine()); // 输入一个整数
            } catch (IOException e) {
            }
        }
        for (i = n - 1; i >= 0; i--)
            System.out.print(a[i] + " ");
        System.out.println();
    }
}

功能说明：
该程序从键盘输入 10 个整数，然后将这些整数以倒序的方式输出。例如，若输入的顺序是 1 2 3 ... 10，输出的结果为 10 9 8 ... 1。

3. 程序功能：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import java.awt.*;

public class abc {
    public static void main(String args[]) {
        new FrameOut();
    }
}

class FrameOut extends Frame {  // Frame 为系统定义的窗框类
    Button btn;

    FrameOut() {
        super("按钮");
        btn = new Button("按下我");
        setLayout(new FlowLayout());
        add(btn);
        setSize(300, 200);
        show();
    }
}

功能说明：
该程序创建了一个简单的 GUI 窗口，其中有一个按钮。窗口标题为“按钮”，按钮上显示文字“按下我”，窗口大小为 300x200 像素，并以 FlowLayout 布局显示。

4. 程序功能：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import java.io.*;

public class abc {
    public static void main(String args[]) {
        SubClass sb = new SubClass();
        System.out.println(sb.max());
    }
}

class SuperClass {
    int a = 10, b = 20;
}

class SubClass extends SuperClass {
    int max() {
        return ((a > b) ? a : b);
    }
}

功能说明：
该程序通过继承机制比较父类 SuperClass 中的两个整数 a 和 b 的大小，并返回较大的值。结果输出较大的数，即 b 的值 20。

程序功能及运行结果

1. 程序功能及运行结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import java.io.*;

public class abc {
    public static void main(String args[]) {
        AB s = new AB("Hello!", "I love JAVA.");
        System.out.println(s.toString());
    }
}

class AB {
    String s1;
    String s2;

    AB(String str1, String str2) {
        s1 = str1;
        s2 = str2;
    }

    public String toString() {
        return s1 + s2;
    }
}

功能说明：
该程序定义了一个类 AB，该类有两个成员字符串 s1 和 s2。在构造函数中通过参数初始化这两个字符串。toString() 方法返回 s1 和 s2 拼接后的字符串。main 方法中，创建了一个 AB 类的对象，并调用其 toString() 方法输出结果。

输出结果：

1
Hello!I love JAVA.

2. 程序功能及运行结果：

1
2
3
4
5
6
7
8
9
10
11
import java.io.*;

public class abc {
    public static void main(String args[]) {
        int i, s = 0;
        int a[] = {10, 20, 30, 40, 50, 60, 70, 80, 90};
        for (i = 0; i < a.length; i++)
            if (a[i] % 3 == 0) s += a[i];
        System.out.println("s=" + s);
    }
}

功能说明：
该程序定义了一个数组 a[]，并通过 for 循环遍历数组元素。程序检查每个元素是否能被 3 整除，如果可以，则将该元素加到 s 中，最终输出 s 的值。

计算过程：

  • 数组中可以被 3 整除的元素有：30, 60, 90
  • 它们的和：30 + 60 + 90 = 180

输出结果：

1
s=180

3. 程序功能及运行结果：

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
import java.io.*;

public class abc {
    public static void main(String args[]) {
        SubSubClass obj = new SubSubClass(10, 20, 30);
        obj.show();
    }
}

class SuperClass {
    int a, b;

    SuperClass(int aa, int bb) {
        a = aa;
        b = bb;
    }
}

class SubClass extends SuperClass {
    int c;

    SubClass(int aa, int bb, int cc) {
        super(aa, bb);
        c = cc;
    }
}

class SubSubClass extends SubClass {
    int a;

    SubSubClass(int aa, int bb, int cc) {
        super(aa, bb, cc);
        a = aa + bb + cc;
    }

    void show() {
        System.out.println("a=" + a + "\nb=" + b + "\nc=" + c);
    }
}

功能说明：
该程序通过继承关系创建了三个类：SuperClass、SubClass 和 SubSubClass。在 SubSubClass 类中，a 被重新定义，并通过 aa + bb + cc 计算新值。show() 方法打印三个成员变量的值。

计算过程：

  • 创建 SubSubClass 对象时，传递的参数为 10, 20, 30
  • SuperClass 的构造函数初始化 a = 10, b = 20
  • SubClass 的构造函数初始化 c = 30
  • SubSubClass 的 a = 10 + 20 + 30 = 60

输出结果：

1
2
3
a=60
b=20
c=30

1. 编写字符界面的 Java 应用程序，接受用户输入的10个整数，并输出最大值和最小值。

问题分析：
程序要求通过控制台输入10个整数，并计算这10个整数中的最大值和最小值。实现方式是通过 BufferedReader 读取输入，并在读取每个数字时，更新最大值和最小值。

解答代码：

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
import java.io.*;

public class MaxMinFinder {
    public static void main(String[] args) {
        int n = 10;
        int max = 0, min = 0, temp = 0;

        try {
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

            // 读取第一个数字并初始化max和min
            System.out.println("请输入第1个整数：");
            max = min = Integer.parseInt(br.readLine());

            // 继续读取剩下的9个数字
            for (int i = 2; i <= n; i++) {
                System.out.println("请输入第" + i + "个整数：");
                temp = Integer.parseInt(br.readLine());

                // 更新max和min
                if (temp > max) {
                    max = temp;
                }
                if (temp < min) {
                    min = temp;
                }
            }

        } catch (IOException e) {
            e.printStackTrace();
        }

        System.out.println("最大值 = " + max);
        System.out.println("最小值 = " + min);
    }
}

输出说明：

  • 程序将要求用户输入10个整数，并在每次输入后根据当前的数字更新最大值和最小值。
  • 输出的结果为输入的最大值和最小值。

2. 编写 Java Applet 程序，使用 Complex 类验证两个复数相加的结果。

问题分析：
程序要求定义一个 Complex 类来表示复数，并实现复数相加的方法。两个复数 1 + 2i 和 3 + 4i 相加的结果应该是 4 + 6i。通过 Applet 界面展示结果。

解答代码：

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
import java.applet.Applet;
import java.awt.Graphics;

public class ComplexApplet extends Applet {
    Complex a, b, c;

    public void init() {
        a = new Complex(1, 2); // 第一个复数 1 + 2i
        b = new Complex(3, 4); // 第二个复数 3 + 4i
        c = new Complex();     // 用于保存结果的复数
    }

    public void paint(Graphics g) {
        c = a.complexAdd(b); // 两个复数相加

        g.drawString("第一个复数: " + a.toString(), 10, 50);
        g.drawString("第二个复数: " + b.toString(), 10, 70);
        g.drawString("两复数之和: " + c.toString(), 10, 90);
    }
}

class Complex {
    int RealPart;    // 实部
    int ImaginPart;  // 虚部

    // 无参构造函数，初始化为 0 + 0i
    Complex() {
        RealPart = 0;
        ImaginPart = 0;
    }

    // 带参构造函数，初始化为给定实部和虚部
    Complex(int r, int i) {
        RealPart = r;
        ImaginPart = i;
    }

    // 复数相加方法
    Complex complexAdd(Complex a) {
        Complex temp = new Complex(); // 临时复数对象用于存储结果
        temp.RealPart = this.RealPart + a.RealPart;
        temp.ImaginPart = this.ImaginPart + a.ImaginPart;
        return temp;
    }

    // 返回复数的字符串表示形式，如 "a + bi"
    public String toString() {
        return RealPart + " + " + ImaginPart + "i";
    }
}

运行说明：

  • 初始化 Applet 后，两个复数 1 + 2i 和 3 + 4i 将被相加，并显示在界面上。
  • Complex 类中的 complexAdd() 方法实现了复数相加的功能。
  • paint() 方法通过调用 Graphics 的 drawString() 方法将结果绘制在 Applet 界面上。

输出示例：

  • 第一个复数: 1 + 2i
  • 第二个复数: 3 + 4i
  • 两复数之和: 4 + 6i

总结：

  • 第一个程序通过控制台读取用户输入的10个整数并找出最大值和最小值。
  • 第二个程序通过 Java Applet 界面展示两个复数相加的结果，使用 Complex 类实现复数的表示和运算。