《JAVA语言程序设计》练习题

《JAVA语言程序设计》模拟练习

https://blog.csdn.net/Miracle1203/article/details/103726640

一、单选择题

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;
返回 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()); 
    }
}
// int初始值为 0，aMethod 调用了两次所以结果为 2

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

6、如下哪个是合法的 Java 中的标识符（ A ）。
A、fieldname B、super C、3number D、#number

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

int count = 1;
for (int i = 1; i <= 5; i++) {// 第一次 i 出去是 1
	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 ）。
str.charAt(i) 的意思是第 i 个字符在字符串 str 中所占的位置
length() 返回字符串的长度

String s = new String("abcdefg");
for (int i = 0; i < s.length(); i += 2){ // i 第一次输出的值是 0
    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 ）不是面向对象程序设计方法的特点。
A.封装 B.继承 C.多态 D.结构化

13.下列哪个属于容器的构件（B ）?
A.JFrame B.JButton C.JPanel D.JApplet

B) JButton 属于容器的构件,容器是用来存放构件的,而构件必须要放在容器上才能显示起作用
如果只创建出一个 JButton 来，没有任何意义，只有放在其它三项的容器里面，才能看到使用

14.下列有关父类属性和方法继承规则的描述错误的是（ A ）
A.父类中 private 修饰的属性和方法在子类中不被继承
B.父类中 public 修饰的属性和方法在子类中被继承且可访问
C.父类中 protected 修饰的属性和方法在子类中被继承且可访问
D.父类中 default 修饰的属性和方法在之类中被继承，若父类和子类在同一个包中，则也可访问

二、填空题

1、开发与运行 Java 程序需要经过的三个主要步骤为：
编辑源程序、 编译生成字节码 和 解释运行字节码。

2、在 Java 的基本数据类型中，char 型采用 Unicode 编码方案，每个 Unicode 码占用 2 字节 内存空间，这样，无论是中文字符还是英文字符，都是占用 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 应用程序，完成从键盘输入矩形的长和宽，求矩形的周长和面积并输出结果的功能。

import java.io.*;
import java.util.*;

public class Rect{
    public static void main(String args[]){
        String s;
        double length,width,girth,area;
        Scanner cin = new Scanner(System.in);
        
        System.out.println("输入矩形的长："); 
        length = cin.nextDouble(); // 输入一个双精度的浮点数 
        System.out.println("输入矩形的宽："); 
        width = cin.nextDouble();       
        girth = (length + width) * 2;
        area = length * width;
        System.out.println("周长为：" + girth + "\n" + "面积为：" + area);        
    }
}

2、设计一个矩形类 Rectangle(Java)

设计一个名为 Rectangle 的类表示矩形。这个类包括： 两个名为 width 和 height 的 double 型数据域，它们分别表示矩形的宽和高。
width 和 height 的默认值都为 1.
一个无参构造方法。
一个为 width 和 height 指定值的矩形构造方法。
一个名为getArea() 的方法返回这个矩形的面积。
一个名为 getPerimeter() 的方法返回这个矩形的周长。

类名为：
Rectangle

裁判测试程序样例：

import java.util.Scanner;
/* 你的代码将被嵌入到这里 */

public class Main {
  public static void main(String[] args) {
    Scanner input = new Scanner(System.in);

    double w = input.nextDouble();
    double h = input.nextDouble();
    Rectangle myRectangle = new Rectangle(w, h);
    System.out.println(myRectangle.getArea());
    System.out.println(myRectangle.getPerimeter());

    input.close();
  }
}

输入样例：
3.14 2.78

输出样例：
8.7292
11.84

class Rectangle {
  double width = 1;
  double height = 1;

  public Rectangle() {
  }

  public Rectangle(double width, double height) {
    this.width = width;
    this.height = height;
  }

  public double getArea() {
    return width * height;
  }

  public double getPerimeter() {
    return (width + height) * 2;
  }
}

成员变量和局部变量的区别
(1) 在类中的位置不同
成员变量：类中方法外
局部变量：方法定义中或者方法声明上
(2) 在内存中的位置不同
成员变量：在堆中
局部变量：在栈中
(3) 生命周期不同
成员变量：随着对象的创建而存在，随着对象的消失而消失
局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
(4) 初始化值不同
成员变量：有默认值
局部变量：没有默认值，必须定义，赋值，然后才能使用

3、用 Java Application 编写一个程序，输出你的班级和姓名。

public class HelloJava { // 类定义正确3分
	public static void main(String[] args) { // 2分
        Scanner cin = new Scanner(System.in);
        System.out.println("请输入学号：");
        String id = cin.next(); // 输入一个单词，遇到分号则输入终止
        System.out.println("请输入姓名：");         
        String name = cin.nextLine(); // 输入一行，中间可有多个空格
		System.out.println("学号 = " + id + "，姓名 = " + name); // 5分
	}
}

《JAVA语言程序设计》模拟练习二

一．判断题

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 中类只允许单一继承
B、在 Java 中一个类只能实现一个接口
C、在 Java 中一个类不能同时继承一个类和实现一个接口
D、在 Java 中接口只允许单一继承

3．paint() 方法使用哪种类型的参数? （A ）
A、Graphics B、Graphics2D C、String D、Color

4．以下哪个不是 Java 的原始数据类型（ B ）
A、int B、Boolean C、float D、char

5．若需要定义一个类域或类方法，应使用哪种修饰符？（ A ）
A、static B、package C、private D、public

6．在浏览器中执行 applet 程序，以下选项中的哪个方法将被最先执行（ A ）。
A、init() B、start() C、destroy() D、stop()

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

public class Interesting{
//do sth
}

A、import java.awt.; B、package mypackage;
C、class OtherClass{ } D、public class MyClass{ }

8. 设有下面两个赋值语句：
   a = Integer.parseInt(“12”);
   b = Integer.valueOf(“12”).intValue();
   下述说法正确的是（ D ）。
   A、a 是整数类型变量，b 是整数类对象。
   B、a 是整数类对象，b 是整数类型变量。
   C、a 和 b 都是整数类对象并且值相等。
   D、a 和 b 都是整数类型变量并且值相等。

9．FilterOutputStream 是 BufferedOutputStream、DataOutputStream 及 PrintStream 的父类，以下哪个类可能是 FilterOutputStream 构造函数的参数类型？(A)
A、OutputStream B、File
C、InputStream D、BufferedOutputStream

10．在编写 Java Applet 程序时，需在程序的开头写上( B )语句。
A、import java.awt. ; B、import java.applet.Applet ;
C、import java.io.* ; D、import java.awt.Graphics ;

11．在使用 interface 声明一个接口时，只可以使用（ D ）修饰符修饰该接口。
A、private B、protected C、private protected D、public

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

13.下列说法中，不正确的一项是（B ）
A.Java 程序只有两类：Application 和 Applet
B.类的方法只能由 public 修饰
C.面向对象的程序设计的优点有可重用性、可扩展性、可管理性
D.Java 语言通过接口支持多重继承

14.main（B）方法是 Java Application 程序执行的入口点，关于 main（）方法的方法头，下面（ ）是合法的。
A.public static void main （）
B.public static void main （String args[ ]）
C.public static int main （String [ ] args）
D.public void main （String args[ ]）

15.在类中若要处理 ItemEvent 事件，则该类需要实现的接口是（A ）
A.ItemListener B.ActionListener C. itemStateChanged D. Event

16.将GUI窗口中的组件按照从左到右如打字式排列的布局管理器是（ A ）
A.FlowLayout B.BorderLayout C.GirdLayout D.CardLayout

三．程序阅读题
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．以下程序段的输出结果为 5 6 7 8 9 。

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

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

《JAVA语言程序设计》模拟练习三

一、单项选择题

1、如下哪个是Java中的标识符（D）
A、public B、super C、3number D、width
2、如下哪个是Java中的标识符( A)
A、fieldname B、super C、3number D、#number
3、已知如下定义：String s = “story”; 下面哪个语句不是合法的(C )
A、s += “books”; B、s = s + 100;
C、int len = s.length; D、String t = s + “abc”;
4、如下哪个是Java中有效的关键字(C )
A、name B、hello C、false D、good
5、下面的代码段执行之后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

6、定义一个类，必须使用的关键字是(B )
A、public B、class C、interface D、static

7、定义一个接口必须使用的关键字是（C ）
A、public B、class C、interface D、static

8、如果容器组件p的布局是BorderLayout，则在p的下边中添加一个按钮b，应该使用的语句是（ C）
A、p.add(b); B、p.add(b,“North”);
C、p.add(b,“South”); D、b.add(p,“North”);

9、声明并创建一个按钮对象b，应该使用的语句是（ A ）
A、Button b=new Button(); B、button b=new button();
C、Button b=new b(); D、b.setLabel(“确定”);

10、Frame对象默认的布局管理器是（ B ）
A、FlowLayout B、BorderLayout
C、CardLayout D、null

11、下列哪一个import命令可以使我们在程序中创建输入/输出流对象（C）
A、import java.sql.; B、import java.util.;
C、import java.io.; D、import java.net.;

12、下面哪一个import命令可以为我们提供编写网络应用程序的类（D）
A、import java.sql.; B、import java.util.;
C、import java.io.; D、import java.net.;

13、如果需要从文件中读取数据，则可以在程序中创建哪一个类的对象（A）
A、FileInputStream B、FileOutputStream
C、DataOutputStream D、FileWriter

14、在编写Java Applet程序时，需在程序的开头写上（ B）语句。
A、import java.awt.* ; B、import java.applet.Applet ;
C、import java.io.* ; D、import java.awt.Graphics ;

15、如何在框架（Frame）中显示标题？（C ）
A、调用根窗格的set Title 函数显示
B、调用内容窗格的setTitle函数显示
C、调用框架对象的setTitle函数显示
D、调用框架对象的Border对象的setTitle函数显示
16、下列各种java中的构造函数定义，那种形式是错误的构造函数定义（ C）。

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

17、Java属于（ A ）型语言。
A.解释 B.编译 C.多线程性 D.安全性

18、下列哪项不是Java语言中所规定的注释样式?（ B）
A.//单行注释 B.–单行注释
C./* D./**
*多行注释 *文档注释
*/ */

1,　// 注释一行
2,　/* … / 注释若干行
3,　/**……/文档注释

19、以下关于抽象类和接口的说法正确的是（ B ）。
A.抽象类可以用来定义接口 B.定义抽象类时需要abstract
C.抽象类中的所有方法都是具体的 D.抽象类可以是对接口的实现

20、Applet可以做下列哪些操作（ D）?
A.读取客户端文件　 B.在客户端主机上创建新文件
C.在客户端装载程序库　　D.读取客户端部分系统变量

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

22、下列哪项是不能改变线程状态的方法?（C ）
A.start( ) B.sleep( ) C.main( ) D.stop( )

二、填空题

1、如果将类MyClass声明为public，它的文件名称必须是（MyClass.java）才能正常编译。
2、Java程序中的单行注释符是（ // ），多行注释符是（ /* */ ）。

1,　// 注释一行
2,　/* … / 注释若干行
3,　/**……/文档注释

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--)
	//这里的a表示你上面定义的那个整型一维数组，然后a.length表示a数组的长度,第一次i出去是4所以a【4】=6
		System.out.print(a[i] + "");

13、定义类的保留字是( class )，定义接口的保留字是( interface )。
14、构造方法是一种特殊的成员方法，构造方法名与( 类名 ) 相同。
15、Java语言只允许单继承，指每个类只能有一个 ( 父类 ) ，但通过接口的定义可以实现（ 多重 ） 继承关系。
16、在Java中，抽象类不能 被实例化 。
17、在Java中，为了能监视到ActionEvent类型的事件，事件源必须使用 addActionListener( ) 方法获得监视器。
18、利用DriverManager类的 getConnection（String url）静态方法创建数据库连接。

三、程序阅读题

1、以下程序的输出结果为_ Peter is 17 years old!___。

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

2、阅读以下程序，输出结果为 90and10

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

3、以下程序的输出结果为__课程号:101 课程名:ASP 学分: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;
		c = new Course("101", "ASP", 3);
		c.printCourseInfo();
	}
}

4、以下程序的输出结果为__汤姆猫体重：20.0斤___。

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

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

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

6、下列程序的运行结果是__12345____。

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

四、简答题
1、简述Java中异常处理的机制？

答：首先Java的异常是面向对象的。一个Java的Exception是一个描述异常情况的对象.当出现异常情况时，一个Exception对象就产生了,并放到异常的成员函数里。
Java的异常处理是通过5个关键词来实现的：try,catch,throw,throws和finally。
1.异常处理：在Java语言的错误处理结构由try，catch，finally三个块组成。其中try块存放将可能发生异常的Java语言，并管理相关的异常指针；catch块紧跟在try块后面，用来激发被捕获的异常；finally块包含清除程序没有释放的资源，句柄等。不管try块中的代码如何退出，都将执行 finally块。
2.抛出异常：Java语言可以不在方法中直接捕获，而用throw语句将异常抛给上层的调用者。Throw语句就是来明确地抛出一个异常；首先你必需得到一个Throwable的实例句柄，通过参数传到catch中，或者采用new操作符来创建一个。

2、什么是继承？

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

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

答：方法的重写Overriding和重载Overloading是Java多态性的不同表现。
重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。
如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被“屏蔽”了。
如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。Overloaded的方法是可以改变返回值的类型。

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

答：Public、protected、private、default

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

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

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

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

五、程序设计题
1、按以下要求编写程序
(1) 创建一个Rectangle类，添加width和height两个成员变量
(2) 在Rectangle中添加两种方法分别计算矩形的周长和面积
(3) 编程利用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、按以下要求编写程序
(1) 编写Animal接口，接口中声明run() 方法
(2) 定义Bird类和Fish类实现Animal接口
(3) 编写Bird类和Fish类的测试程序，并调用其中的run()方法
解答：

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框架应用程序，要求如下：
(1) 在窗口设置两个菜单“文件”、“编辑”
(2) 在“文件”菜单里添加三个菜单项“打开”、“保存”、“关闭”
(3) 在“编辑”菜单里添加两个菜单项“复制”、“粘贴”
(4) 点击关闭菜单项时，使程序关闭。
解答：

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;              	// "文件"菜单
	Menu mnuEdit;              	// "编辑"菜单
	MenuItem miOpen;   		   	// "打开"菜单项
	MenuItem miSave;           	// "保存"菜单项
	MenuItem miClose;          	// "关闭"菜单项
	MenuItem miCopy;           	// "复制"菜单项
	MenuItem 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); // 退出应用程序，状态码 0 表示正常终止，非 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();
	}
}

《JAVA语言程序设计》期末考试试题及答案4（应考必备题库）
一、 单选题
1、下列程序段执行后的结果是( A )。

String s = new String(“abcdefg”);
for (int i=0; i<s.length(); i+=2){
System.out.print(s.charAt(i));
}
1
2
3
4
A) aceg B) ACEG C) abcdefg D) abcd
2、有整型数组：int[] x={12,35,8,7,2};,则调用方法Arrays.sort(x)后，数组x中的元素值依次是( A ).
A) 2 7 8 12 35 B) 12 35 8 7 2
C) 35 12 8 7 2 D) 8 7 12 35 2

Arrays.sort(x)按升序排列
1
3、下面的程序段创建了BufferedReader类的对象in，以便读取本机c盘my文件夹下的文件1.txt。File构造函数中正确的路径和文件名的表示是( C )。
File f = new File(填代码处);
file =new FileReader(f);
in=new BufferedReader(file);
A) “./1.txt” B) “…/my/1.txt” C) “c:\my\1.txt” D) “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);
1
2
3
4
5
A)true false B) false true C) true true D)false false
5、应用程序的main方法中有以下语句，则输出的结果是 (B )。

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

1
2
3
4
5
A) a B) abcde C) 12345 D) 67890
6、下面语句的功能是( A)。

RandomAccessFile raf2 = new RandomAccessFile(“1.txt”,“rw” );
1
A)打开当前目录下的文件1.txt，既可以向文件写数据，也可以从文件读数据。
B)打开当前目录下的文件1.txt，但只能向文件写入数据，不能从文件读取数据。
C)打开当前目录下的文件1.txt，但不能向文件写入数据，只能从文件读取数据。
D) 以上说法都不对。
7、应用程序的main方法中有以下语句，则输出的结果是 B( )。

String s=“12345#aaa#bbb#67890”;
int n=s.indexOf(“#”);
int k=s.indexOf(“#”,n+1);
int m=s.indexOf(“#”,k+1);
String s2=s.substring(m+1);
System.out.println(s2);
1
2
3
4
5
6
A) 123456 B) 67890 C) aaa D) bbb
8、下面程序段执行后b的值是(B )。

Integer integ =new Integer(9)；
boolean b = integ instanceof Object;
1
2
A) 9 B) true C) 1 D) false
9、应用程序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);
}
}
//args.length表示传入参数的个数

A) 3 2 B)1 2 C) 1 3 D) 3 3
10、应用程序的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 B)11 C) 2 D) 3
11、应用程序的main方法中有以下语句，则执行后输出的结果是 ( 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);
A) 125 B) 5 C) 98 D) 168
12、程序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 B)2 C)没有输出结果 D)java
13、应用程序的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 B) 120.5 C) 12 D) “12.5”
14、下面的程序创建了一个文件输出流对象，用来向文件test.txt中输出数据，假设程序当前目录下不存在文件test.txt，编译下面的程序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());
}
}
}
A) ABCABC B) ABCDE C) Test D) ABCDE ABCDE ABCDE
15、在Java语言中，表达式10/3的结果是（C ）。
A.3.3 B.3.33 C.3 D.3.0
16、已知数组arrey，其最后一个元素的下标是（D ）。
A.arrey.size B.arrey.length C. arrey.size-1 D. arrey.length-1
17、初始状态下，ResultSet的指针初始位置在( )
A.第一行之前 B.第一行 C.最后一行 D.最后一行之后
18、下列有关Swing的叙述，哪项错误? ( D )
A.Swing是Java基础类(JFC)的组成部分
B.Swing是可用来构建GUI的程序包
C.Java基础类(JFC)是Swing的组成部分
D.Swing是AWT图形工具包的替代技术
Swing 是一个为Java设计的GUI工具包。
Swing是JAVA基础类的一部分。
Swing包括了图形用户界面（GUI）器件如：文本框，按钮，分隔窗格和表。

二、程序阅读题
1、阅读下面的程序，回答问题(问3分，问3分，共6分)。
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();
}
}
画图表示程序运行后的图形界面。
如果程序通过实现某个接口处理按钮的动作事件，则该接口名为何？接口中的方法头声明如何？
答案：

接口名：ActionListener
接口中的方法：public void actionPerformed(ActionEvent e)
2、阅读下面的程序代码，并回答问题（①问3分，②问3分，共6分）。
String s1 = new String(“abcde”);
String s2 = new String(“abcde”);
boolean b1= s1.equals(s2);
boolean b2 = s1== s2;
System.out.print(b1+" "+b2);
编译运行上面的程序：①程序段执行后，在命令行的输出结果如何？②equals方法的功能是什么？运算符“ == ”\ 的功能是什么？
答：
①true false
②equals方法比较两个字符串的内容是否相等；运算符“==”判断两个对象是否指向同一个引用，即是否为同一个对象。

《JAVA程序设计》期末考试试题 （五）
一、 单选题
1、当某一线程正处于休眠状态，而另一个线程用 Thread 类中的 interrupt() 方法中断它时，抛出的异常类型是（ C ）。
A) IOException B) RuntimeException
C) InterruptedException D) ClassNotFoundException
2、下面的程序段的功能是( D)。
File file1=new File(“d:\xxx\yyy\zzz”);
file1.mkdirs();
A)在当前目录下生成子目录：\xxx\yyy\zzz B)生成目录： e:\xxx\yyy\zzz
C)在当前目录下生成文件xxx.yyy.zzz 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);
A) 123456 B) 123 C) xxxxxxxxxxxxxxx D) zzzzz
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);
}
}
A)3 B)102 C) 12 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 B)6 C) 9 D) 13
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);
A) 125 B) 5 C) 98 D) 168

7、应用程序的main方法中有以下语句，则输出的结果是 ( 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());
  A) aaa B) bbb C) ccc D) cccbbbaaa
  8、以下关于java异常说法不正确的是（D ）。
  A) Throwable 类是 Java 语言中Error类和Exception类的父类。
  B)当异常对象是Exception类（或其子类）的实例时，能通过 Java 虚拟机或者 throw 语句抛出该异常对象，并能通过try…catch…finally处理。
  C)如果只用一个catch块捕捉多个异常对象，则catch 子句中的参数类型应是所有异常对象的父类。
  D)以上说法都不对。
  9、下面的程序创建了一个文件输出流对象，用来向文件test.txt中输出数据，假设程序当前目录下存在文件test.txt，编译下面的程序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());
  }
  }
  }
  A) ABCABC B) ABCDE C)Test D) ABCDE ABCDE ABCDE
  10、下面说法不正确的是( D )？
  A)列表(List)、集合(Set)和映射(Map)都是java.util包中的接口。
  B)List接口是可以包含重复元素的有序集合。
  C)Set接口是不包含重复元素的集合。
  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()) ;
  } }
  A、0 B、1 C、2 D、3
  12、有整型数组：int[] x={12,35,8,7,2};，则调用方法Arrays.sort(x)后，数组x中的元素值依次是（ A ）。
  A) 2 7 8 12 35 B) 12 35 8 7 2
  C) 35 12 8 7 2 D) 8 7 12 35 2
  13、Frame对象默认的布局管理器是（B ）。
  A、FlowLayout B、BorderLayout
  C、CardLayout D、null

二、程序阅读题
1、阅读下面的程序代码，并回答问题(1问3分，2问3分，共6分)。
String s1 = new String(“abcde”);
String s2 = new String(“abcde”);
boolean b1= s1.equals(s2);
boolean b2 = s1== s2;
System.out.print(b1+" "+b2);
程序段执行后，在命令行的输出结果如何？
解释输出(1)的结果的原因？
答案：
1 true false
2 equals方法比较两个字符串的内容是否相等；运算符“= =”判断两个对象是否指向同一个引用，即是否为同一个对象。
2、阅读下面的程序，并回答问题(问3分，问3分，共6分)。

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

编译运行上面的程序：
从键盘输入10，回车后输出的结果如何？
从键盘输入exit，回车后程序能正确执行吗？为什么？
答案：
100
不能；因为方法Integer.parseInt(str)不能将字符串“exit”转化为整数，抛出异常。
3、写出下面的程序编译、运行后的结果(6分)。

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

《JAVA程序设计》期末考试试题 （六）
一、填空题
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　）
A．if语句和 else语句必须成对出现
B．if语句可以没有else语句对应
C．switch结构中每个case语句中必须用break语句
D．switch结构中必须有default语句
2．while循环和 do…while循环的区别是：　　（D　　）
A．没有区别，这两个结构任何情况下效果一样
B．while循环比 do…while循环执行效率高
C．while循环是先循环后判断，所以循环体至少被执行一次
D．do…while循环是先循环后判断，所以循环体至少被执行一次
3．关于 for循环和 while循环的说法哪个正确？　（　B　）
A．while循环先判断后执行，for循环先执行后判断。
B．while循环判断条件一般是程序结果，for循环的判断条件一般是非程序结果
C．两种循环任何时候都不可以替换
D．两种循环结构中都必须有循环体，循环体不能为空
4．下列修饰符中与访问控制无关的是　（　D　）
A．private　　　 B．public
C．protected D．final
5． void的含义：　　（　A　）
A．方法没有返回值　　　 B． 方法体为空
C．没有意义　　　　 D.　定义方法时必须使用
6． return语句：　　（C　）
A．只能让方法返回数值　　　　 B．方法都必须含有
C．方法中可以有多句return 　　 D．不能用来返回对象
7．关于对象成员占用内存的说法哪个正确？　　（　B　）
A．同一个类的对象共用同一段内存
B、同一个类的对象使用不同的内存段，但静态成员共享相同的内存空间
C．对象的方法不占用内存
D．以上都不对
8．下列说法哪个正确？©
A．不需要定义类，就能创建对象
B．对象中必须有属性和方法
C．属性可以是简单变量，也可以是一个对象
D、属性必须是简单变量
9．下列说法哪个正确？　　（　A　）
A、一个程序可以包含多个源文件
B、一个源文件中只能有一个类
C、一个源文件中可以有多个公共类
D、一个源文件只能供一个程序使用
10．关于方法main（）的说法哪个正确？（　C　）
A．方法main（）只能放在公共类中
B main()的头定义可以根据情况任意更改
C．一个类中可以没有main()方法
D．所有对象的创建都必须放在main()方法中
11．构造函数何时被调用？　　（　A　）
A、创建对象时　　　　　 B、类定义时
C、使用对象的方法时　　 D、使用对象的属性时
12． 抽象方法：　　（　　C）
A、可以有方法体
B、可以出现在非抽象类中
C、是没有方法体的方法
D、抽象类中的方法都是抽象方法　
13．关于继承的说法正确的是：　　（B　　）
A、子类将继承父类所有的属性和方法。
B、子类将继承父类的非私有属性和方法。
C、子类只继承父类public方法和属性
D、子类只继承父类的方法，而不继承属性
14．关于构造函数的说法哪个正确？　　（　C　）
A、一个类只能有一个构造函数
B、一个类可以有多个不同名的构造函数
C、构造函数与类同名
D、构造函数必须自己定义，不能使用父类的构造函数
17．覆盖与重载的关系是　　（　A　）
A、覆盖只有发生在父类与子类之间，而重载可以发生在同一个类中
B．覆盖方法可以不同名，而重载方法必须同名
C．final修饰的方法可以被覆盖，但不能被重载
D．覆盖与重载是同一回事
18．关于接口哪个正确？　　（　A　）
A、实现一个接口必须实现接口的所有方法
B．一个类只能实现一个接口
C．接口间不能有继承关系
D．接口和抽象类是同一回事
19．异常包含下列哪些内容？　　（　　A）
A．程序执行过程中遇到的事先没有预料到的情况
B．程序中的语法错误　　
C．程序的编译错误
D．以上都是

20． 对于已经被定义过可能抛出异常的语句，在编程时：　　（　A　）
A、必须使用try／catch语句处理异常，或用throws将其抛出
B．如果程序错误，必须使用 try／catch语句处理异常
C．可以置之不理
D．只能使用try／catch语句处理
21． 字符流与字节流的区别在于（D　　）
A．前者带有缓冲，后者没有
B．前者是块读写，后者是字节读写
C. 二者没有区别，可以互换使用
D. 每次读写的字节数不同
22．下列流中哪个不属于字节流　　（　　D）
A．FileInputStream
B．BufferedInputStream
C. FilterInputStream
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 : (1)
j in calculate() is : (2)
At last j is : (3)
答案：(1) 10； (2) 20； (3) 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和　（1）　　(写出类名)
非抽象类有：　　　　　　　（2）　　(写出类名)
接口有：　　　　　　　　　（3）　　(写出接口名)
AsSuper中的x()方法是（4）方法，所以在InheritAbstract中必须对它进行（5）　　　　　　　
答案：
(1) SuperAbstract；(2) InheritAbstract；(3) AsSuper；(4) 抽象；(5) 覆盖和实现。
3. 按注释完成程序
public class Leaf {
private int i = 0; //此属性值用于检验
Leaf increment(){ //定义方法increment()，返回值是Leaf类的对象
i++;
return (1) ;//将当前对象的地址作为返回值返回
}
void print() {
System.out.println(" i = " + i);
}
public static void main(String args[]){
Leaf x = (2); //创建Leaf类的对象x
x.increment().increment().increment().print();
}//多次调用方法increment()，返回的都是x的地址，i 值表示调用次数
}
输出结果为 i = (3)
答案：
(1) this； (2)new Leaf()；(3) 3
4. 按注释提示完成文件复制的程序
//FileStream源代码如下：
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 =（1）;
FileOutputStream fos = new FileOutputStream(outFile);
int c;
//逐字节从源文件中输入，再输出到fos流
while ((c = fis.read ())!=-1)
（2）;
fis.close();
fos.close();
}
catch (Exception e) {
System.out.println("FileStreamsTest: "+e);
}
}
}
答案：
(1) new FileInputStream(inFile);
(2) fos.write©;
5. 阅读程序，给出结果：

// AbstractClassDemo.java源代码如下：
abstract class Shape { //定义抽象类Shape和抽象方法display
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(); //定义无名对象来调用对应的display方法
(new Rectangle()).display();
(new Triangle()).display();
}

}
输出结果是 ?
答案：(1) Circle； (2) Rectangle； (3) Triangle。

《JAVA程序设计》期末考试试题 （七）
一、选择题
请说出下列代码的执行结果 : (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”);
A. the same equals B. equals
C. the same D. 什么结果都不输出

下列有关 Java 中接口的说法哪个是正确的？ （B）
A. 接口中含有具体方法的实现代码
B. 若一个类要实现一个接口，则用到 “implements” 关键字
C. 若一个类要实现一个接口，则用到“ extends ”关键字
D. 接口不允许继承

下列代码的执行结果是什么？ (B)
String s1 = “aaa”;
s1.concat(“bbb”);
System.out.println(s1);
A. The string “aaa”.
B. The string “aaabbb”.
C. The string “bbbaaa”.
D. The string “bbb”.

如果有一个对象 myListener ( 其中 myListener 对象实现了 ActionListener 接口 ), 下列哪条语句使得 myListener 对象能够接受处理来自于 smallButton 按钮对象的动作事件 ? ©
A. smallButton.add(myListener);
B. smallButton.addListener(myListener);
C. smallButton.addActionListener(myListener);
D. smallButton.addItem(myListener);

二．读程序题
读下列代码，说出这段程序的功能。
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、 读下列程序，写出正确的运行结果。
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、以下程序的输出结果为____ mainbord:华硕 cpu:Intel 。
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);
}
}
4、下列程序的运行结果是 s = 180_____。
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);
}
}
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
三 . 简答题
Java语言的特点。
答：
简单性：Java风格类似于C++，但它摒弃了C++中容易引起程序错误的地方
面向对象：Java语言的设计是完全面向对象
分布式：
解释执行：
健壮性：Java提供自动垃圾回收机制，异常处理机制，进行严格的类型检查
平台无关性：
安全性
多线程
动态性

请描述 AWT事件模型。
答：
结合AWT事件模型并举例来说：
import java.awt.event.*;

监听对象必须实现对应事件监听器的接口
class MyFirstFrame extends Frame implements ActionListener
{…}
2．明确事件监听器的接口形式
public void actionPerformed ( ActionEvent event) {…}

MyFirstFrame 类必须实现接口ActionListener中的所有方法。

注册监听对象.
为了把MyFirstFrame对象注册为两个按钮的事件监听对象，必须在MyFirstFrame
的构造函数中添加语句如下：
cancelButton.addActionListener(this);
okButton.addActionListener(this);

在 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() {…}
}