《Java程序设计》期末复习试卷附上答案（2）A卷

JAVA复习卷

一、选择题(2’*15=30’)

1、如下哪个是Java中的标识符(     )

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

2、设 x = 1 , y = 2 , z = 3，则表达式  y＋＝z－－/＋＋x  的值是(      )。

    A. 3          B. 3. 5        C. 4         D. 5

3、下面的代码段执行之后count的值是什么(      )

int count = 1;

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

count += i;

}

System.out.println(count);

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

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

    A. static void method( )                    B. public void method( )    

    C. final void method( )                     D. abstract void method( )

5、下列程序段执行后的结果是(    )。

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

6、下面程序段执行后b的值是(    )。

Integer integ =new Integer(9)；

    boolean b = integ  instanceof  Object; 

A) 9     B) true     C) 1     D) false

7．关于 for循环和 while循环的说法哪个正确？　（　　）

A．while循环先判断后执行，for循环先执行后判断。

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

C．两种循环任何时候都不可以替换

D．两种循环结构中都必须有循环体，循环体不能为空

8．关于对象成员占用内存的说法哪个正确？　　（　　）

A．同一个类的对象共用同一段内存

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

C．对象的方法不占用内存

D．以上都不对

9．关于继承的说法正确的是：　　（　　）

A、子类将继承父类所有的属性和方法。

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

C、子类只继承父类public方法和属性

D、子类只继承父类的方法，而不继承属性

10．覆盖与重载的关系是　　（　　）

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

B．覆盖方法可以不同名，而重载方法必须同名

C．final修饰的方法可以被覆盖，但不能被重载

D．覆盖与重载是同一回事

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

A、import java.sql.*; B、import java.util.*;

C、import java.io.*; D、import java.net.*;

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

A、p.add(b); B、p.add(b,"North");

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

13、Frame对象默认的布局管理器是（   ）

A、FlowLayout B、BorderLayout

C、CardLayout D、null

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

A、FileInputStream B、FileOutputStream

C、DataOutputStream D、FileWriter

15、下面的程序创建了一个文件输出流对象，用来向文件test.txt中输出数据，假设程序当前目录下不存在文件test.txt，编译下面的程序Test.java后，将该程序运行3次，则文件test.txt 的内容是(    )。

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     

二、  填空题(1’*10=10’)

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

2.面向对象有三大特点分别是继承、           、          。

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

4、在Java的基本数据类型中，char型采用Unicode编码方案

，每个Unicode码占用       字节内存空间

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

6、在Java中声明一个字符串类型的变量str的语句是：               ，定义一个具有10个元素的整型数组a的语句是：                       。

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

    int s = 0 ;

    for (int i = 0 ; i < MyIntArray.length ; i + + )

         if ( i % 2 = = 1 )    

s += MyIntArray[i] ;

   System.out.println(s);

8、定义接口的保留字是(           )。

9、异常处理是由（   ）、（    ）和finally块三个关键所组成的程序块。

10．Socket通常也称为 (       )，用于描述(        )  和 (       )。

三、读程题(6’*5=30’)

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

}

}

2、输出结果为：

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

}

}

3、以下程序输出的结果为：

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

}

}

Circle

Rectangular

Triangle

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

}

}

5、以下程序的输出结果为：

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

     }

 }

四、简答题(4’*5=20’)

1. JAVA的基本数据类型有那些? String是不是基本类型?

2、什么是继承？

3、Java I/O中字符流和字节流的区别?

4.创建线程的两种方法

5.抽象类和接口的区别

五、编程题(3’+7’=10’)

1、按以下要求编写程序

(1) 创建一个Rectangle类，添加width和height两个成员变量

(2) 在Rectangle中添加两种方法分别计算矩形的周长和面积

(3) 编程利用Rectangle输出一个矩形的周长和面积

2、   编写一个完整的Java Applet 程序使用复数类Complex验证两个复数 1+2i 和3+4i 相加产生一个新的复数 4+6i 。复数类Complex必须满足如下要求：

 (1) 复数类Complex 的属性有：

 RealPart : int型，代表复数的实数部分

 ImaginPart : int型，代表复数的虚数部分

 (2) 复数类Complex 的方法有：

 Complex( ) : 构造函数，将复数的实部和虚部都置0

 Complex( int r , int i ) : 构造函数，形参 r 为实部的初值，i为虚部的初值。

 Complex complexAdd(Complex a) : 将当前复数对象与形参复数对象相加，所得的结果仍是一个复数值，返回给此方法的调用者。

 String ToString( ) : 把当前复数对象的实部、虚部组合成 a+bi 的字符串形式，其中a 和 b分别为实部和虚部的数据。

一、AADAA    BBBBA    DCBAD

二、MyClass.java       封装,多态      0      2       ==，<>

String str;  int [] arr = new int[10];       120      interface      try   catch

套接字    IP地址　　端口

三、1、Peter is 17 years old!

2、j is : 10                

j in calculate() is : 20   

At last j is : 10     

3、Circle

Rectangular

Triangle

4、汤姆猫体重：20.0斤

5、

name    sex     chinese  english

Mary    f       76      86

Jack     m      66      89

Tom     m      90      88

四、1、float,int char,byte,double，long,short,boolean。string不是基本类型

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

3、java流在处理上分为字符流和字节流。字符流处理的单元为2个字节的Unicode字符，分别操作字符、字符数组或字符串，而字节流处理单元为1个字节，操作字节和字节数组

4、a．Thread类的子类创建线程包括继承Thread类，重写run方法，在应用类中创建Thread之类的对象和调用start方法。

B．使用Runnable接口包括实现Runnable接口，实现run方法，创建THread类对象，采用实现Runnable接口类的对象作为参数和调用start方法。

5、a。接口中的所有方法都是抽象的，而抽象类可以定义带有方法体的不同方法。

b。一个类可以实现多个接口，而只能继承一个抽象父类。

c。接口与实现它的类不构成继承体系，而抽象类是属于一个类的继承体系。

d。接口中的方法默认是public abstract的，而成员变量默认是public static常量。

e。implements关键字用于实现接口，extends关键字用于继承。

五、1、

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、

import java.applet.* ;

import java.awt.* ;

 public class abc extends Applet {

 Complex a,b,c ;

 public void init( ) {

 a = new Complex(1,2);

b = new Complex(3,4);

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 ; // 复数的虚部

 Complex() { RealPart = 0 ; ImaginPart = 0 ; }

Complex(int r , int i)

{ RealPart = r ; ImaginPart = i ; }

 Complex complexAdd(Complex a){

 Complex temp = new Complex( ); // 临时复数对象

 temp.RealPart=RealPart+a.RealPart;

 temp.ImaginPart=ImaginPart+a.ImaginPart;

 return temp;}

 public String toString( )

{ return ( RealPart+" + "+ImaginPart+" i "); }

 }