广工大叶老师Java复习资料一.docx

复习资料一
一、单项选择题
1、编译Java Application 源程序文件将产生相应的字节码文件，这些字节码文件的扩展名为( B )。
A. java B. .class
C. html D. .exe
2、下面关键字中，哪一个不是用于异常处理语句（ ）。
A.try B.break
C.catch D.finally
3. 关于抽象方法的说法正确的是( )
A.可以有方法体 B. 可以出现在非抽象类中
C.是没有方法体的方法 D. 抽象类中的方法都是抽象方法
4．下列选项中，用于在定义子类时声明父类名的关键字是( )。
A.interface B. package C. extends D. class
5．在Java中，一个类可同时定义许多同名的方法，这些方法的形式参数的个数、类型或顺序各不相同，传回的值也可以不相同。这种面向对象程序特性称为（ ）
A. 隐藏 B. 重写 C. 重载 D. Java不支持此特性
6．以下哪个不是Java的原始数据类型（ ）
A、int B、Boolean C、float D、char
7、不允许作为类及类成员的访问控制符的是( )。
A. public B. private C. static D. protected
8、有整型数组：int[] x={10,33,8,7,3};,则调用方法Arrays.sort(x)后，数组x中的元素值依次是( ).
A. 3 7 8 10 33 B. 10 33 8 7 3
C. 33 10 8 7 3 D. 8 7 10 33 3
9、void的含义：　　（　　）
A．方法没有返回值　 B． 方法体为空
C．没有意义　　　　 D.　定义方法时必须使用
10、 以下有关类的继承的叙述中，正确的是：（ ）
   A．子类能直接继承父类所有的非私有属性，也可通过接口继承父类的私有属性
   B．子类只能继承父类的方法，不能继承父类的属性
   C．子类只能继承父类的非私有属性，不能继承父类的方法
   D．子类不能继承父类的私有属性

二、填空题
1、面向对象有三大特点分别是 封装 、 继承 、多态 。
2、数组x定义：String x[ ][ ]=new int[3][2]; x[0 ][0 ]=”123”, x[0 ][1]=”ABCDE”;则 x.length 的值为3，x[0][1].length( ) 的值为 5 。
3、在定义子类时声明父类名的关键字是 extends 。
4、Java程序中的单行注释符是 // ，多行注释符是 /* */ 。
5、创建一个对象，要用 new 命令来实现对象的实例化。
6、创建一个名为 MyPackage 的包的语句是package MyPackage ; ，
该语句应该放在程序的位置为： 应该在程序第一句 。
7、构造方法是一种特殊的成员方法，构造方法名与 类名 相同。
8、在Java程序中，通过类的定义只能实现 单 重继承，但通过接口的定义可以实现 多 重继承关系。

三、 程序综合题
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);
}
}
输出结果为：
j is :  (1) 10
j in calculate() is : (2)20
At last j is :  (3)10

3、  按注释提示完成文件复制的程序
//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(c);

四、 程序设计题

题目：输入三个整数x,y,z，请把这三个数由小到大输出。   
参考答案：
import java.util.*;
public class lianxi15 {
public static void main(String[] args) {
input fnc = new input();
int x=0, y=0, z=0;
System.out.print("输入第一个数字：");
x = fnc.input();
System.out.print("输入第二个数字：");
y = fnc.input();
System.out.print("输入第三个数字：");
z = fnc.input();
if(x > y) {
int t = x;
x = y;
y = t;
}
if(x > z) {
int t = x;
x = z;
z = t;
}
if(y > z) {
int t = y;
y = z;
z = t;
}
System.out.println( "三个数字由小到大排列为： "+x + " " + y + " " + z);
}
}
class input{
public int input() {
int value = 0;
Scanner s = new Scanner(System.in);
value = s.nextInt();
return value;
}
}

复习资料二
一、 单项选择题
1、如果一个类的成员变量能在所在类中使用，则该成员变量必须使用的修饰是（）；
A. public B.. protected
C. private D. static
2、创建一个对象，要用（ ）运算符来实现对象的实例化。
A． make B．new C．use D． import
3、以下有关构造方法的说法，正确的是：（ ）
A． 一个类的构造方法可以有多个
B． 构造方法在类定义时被调用
C． 构造方法只能由对象中的其它方法调用。
D． 构造方法可以和类同名，也可以和类名不同
4、下面语句执行后，i 的值是( )。
for( int i=0, j=1; j < 5; j+=3 ) i=i+j;
A. 4 B. 5 C. 6 D. 7
5、下面的代码段执行之后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
6、定义一个类，必须使用的关键字是( )
A、public B、class C、interface D、static
7. 以下由 for 语句构成的循环执行的次数是( )。
for ( int i = 0; true ; i++) ;
A. 有语法错，不能执行 B. 无限次 C. 执行1次 D. 一次也不执行
8. 下列类定义中，不正确的是( )。
A. class x { .... } B. class x extends y { .... }
C. static class x implements y1,y2 { .... } D. public class x extends Applet { .... }
9．用于定义类成员的访问控制权的一组关键字是( )。
A. class, float, double, public
B. float, boolean, int, long
C. char, extends, float, double
D. public, private, protected
10． this和super( )。
A、都可以用在main()方法中
B、都是指一个内存地址
C、不能用在main()方法中
D、意义相同

二、 填空题
1、编译Java Application 源程序文件将产生相应的字节码文件，这些字节码文件的扩展名为 .class 。
2、在编写异常处理的Java程序中，每个catch语句块都应该与 try 语句块对应，使得用该语句块来启动Java的异常处理机制。
3、在Java程序中，通过类的定义只能实现单重继承，但通过 接口 的定义可以实现多重继承关系。
4、若x = 5，y = 10，则x < y和x >= y的逻辑值分别为 true 和 false 。
5、 抽象(abstract) 方法是一种仅有方法头，没有具体方法体和操作实现的方法，该方法必须在抽象类之中定义。 最终(final) 方法是不能被当前类的子类重新定义的方法。
6、异常处理是由 try 、 catch 和finally块三个关键所组成的程序块。
7、子类必须通过 super 关键字调用父类有参数的构造函数。
8、 表达式3/6 * 8的计算结果是 0 。

三、 程序综合题
1、 阅读下面代码，写出其对应的输出结果。
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();
}
}
请写出输出结果：？

2. 程序填空，按注释完成程序中缺少的代码。
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

3、阅读以下程序，写出输出结果。
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、编写一个“Student”类，该类拥有属性：校名、学号、姓名、性别、出生日期、成绩。方法包含设置姓名和成绩（setName(),setScore()）。
2、再编写“Student”类的子类：Undergraduate（大学生）。Undergraduate类除拥有父类属性和方法外，还有其自己的属性和方法：附加属性包括系（department）、专业(major)；方法包含设置系别和专业。(setDepartment(),setMajor())。
参考代码：
class Student{
String schoolName = null;
String number = null;
String sex = null;
String date = null;
int score;
setName(String name){
this.name = name;

}
setScore(int score){
this.score= score;
}

class Undergraduate extends Student{
String department = null;
String major = null;
setDepartment(String department ){
this.department = department ;
}
setMajor(String major ){
this.major = major ;
}
}

复习资料三
一、 单项选择题
1. 关于类和对象的叙述正确的是：（ ）
A．Java的类分为两大部分：系统定义的类和用户自定义的类
B．类的静态属性和全局变量的概念完全一样，只是表达形式不同
C．类的成员至少有一个属性和一个方法
D．类是对象的实例化
2. 为AB类的一个无形式参数无返回值的方法method书写方法头，使得使用类名AB作为前缀就可以调用它，该方法头的形式为( )。
A. static void method( ) B. public void method( )
C. final void method( ) D. abstract void method( )
3．关于 for循环和 while循环的说法哪个正确？　（　　）
A．while循环先判断后执行，for循环先执行后判断。
B．while循环判断条件一般是程序结果，for循环的判断条件一般是非程序结果
C．两种循环任何时候都不可以替换
D．两种循环结构中都必须有循环体，循环体不能为空
4．关于方法main（）的说法哪个正确？（　　）
A．一个类中可以有多个main()方法
B 所有对象的创建都必须放在main()方法中
C．一个类中可以没有main()方法
D．main()的头定义可以根据情况任意更改
5、下列语句序列执行后，i的值是( )。
int i=16; do { i/=2; } while( i > 3 );
A. 16 B. 8 C. 4 D. 2
6. 编译Java Application 源程序文件将产生相应的字节码文件，这些字节码文件的扩展名为( )。
A. java B. .class C. html D. .exe
7、定义一个接口必须使用的关键字是（ ）
A、public B、class C、interface D、static
8、下面语句的功能是( )。
RandomAccessFile raf2 = new RandomAccessFile("1.txt","rw" );
A.打开当前目录下的文件1.txt，既可以向文件写数据，也可以从文件读数据。
B.打开当前目录下的文件1.txt，但只能向文件写入数据，不能从文件读取数据。
C.打开当前目录下的文件1.txt，但不能向文件写入数据，只能从文件读取数据。
D. 以上说法都不对。
9、在类的定义中可以有两个同名函数，这种现象称为函数（ ）。
A.封装 B.继承 C.覆盖 D.重载
10、下面关于Java中异常处理try块的说法正确的是( )?
A.try块后通常应有一个catch 块，用来处理try块中抛出的异常。
B. catch 块后必须有finally块。
C.可能抛出异常的方法调用应放在catch块中。
D.对抛出的异常的处理必须放在try块中

二、 填空题
1、开发与运行Java程序需要经过的三个主要步骤为 编辑源程序 、
编译生成字节码 和 解释运行字节码 。
2、若x = 5，y = 10，则x < y和x >= y的逻辑值分别为 true 和 false 。
3、设 x = 2 ，则表达式 ( x + + )／3 的值是 0 。
4、Java 源文件中最多只能有 1 个公共类，其它类的个数不限。 
5、在Java中声明一个字符串类型的变量str的语句是： String str; .
6、接口中的成员只有静态常量和 方法声明 。
7、关键字 import 用于导入包中的类到程序中，供程序中使用。
8、 表达式(5-3)/4 * 6的计算结果是 0 。

三、 程序综合题
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. 阅读下面代码，按要求填空。
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) 覆盖和实现。

4.  阅读程序，写出程序运行结果：
// 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) 编写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();
}
}

复习资料四
一、 单项选择题
1、如下哪个是Java中的标识符( )
A、fieldname B、super C、3number D、#number
2、如下哪个是Java中有效的关键字( )
A、name B、hello C、false D、good
3. 以下关于继承的叙述正确的是（ ）。
A、在Java中类只允许单一继承
B、在Java中接口只允许单一继承
C、在Java中一个类不能同时继承一个类和实现一个接口
D、在Java中一个类只能实现一个接口
4、下列程序段执行后的结果是( )。
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
5、有整型数组：int[] x={12,35,8,7,2};,则调用方法Arrays.sort(x)后，数组x中的元素值依次是( ).
A. 2 7 8 12 35 B. 12 35 8 7 2
C. 35 12 8 7 2 D. 8 7 12 35 2
6．构造函数何时被调用？　　（　　）
A、创建对象时　　　　　 B、类定义时
C、使用对象的方法时　　 D、使用对象的属性时
7、关于方法main（）的说法哪个正确？（　　）
A．main()方法也可以重载。
B. main()的头定义可以根据情况任意更改
C．一个类中可以没有main()方法
D．所有对象的创建都必须放在main()方法中
8、类B是一个抽象类，类C是类B的非抽象子类，下列创建对象x1的语句中正确的是( )。
A. B x1= new B( ); B. B x1= new C( );
C. C x1=(C)new B( ); D. C x1= new B( );
9、以下关于继承的叙述正确的是（ ）。
A、在Java中类只允许单一继承
B、在Java中一个类只能实现一个接口
C、在Java中一个类不能同时继承一个类和实现一个接口
D、在Java中接口只允许单一继承
10、声明并创建一个按钮对象b，应该使用的语句是（ ）
A、Button b=new Button(); B、button b=new button();
C、Button b=new b(); D、b.setLabel(“确定”);

二、 填空题
1、 Java的复合数据类型有 : 类、数组和 接口 等。
2、为AB类的一个无形式参数无返回值的方法method书写方法头，使得使用类名 AB作为前缀就可以调用它，该方法头的形式为 static void method ( ) 。
3、 抽象 方法是一种仅有方法头，没有具体方法体和操作实现的方法，该方法必须在抽象类之中定义。
4、如果一个类的成员变量只能在所在类中使用，则该成员变量必须使用的修饰是 public 。
5、Java中所有类的默认超类为 Object 。
6、构造函数 没 有返回值。
7、创建类对象的运算符是 new 。
8、Java 源程序文件编译后产生的文件称为 字节码 文件,其扩展名为 .class 。

三、 程序综合题
阅读下面程序，写出其运行结果
public class Test {

public static void main(String[] args) {
int x;
int a[] = {0, 0, 0, 0, 0, 0};
calculate(a, a[5]);
System.out.println("the value of a[0] is " + a[0]);
System.out.println("the value is a[5] is " + a[5]);
}

static int calculate(int x[], int y) {
for (int i = 1; i < x.length; i++) {
if (y < x.length) {
x[i] = x[i - 1] + 1;
}
}
return x[0];
}
}
程序的输出结果为：
the value of a[0] is 0
the value is a[5] is 5
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; //请写注释：for语句的功能答：for语句去遍历数组中的元素，用k记录下值第i小元素的下标。
int temp =a[i];
a[i] = a[k];
a[k] = temp; //‚请写注释：这三个语句的功能
答：将第i小元素的值换到数字中的相应位置上；
}
for ( i =0 ; i<a.length; i++ )
System.out.print(a[i]+" ");
System.out.println( );
}
}
请写出输出结果：？
输出结果是：5 6 7 8 9

3、阅读以下程序，写出其输出结果。
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.println(" 家庭住址:" + address);
System.out.println(" 电话:" + tel);
}
}
class Son extends Father {
String school;
public Son(String name, int age) {
super(name, age);
}
void out() {
super.out(