Java复习题1

《JAVA语言程序设计》期末考试试题及答案

来源：CSDN博客
作者：leah126
发布时间：2026-05-08 23:27:31
原文链接：https://blog.csdn.net/leah126/article/details/155775503

---

📚 目录

• 试题一
• 试题二
• 试题三
• 试题四
• 试题五
• 试题六
• 试题七

---

试题一

一、单选择题

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

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

2. 设 x = 1 , y = 2 , z = 3，则表达式 y＋＝zーー/＋＋x 的值是( A )

   • A. 3 B. 3.5 C. 4 D. 5
   • 解析：z-- 先返回值在运算，返回值是3，z的值变为2；++x 先运算再返回值，x值变2，返回2；3/2 整形数据范围内的计算，返回1；y += 1，y = 3

3. 不允许作为类及类成员的访问控制符的是( C )

   • A. public B. private C. static D. protected

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

   • A. static void method( ) B. public void method( ) C. final void method( ) D. abstract void method( )

5. 给定java代码如下，编译运行后，输出结果是（C）

public class test { 
    static int i; 
    public int aMethod() { 
        i++; 
        return i; 
    } 
    public static void main (String args[]) {    
        Test test=new Test() ;  
        test.aMethod () ; 
        System.out.println (test.aMethod()) ; 
    } 
}   

• a) 0 b) 1 c) 2 d) 3
• 解析：int初始值为0，aMethod调用了两次所以结果为2

6. 如下哪个是合法的Java中的标识符（ A ）

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

7. 下面的代码段执行之后count的值是什么（ D）

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

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

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

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

9. 下列程序段执行后的结果是（A）

String s = new String("abcdefg");
for (int i=0; i<s.length(); i+=2){
    System.out.print(s.charAt(i));
}  

• A) aceg B) ACEG C) abcdefg D) abcd

10. Java"一次编译，随处运行"的特点在于其（ A ）

    • A.跨平台性 B.面向对象型 C.多线程性 D.安全性

11. 下列有关类、对象和实例的叙述，正确的是（ B ）

    • A.类就是对象，对象就是类，实例是对象的另一个名称，三者没有差别
    • B.类是对象的抽象，对象是类的具体化，实例是对象的另一个名称 ✓
    • C.对象是类的抽象，类是对象的具体化，实例是对象的另一个名称
    • D.类是对象的抽象，对象是类的具体化，实例是类的另一个名称

12. 下列（ D ）不是面向对象程序设计方法的特点

    • D
    • A.封装 B.继承 C.多态 D.结构化

13. 下列哪个属于容器的构件（B ）?

    • A.JFrame B.JButton C.JPanel D.JApplet
    • B)JButton属于容器的构件，容器是用来存放构件的，而构件必须要放在容器上才能显示起作用

14. 下列有关父类属性和方法继承规则的描述错误的是（ A ）

    • A.父类中private修饰的属性和方法在子类中不被继承 ✗
    • B.父类中public修饰的属性和方法在子类中被继承且可访问
    • C.父类中protected修饰的属性和方法在子类中被继承且可访问
    • D.父类中default修饰的属性和方法在之类中被继承，若父类和子类在同一个包中，则也可访问

---

二、填空题

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

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

2. 在Java的基本数据类型中，char型采用Unicode编码方案，每个Unicode码占用 2 字节内存空间

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

4. 若x = 5，y = 10，则x < y和x >= y的逻辑值分别为 true 和 false

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

6. 创建一个名为 MyPackage 的包的语句是 package MyPackage ;，该语句应该放在程序的位置为：应该在程序第一句

7. 设有数组定义：int MyIntArray[] = { 10 , 20 , 30 , 40 , 50 , 60 , 70}，执行后输出结果是 120

int s = 0;
for (int i = 0; i < MyIntArray.length; i++)
    if (i % 2 == 1)    
        s += MyIntArray[i];
System.out.println(s);

8. 在Java程序中，通过类的定义只能实现 单重继承，但通过接口的定义可以实现 多重继承关系

9. 面向对象的软件开发方法用类把（数据）和基于数据的（操作）封装在一起

10. 在Java语言中，用来分配内存的运算符是 new

11. 接口中的方法只能是____抽象方法______

12. javax.swing包中的 JMenu 类是负责创建菜单的

---

三、写出下面程序的运行结果

程序1：

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;
    public AB(String str1, String str2)
    { 
        s1 = str1;  
        s2 = str2; 
    }
    public String toString()
    { 
        return s1+s2;
    }
}

运行结果： Hello! I love JAVA.

程序2：

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);
    }
}

运行结果： s = 180

程序3：

class Parent {
    String one, two;
    public Parent(String a, String b){
        one = a;
        two = b;
    }
    public void print(){ System.out.println(one); }
}
public class Child extends Parent {
    public Child(String a, String b){
        super(a,b);
    }
    public void print(){
        System.out.println(one + " to " + two);
    }
    public static void main(String args[]){
        Parent p = new Parent("south", "north");
        Parent t = new Child("east", "west");
        p.print();
        t.print();
    }
}

运行结果：

south
east to west

---

四、编程题

编程题1：编写Java GUI应用程序，完成从键盘输入矩形的长和宽，求矩形的周长和面积并输出结果

import javax.swing.JOptionPane;
public class Rect
{
    public static void main(String args[])
    {
        String s;
        double length, width, girth, area;
        s = JOptionPane.showInputDialog("输入矩形的长：");
        length = Double.parseDouble(s);
        s = JOptionPane.showInputDialog("输入矩形的宽：");
        width = Double.parseDouble(s);
        girth = (length + width) * 2;
        area = length * width;
        JOptionPane.showMessageDialog(null,"周长为：" + girth + "\n" + "面积为：" + area);
    }
}

编程题2：用Java Application编写一个程序，输出你的班级和姓名

public class HelloJava {
    public static void main(String[] args) {
        System.out.println("学号=2013001，姓名=张三");
    }
}

---

试题二

一、判断题

1. 在异常处理中，若try中的代码可能产生多种异常则可以对应多个catch语句，若catch中的参数类型有父类子类关系，此时应该将父类放在后面，子类放在前面（ √ ）

2. 子类只能继承父类的public，protected和同一个包中的package级的成员（ √ ）

3. 在类中实现一个接口，则一定要实现接口中的所有方法（ × ）

4. 抽象方法不仅有方法头，还应该有方法体（ × ）

   • 拥有abstract方法的类是抽象类，但抽象类中可以没有abstract方法

5. 在比较str1和str2两个字符串对象值是否相等时使用语句str1==str2（ √ ）

6. Java的源代码中定义几个类，编译结果就生成几个以.class为后缀的字节码文件（√）

7. Java程序里，创建新的类对象用关键字new，回收无用的类对象使用关键字free（×）

   • java自动回收机制

8. 构造函数用于创建类的实例对象，构造函数名应与类名相同，返回类型为void（×）

   • 构造函数无返回值

9. 如果源文件包含import语句，则该语句必须是除空行和注释行外的第一个语句行（ √ ）

10. 拥有abstract方法的类是抽象类，但抽象类中可以没有abstract方法（√）

11. 静态初始化器是在其所属的类加载内存时由系统自动调用执行（√）

12. 在Java中对象可以赋值，只要使用赋值号（等号）即可，相当于生成了一个各属性与赋值对象相同的新对象（×）

13. Java applet也能够存取客户机磁盘上的文件（ √ ）

14. 进程是程序的一次动态执行过程。一个进程在其执行过程中，可以产生多个线程——多线程，形成多条执行线索（ √ ）

---

二、单项选择题

1. Java application中的主类需包含main方法，以下哪项是main方法的正确形参？（ B）

   • A、String args B、String args[] C、Char arg D、StringBuffer args[]

2. 以下关于继承的叙述正确的是（A ）

   • A、在Java中类只允许单一继承

3. paint()方法使用哪种类型的参数? （A ）

   • A、Graphics

4. 以下哪个不是Java的原始数据类型（ B ）

   • A、int B、Boolean C、float D、char

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

   • A、static

6. 在浏览器中执行applet程序，以下选项中的哪个方法将被最先执行（ A ）

   • A、init()

7. 有以下程序片段，下列哪个选项不能插入到行1（ D ）

1.  
2. public class Interesting{
3. //do sth
4.}

• D、public class MyClass

8. 设有下面两个赋值语句，正确的是（ D ）

a = Integer.parseInt("12");
b = Integer.valueOf("12").intValue();

• D、a和b都是整数类型变量并且值相等

9. FilterOutputStream是BufferedOutputStream、DataOutputStream及PrintStream的父类，以下哪个类可能是FilterOutputStream构造函数的参数类型？（A）

   • A、OutputStream

10. 在编写Java Applet程序时，需在程序的开头写上（ B ）

    • B、import java.applet.Applet ;

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

    • D、public

12. Java源文件和编译后的文件扩展名分别为（ B ）

    • B、java 和 class

13. 下列说法中，不正确的一项是（B ）

    • B、类的方法只能由public修饰

14. main（B）方法是Java Application程序执行的入口点

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

15. 在类中若要处理ItemEvent事件，则该类需要实现的接口是（A ）

    • A、ItemListener

16. 将GUI窗口中的组件按照从左到右如打字式排列的布局管理器是（ A )

    • A、FlowLayout

---

三、程序阅读题

程序1：

class StringTest1 {
    public static void main(String[] args) {
        String s1="hello";
        String s2=new String("hello");
        if(s1.equals(s2)){
            System.out.println("相等");
        }else{
            System.out.println("不相等");
        }
    }
}

输出结果： 相等

程序2：

public class TestArray {
    public static void main(String args[]){  
        int i, j;
        int a[] = { 5,9,6,8,7};
        for ( i = 0 ; i < a.length-1; i++ ) {
            int k = i;
            for ( j = i ; j < a.length ; j++ )
                if ( a[j] < a[k] )  k = j;
            int temp = a[i];
            a[i] = a[k];
            a[k] = temp;
        }
        for ( i = 0 ; i < a.length; i++ )
            System.out.print(a[i]+"  ");
        System.out.println();
    }
}

输出结果： 5 6 7 8 9

程序3：功能说明

import java.io.*;
public class TestFile {
    public static void main(String args[]) throws Exception {
        BufferedReader br = new BufferedReader(
            new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new FileWriter("input.txt"));
        String s;
        while (true) {
            System.out.print("请输入一个字符串： ");
            System.out.flush();
            s=br.readLine();
            if (s.length()==0) break;
            bw.write(s);
            bw.newLine();
        }
        bw.close();
    }
}

功能： 从键盘逐一输入字符串，逐一输出至input.txt文件中，直至输入空行

---

四、阅读以下程序，写出输出结果

class Animal {
    Animal() {
        System.out.print ("Animal  ");  
    }
}
public class Dog extends Animal {
    Dog() {
        System.out.print ("Dog ");  
    }
    public static void main(String[] args) {
        Dog snoppy= new Dog();  
    }
}

输出结果： Animal Dog

---

试题三

一、单项选择题

1. 如下哪个是Java中的标识符（D）

   • D、width

2. 如下哪个是Java中的标识符（A）

   • A、fieldname

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

   • C、int len = s.length;

4. 如下哪个是Java中有效的关键字（C )

   • C、false

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

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

• D、16

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

   • B、class

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

   • C、interface

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

   • C、p.add(b,"South");

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

   • A、Button b=new Button();

10. Frame对象默认的布局管理器是（ B )

    • B、BorderLayout

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

    • C、import java.io.*;

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

    • D、import java.net.*;

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

    • A、FileInputStream

14. 在编写Java Applet程序时，需在程序的开头写上（ B）

    • B、import java.applet.Applet ;

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

    • C、调用框架对象的setTitle函数显示

16. 下列各种java中的构造函数定义，那种形式是错误的构造函数定义（ C )

C、 class MyClass {
    public int MyClass() { }  // 错误！构造函数不能有返回类型
}

17. Java属于（ A ）型语言

    • A、解释

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

    • B、–单行注释

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

    • B、定义抽象类时需要abstract

20. Applet可以做下列哪些操作（ D )?

    • D、读取客户端部分系统变量

21. 下列说法中，错误的一项是（ D )

    • D、事件源通常是一个构件，也称做监听器

22. 下列哪项是不能改变线程状态的方法?（C ）

    • C、main( )

---

二、填空题

1. 如果将类MyClass声明为public，它的文件名称必须是（MyClass.java）

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

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

4. Java中用于定义小数的关键字有两个：（float）和（double）

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

---

三、程序阅读题

程序1：

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!

程序2：

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

程序3：

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 = new Course("101", "ASP", 3);
        c.printCourseInfo();
    }
}

输出结果： 课程号:101 课程名:ASP 学分:3

程序4：

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斤

程序5：

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 学校：九中

程序6：

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

---

四、简答题

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

答：首先Java的异常是面向对象的。一个Java的Exception是一个描述异常情况的对象，当出现异常情况时，一个Exception对象就产生了，并放到异常的成员函数里。Java的异常处理是通过5个关键词来实现的：try,catch,throw,throws和finally。

• 异常处理： 在Java语言的错误处理结构由try，catch，finally三个块组成
• 抛出异常： Java语言可以不在方法中直接捕获，而用throw语句将异常抛给上层的调用者

2. 什么是继承？

答：通过必要的说明能够实现某个类无需重新定义就拥有另一个类的某些属性和方法，并把这种关系称为继承，先定义的类称为父类，后定义的类称为子类，并且允许多层的继承关系。

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

答：方法的重写Overriding和重载Overloading是Java多态性的不同表现：

• 重写(Overriding)： 父类与子类之间多态性的一种表现，子类的对象使用这个方法时，将调用子类中的定义
• 重载(Overloading)： 一个类中多态性的一种表现，定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型

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

答：Public、protected、private、default

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

答：用修饰符static说明的变量是类变量，其他是实例变量。不同对象的实例变量将分配不同的内存空间。所有对象的类变量都分配给相同的一处内存，改变其中一个对象的类变量的值，会影响其他对象的这个类变量的值。

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

答：

• 用abstract修饰的类不能创建对象，必须产生子类，有子类创建对象
• 用abstract修饰的方法只允许声明，而不允许实现
• 如果一个类是一个abstract类的子类，它必须实现父类的abstract方法

---

五、程序设计题

程序设计题1：创建Rectangle类

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) {
        Rectangle rect = new Rectangle(10, 20);
        System.out.println("周长是：" + rect.getLength());
        System.out.println("面积是：" + rect.getArea());
    }
}

程序设计题2：编写Animal接口

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 bird = new Bird();
        bird.run();
        Fish fish = new Fish();
        fish.run();
    }
}

程序设计题3：编写Frame框架应用程序

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() == "miClose_Clicked") {
                System.exit(0);
            }
        }
    }
}

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

---

试题四

一、单选题

1. 下列程序段执行后的结果是（ A )

String s = new String("abcdefg");
for (int i=0; i<s.length(); i+=2){
    System.out.print(s.charAt(i));
}

• A) aceg

2. 有整型数组：int[] x={12,35,8,7,2}，则调用方法Arrays.sort(x)后，数组x中的元素值依次是（ A )

   • A) 2 7 8 12 35
   • Arrays.sort(x)按升序排列

3. 下面的程序段创建了BufferedReader类的对象in，以便读取本机c盘my文件夹下的文件1.txt。File构造函数中正确的路径和文件名是（ C )

   • C) "c:\my\1.txt"

4. 应用程序的main方法中有以下语句，则输出的结果是（ A )

String s1=new String("abc");
String s2=new String("abc"); 
boolean b1=s1.equals(s2);
boolean b2=(s1==s2);            
System.out.print(b1+"   "+b2);

• A) true false

5. Hashtable语句的功能是（B )

Hashtable hashtable=new Hashtable();
hashtable.put("x","12345");
hashtable.put("y","67890");
hashtable.put("a","abcde"); 
System.out.println(hashtable.get("a"));

• B) abcde

6. 下面语句的功能是（A)

RandomAccessFile raf2 = new RandomAccessFile("1.txt","rw" );

• A) 打开当前目录下的文件1.txt，既可以向文件写数据，也可以从文件读数据

7. 应用程序Test.java的源程序如下，在命令行键入：java Test aaa bb c 回车后输出的结果是（ A )

public class Test {
    public static void main(String args[]) {
        int k1=args.length;
        int k2=args[1].length();         
        System.out.print(k1+"    "+k2); 
    }  
}

• A) 3 2

8. 应用程序的main方法中有以下语句，则执行后输出的结果是（ A )

int b[][]={{1}, {2,2}, {2,2,2}};
int sum=0;
for(int i=0;i<b.length;i++) {            
    for(int j=0;j<b[i].length;j++) {
        sum*=b[i][j];
    }            
}
System.out.println("sum="+sum);

- A) 32

9. 求最大值的程序，执行后输出的结果是（ D )

int[] x={125,21,5,168,98};  
int max=x[0];  
for(int i=1;i<x.length;i++){  
    if(x[i]> max)  
        max =x[i];  
}  
System.out.println(max);

- D) 168

10. 程序Test.java编译运行后输出的结果是（ A )

public class Test {  
    String s1="java";  
    public static void main(String args[]) {  
        int z=2;  
        Test t=new Test();  
        System.out.println(t.s1+z);  
    }  
}

- A) java2

11. 应用程序的main方法中有以下语句，则执行后输出的结果是（ A )

String s1="0.5", s2="12";  
double x=Double.parseDouble(s1);  
int y=Integer.parseInt(s2);  
System.out.println(x+y);

- A) 12.5

12. 编译程序Test.java后，将该程序运行3次，则文件test.txt的内容是（ D )

import java.io.*;
public class Test {
    public static void main(String args[]) {
        try {  
            String s="ABCDE";  
            byte b[]=s.getBytes();  
            FileOutputStream file=new FileOutputStream("test.txt",true);
            file.write(b);  
            file.close();  
        } catch(IOException e) {  
            System.out.println(e.toString());  
        }  
    }  
}

- D) ABCDE ABCDE ABCDE

13. 在Java语言中，表达式10/3的结果是（C ）

    • C) 3

14. 已知数组arrey，其最后一个元素的下标是（D ）

    • D) arrey.length-1

15. 初始状态下，ResultSet的指针初始位置在

    • A) 第一行之前

16. 下列有关Swing的叙述，哪项错误?（ D )

    • D) Swing是AWT图形工具包的替代技术

---

二、程序阅读题

程序1：GridLayout程序

import java.awt.*;
import javax.swing.*;
public class T extends JFrame {
    public T() {
        super("GridLayout");
        Container con=this.getContentPane();
        con.setLayout(new GridLayout(2,3));
        con.add(new JButton("a"));
        con.add(new JButton("b"));
        con.add(new JButton("c"));
        con.add(new JButton("d"));
        con.add(new JButton("e"));
        con.add(new JButton("f"));
        setSize(200, 80);
        setVisible(true);
    }
    public static void main(String args[]) {
        new T();
    }
}

• 界面显示：2行3列的GridLayout布局，按钮a-f排列
• 接口名：ActionListener
• 接口中的方法：public void actionPerformed(ActionEvent e)

程序2：字符串比较

String s1 = new String("abcde");
String s2 = new String("abcde");
boolean b1= s1.equals(s2);
boolean b2 = s1== s2;
System.out.print(b1+" "+b2);

• ①输出结果：true false
• ②equals方法比较两个字符串的内容是否相等；运算符"=="判断两个对象是否指向同一个引用

---

试题五

一、选择题

1. 当某一线程正处于休眠状态，而另一个线程用Thread类中的interrupt()方法中断它时，抛出的异常类型是（ C )

   • C) InterruptedException

2. 下面的程序段的功能是（D)

File file1=new File("d:\\xxx\\yyy\\zzz");
file1.mkdirs();

• D) 以上说法都不对

3. 应用程序的main方法中有以下语句，则输出的结果是（ B )

String s = "xxxxxxxxxxxxxxx#123#456#zzzzz";
int n = s.indexOf("#");
int k = s.indexOf("#", n+1);
String s2 = s.substring(n+1, k);
System.out.println(s2);

• B) 123

4. 关于程序Test.java说法正确的是（ D )

public class Test {  
    String x="1";  
    int y;  
    public static void main(String args[]) {  
        int z=2;  
        System.out.println(x+y+z);  
    }  
}

• D) 程序有编译错误

5. 应用程序的main方法中有以下语句，则输出的结果是（ A )

int b[][]={{1, 1, 1}, {2,2}, {3}};
int sum=0;
for(int i=0; i<b.length; i++) {  
    for(int j=0; j<b[i].length; j++) {  
        sum+=b[i][j];  
    }  
}
System.out.println("sum="+sum);

• A) 10

6. 应用程序的main方法中有以下语句，则执行后输出的结果是（ B )

int[] x = {125,21,5,168,98};
int min = x[0];
for (int i=1; i<x.length; i++){
    if(x[i] < min)
        min = x[i];
}
System.out.println(min);

• B) 5

7. Hashtable程序，输出结果是（ D )

Hashtable hashtable=new Hashtable();
hashtable.put("100","aaa");
hashtable.put("200","bbb");
hashtable.put("300","ccc");
System.out.println(hashtable.get("300").toString()
    + hashtable.get("200").toString()
    + hashtable.get("100").toString());

• D) cccbbbaaa

8. 以下关于java异常说法不正确的是（D ）

   • D) 以上说法都不对

9. 编译程序Test.java后，将该程序运行3次，则文件test.txt的内容是（D)

import java.io.*;
public class Test {
    public static void main(String args[]) {
        try {
            String s="ABCDE";
            byte b[]=s.getBytes();
            FileOutputStream file=new FileOutputStream("test.txt", true);
            file.write(b);
            file.close();
        } catch(IOException e) {
            System.out.println(e.toString());
        }
    }
}

• D) ABCDE ABCDE ABCDE

10. 下面说法不正确的是（ D )?

    • D) Map接口将键映射到值，键可以重复，但每个键最多只能映射一个值

11. 给定java代码，编译运行后输出结果是（ C )

public class test {  
    static int i=0;  
    public int aMethod() { 
        i++;  
        return i; 
    } 
    public static void main (String args[]) {  
        Test test=new Test() ;  
        test.aMethod () ;  
        System.out.println (test.aMethod()) ;  
    } 
}

- C) 2

12. 有整型数组，调用方法Arrays.sort(x)后，数组x中的元素值依次是（ A )

    • A) 2 7 8 12 35

13. Frame对象默认的布局管理器是（ B )

    • B) BorderLayout

---

二、程序阅读题

程序1：字符串比较

• 输出结果：true false
• equals方法比较两个字符串的内容是否相等；运算符"=="判断两个对象是否指向同一个引用

程序2：BufferedReader程序

import java.io.*;
public class Test {
    public static void main(String args[]) throws IOException {
        BufferedReader buf=new BufferedReader(
            new InputStreamReader(System.in));        
        while(true) {
            String str = buf.readLine();
            if(str.equals("quit"))
                break;
            int x=Integer.parseInt(str);
            System.out.println(x*x);
        }
    }  
}

• ①从键盘输入10，回车后输出的结果：100
• ②从键盘输入exit，不能正确执行，因为方法Integer.parseInt(str)不能将字符串"exit"转化为整数，抛出异常

程序3：Student链表程序

public class Test{
    public static void main(String args[]) {
        new Student("Tom", 'm', 90, 88);
        new Student("Jack", 'm', 66, 89);
        new Student("Mary", 'f', 76, 86);
        System.out.println("name\tsex\tchinese\tenglish");
        Student.print();
    }
}
class Student {
    protected String name;
    protected char sex;
    protected int chinese;
    protected int english;
    protected Student next;
    static Student list; 
    Student (String name, char sex, int chinese, int english) {
        this.name=name;
        this.sex=sex;
        this.chinese=chinese;
        this.english=english;
        this.next=list;
        list=this;
    }
    static void print() {
        Student friend=list;
        if (friend==null)
            System.out.println("The list is empty.");
        else {
            do{
                System.out.println(friend.toString());
                friend=friend.next;
            }while(friend!=null);
        }
    }
    public String toString() {
        return new String(name+"\t"+sex+"\t"+chinese+"\t"+english);
    }
}

输出结果：

name    sex     chinese english
Mary    f       76      86
Jack    m       66      89
Tom     m       90      88

---

试题六

一、填空题

1. 定义类的保留字是（ class ），定义接口的保留字是（ interface ）
2. Socket通常也称为（ 套接字 ），用于描述（ IP地址 ）和（ 端口 ）
3. 线程的优先级在（ 1 ）至（ 10 ）之间，数值越大（ 任务越紧急 ）
4. 构造方法是一种特殊的成员方法，构造方法名与（ 类名 ）相同
5. Java语言只允许单继承，指每个类只能有一个（ 父类 ）
6. Java源程序的扩展名是（ .java ），经过编译后的程序的扩展名是（ .class ）
7. 在一个时间只能由一个线程访问的资源称为（ 临界资源 ）访问临界资源的代码（ 临界代码 ）
8. 在多线程系统中，多个线程之间有（ 同步 ）和（ 互斥 ）两种关系
9. 使用运算符（ new ），创建类的对象，给对象分配内存空间
10. 程序中实现多线程的方法有两种：继承Thread类和实现（ Runnable ）接口
11. 同一个类中多个方法具有相同的方法名，不同的参数列表称为方法的（ 重载 ）
12. Java语言中的浮点型数据根据数据存储长度和数值精度的不同，进一步分为（ float ）和（ double ）两种具体类型
13. 假设x=1,y=2，则表达式x+y>=x*y的值是（ true ），其数据类型是（布尔）
14. 在Java的基本数据类型中，char型采用Unicode编码方案，这样无论是中文字符还是英文字符，都是占用（ 2 ）字节内存空间
15. 用户自定义异常是通过继承______异常______类或其子类
16. 为了支持Java程序的数据库操作功能，Java语言采用了专门的Java数据库编程接口API，叫做 JDBC
17. 可以通过继承 Thread 类和实现 Runnable 接口来创建线程

---

二、选择题

1. 关于选择结构下列哪个说法正确？（ B )

   • B、if语句可以没有else语句对应

2. while循环和 do…while循环的区别是：（ D )

   • D、do…while循环是先循环后判断，所以循环体至少被执行一次

3. 关于 for循环和 while循环的说法哪个正确？（ B )

   • B、while循环判断条件一般是程序结果，for循环的判断条件一般是非程序结果

4. 下列修饰符中与访问控制无关的是（ D )

   • D、final

5. void的含义：（ A )

   • A、方法没有返回值

6. return语句：（ C )

   • C、方法中可以有多句return

7. 关于对象成员占用内存的说法哪个正确？（ B )

   • B、同一个类的对象使用不同的内存段，但静态成员共享相同的内存空间

8. 下列说法哪个正确？（ C )

   • C、属性可以是简单变量，也可以是一个对象

9. 下列说法哪个正确？（ A )

   • A、一个程序可以包含多个源文件

10. 关于方法main()的说法哪个正确？（ C )

    • C、一个类中可以没有main()方法

11. 构造函数何时被调用？（ A )

    • A、创建对象时

12. 抽象方法：（ C )

    • C、是没有方法体的方法

13. 关于继承的说法正确的是：（ B )

    • B、子类将继承父类的非私有属性和方法

14. 关于构造函数的说法哪个正确？（ C )

    • C、构造函数与类同名

15. 覆盖与重载的关系是（ A )

    • A、覆盖只有发生在父类与子类之间，而重载可以发生在同一个类中

16. 关于接口哪个正确？（ A )

    • A、实现一个接口必须实现接口的所有方法

17. 异常包含下列哪些内容？（ A )

    • A、程序执行过程中遇到的事先没有预料到的情况

18. 对于已经被定义过可能抛出异常的语句，在编程时：（ A )

    • A、必须使用try／catch语句处理异常，或用throws将其抛出

19. 字符流与字节流的区别在于（ D )

    • D、每次读写的字节数不同

20. 下列流中哪个不属于字节流（ D )

    • D、InputStreamReader

---

三、程序填空题

程序1：

public class Sum{
    public static void main(String [] args){
        int j=10;
        System.out.println("j is : "+j);
        calculate(j);
        System.out.println("At last, j is : "+j);
    }
    static void calculate (int j){
        for (int i = 0;i<10;i++)
            j++;
        System.out.println("j in calculate() is: "+j);
    }
}

输出结果：

• j is : 10
• j in calculate() is : 20
• At last j is : 10

程序2：继承抽象类与接口

abstract class SuperAbstract{
    void a(){…}
    abstract void b();
    abstract int c(int i);
}
interface AsSuper { void x(); }
abstract class SubAbstract extends SuperAbstract implements AsSuper {
    public void b(){…}
    abstract String f();
}
public class InheritAbstract extends SubAbstract{
    public void x(){…}
    public int c(int i ) {…}
    public String f(){…}
    public static void main(String args[]){
        InheritAbstract instance=new InheritAbstract();
        instance.x();
        instance.a();
        instance.b();
        instance.c(100);
        System.out.println(instance.f());
    } 
}

答案：

• 抽象类有：SuperAbstract 和 SubAbstract
• 非抽象类有：InheritAbstract
• 接口有：AsSuper
• AsSuper中的x()方法是 抽象 方法，所以在InheritAbstract中必须对它进行 覆盖和实现

程序3：Leaf类链式调用

public class Leaf {  
    private int i = 0;
    Leaf increment(){
        i++;
        return this;
    }  
    void print() {
        System.out.println(" i = " + i);
    }  
    public static void main(String args[]){
        Leaf x = new Leaf();
        x.increment().increment().increment().print();
    }
}

输出结果： i = 3

程序4：文件复制程序

import java.io.*;
class FileStream {
    public static void main(String args[]) {
        try {
            File inFile = new File("file1.txt");
            File outFile = new File("file2.txt");
            FileInputStream fis = new FileInputStream(inFile);
            FileOutputStream fos = new FileOutputStream(outFile);
            int c;
            while ((c = fis.read())!=-1)
                fos.write(c);
            fis.close();
            fos.close();
        } catch (Exception e) {
            System.out.println("FileStreamsTest: "+e);
        }
    }
}

程序5：抽象类示例

abstract class Shape {
    abstract void display();
}
class Circle extends Shape {
    void display() {
        System.out.println("Circle");
    }
}
class Rectangle extends Shape {
    void display() {
        System.out.println("Rectangle");
    }
}
class Triangle extends Shape {
    void display() {
        System.out.println("Triangle");
    }
}
public class AbstractClassDemo{
    public static void main(String args[]){
        (new Circle()).display();
        (new Rectangle()).display();
        (new Triangle()).display();
    }
}

输出结果：

Circle
Rectangle
Triangle

---

试题七

一、选择题

1. 请说出下列代码的执行结果（B)

String s = "abcd";
String s1 = new String(s);
if (s == s1) System.out.println("the same");
if (s.equals(s1)) System.out.println("equals");

• B. equals

2. 下列有关Java中接口的说法哪个是正确的？（B）

   • B. 若一个类要实现一个接口，则用到"implements"关键字

3. 下列代码的执行结果是什么？（A)

String s1 = "aaa";
s1.concat("bbb");
System.out.println(s1);

• A. The string "aaa"

4. 如果有一个对象myListener（其中myListener对象实现了ActionListener接口），下列哪条语句使得myListener对象能够接受处理来自于smallButton按钮对象的动作事件？（C）
   • C. smallButton.addActionListener(myListener);

---

二、读程序题

程序1：键盘输入程序

import java.io.*;
public class Test{
    public static void main(String [] argv) {
        try {
            BufferedReader is = new BufferedReader(new InputStreamReader(System.in));
            String inputLine;
            while ((inputLine = is.readLine()) != null) {
                System.out.println(inputLine);
            }
            is.close();
        } catch (IOException e) {
            System.out.println("IOException: " + e);
        }
    }
}

功能： 读取键盘输入，显示到屏幕上，直到键盘输入为空为止

程序2：if-else嵌套

class test {
    public static void main (String [] args ){
        int x=9, y;
        if (x>=0)
            if (x>0)
                y=1;
            else y=0;
        else y=-1;
        System.out.println(y);
    }
}

答案： 1

程序3：Computer类

public class Computer {
    String mainbord,cpu;
    public Computer(String s1,String s2) {
        mainbord=s1;
        cpu=s2;
    }
    public static void main(String[] args) {
        Computer c=new Computer("华硕","Intel");
        System.out.println("mainbord:"+c.mainbord+" cpu:"+c.cpu);
    }
}

输出结果： mainbord:华硕 cpu:Intel

程序4：数组求和

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);
    }
}

输出结果： s = 180

程序5：父类子类属性

public class Father{
    int a=100;
    public void miner(){
        a--;
    }
    public static void main(String[] args){
        Father x = new Father();
        Son y = new Son();
        System.out.println(y.a);
        System.out.println(y.getA());
        y.miner();
        System.out.println(y.a);
        System.out.println(y.getA());
    }
}
class Son extends Father{
    int a = 0;
    public void plus(){
        a++;
    }
    public int getA() {
        return super.a;
    }
}

输出结果：

0
100
0
99

---

三、简答题

1. Java语言的特点

答：

• 简单性： Java风格类似于C++，但它摒弃了C++中容易引起程序错误的地方
• 面向对象： Java语言的设计是完全面向对象
• 分布式
• 解释执行
• 健壮性： Java提供自动垃圾回收机制，异常处理机制，进行严格的类型检查
• 平台无关性
• 安全性
• 多线程
• 动态性

2. 请描述AWT事件模型

答：

1. 监听对象必须实现对应事件监听器的接口
2. 明确事件监听器的接口形式
3. MyFirstFrame类必须实现接口ActionListener中的所有方法
4. 注册监听对象

3. 在Java中，怎样创建一个线程？

答：

1. 定义类来实现Runnable接口

class TestThread implements Runnable {
    public void run() { …}
}

2. 继承Thread类来实现

class TestThread extends Thread {
    TestThread(String name) {
        super(name);
        start();
    }
    public void run() { …}
}

---

总结

本资料包含7套完整的Java语言程序设计期末考试试题，涵盖了：

• ✅ 单选题
• ✅ 判断题
• ✅ 填空题
• ✅ 程序阅读题
• ✅ 简答题
• ✅ 编程题

主要知识点覆盖：

• Java基础语法
• 面向对象编程
• 异常处理
• 集合框架
• I/O流
• 多线程
• GUI编程
• 数据库编程(JDBC)

---

本文档由WorkBuddy AI助手从CSDN博客自动提取并整理