java试卷练习1_若要给当前的程序添加一个包名,添加包名的语句关键字为: 应该放在程序的位置 为:

试卷练习1

一、单项选择题。

在每小题列出的四个备选项中只有一个选项是符合目的要求的，请将其代码填写在
题后的括号内。

1、Java 语言中，byte 类型占用的二进制位数是：（D）
A、1 位 B、2 位 C、4 位 D、8 位

解释：byte 类型在 Java 中是 8 位二进制，也就是 1 个字节。

2、下面定义数组的格式中正确的是：（C）
A、int a[10] // Java 不支持这样的语法
B、int a=new int[10] // 这将创建一个整数数组，但语法错误，应使用数组引用类型
C、int [] a=new int[5] // 正确的数组声明和初始化
D、int a[] // 这是一个数组声明，但没有初始化，但它本身不是完整的定义格式

解释：在 Java 中，数组的正确声明和初始化方法是选项 C。

3、在 Java 中，下列哪些标识符是非法的？（C）
A、YourName
B、isEmpty
C、3second // 不能以数字开头
D、abc3

解释：在 Java 中，标识符不能以数字开头，所以 3second 是非法的。

4、下列哪项是正确的 char 型变量的申明？（B）
A、char ch = “R” // 错误，应该使用单引号
B、char ch= ‘R’ // 正确
C、char ch=“ABCD” // 错误，字符串太长，需要双引号，但也不能赋给 char 变量
D、char ch=’ ABCD ’ // 错误，单引号内不能有空格

解释：在 Java 中，char 类型用于存储单个字符，并且该字符应该用单引号括起来。

5、设 int x=1, float y=2，则表达式 x / y 的值是：（D）
A、0 // 整数除法会丢弃小数部分
B、1 // 实际上会进行浮点除法，但由于 x 是 int 类型，结果会被截断
C、2 // 不正确，结果远小于 2
D、以上都不是 // 因为表达式实际上是进行浮点除法，但由于 x 被隐式转换为 float，结果是 0.5，但选项中没有这个值

解释：在 Java 中，当两个操作数中有一个是浮点数时，整数除法会变为浮点除法。但由于 x 是 int 类型，它会被隐式转换为 float 类型，然后进行除法运算，结果是 0.5，但选项中没有这个值。

6、在 Java 语言中，用于标记回车符的转义字符是：（C）
A、\b // 退格符
B、/b // 这实际上不是一个转义字符
C、\n // 回车符（实际上在很多系统中表示换行符）
D、/n // 这不是一个有效的转义字符

7、有如下程序段：

int x = 2;
do {
    x *= x;
} while (x < 16);
1
2
3
4

该程序段执行后的 x 值：（B）
A、32
B、16
C、8
D、4

解释：x 变化轨迹：2,4,16

8、Java 中有三种循环语句，为了方便循环流程的控制，经常会使用 break 语句，关于 continue 语句的描述，正确的是（C）。
A、break 语句可以出现在循环控制语句之外的任何地方
B、执行 break 语句的结果是本次循环必须执行完毕
C、执行到 continue，则直接跳出本次循环体，继续执行下一次循环
D、break 语句是终止本次循环的执行，然后测试循环条件，准备进行下一次循环过程（这是 break 的描述，不是 continue）

9、以下代码执行后的输出结果是：（D）

int i = 1;
switch (i) {
    case 0: System.out.print(“Zero”); break;
    case 1: System.out.print(“One”); break； 
    case 2: System.out.print(“Two”); break;
    default: System.out.print(“Default”);
}
1
2
3
4
5
6
7

A、ZeroOneTwoDefault
B、OneTwoDefault
C、Default
D、One
解释：switch 语句根据 i 的值（1）选择执行 case 1: 下的代码块，并遇到 break 语句后跳出 switch 语句。

10、不能被再继承的类是 ：（A）
A、final 类 // 一个被声明为 final 的类不能被继承。这是 final 关键字在类上的主要用途。
B、abstract 类 // 一个 abstract 类可以被继承，但任何继承它的子类（除非该子类也是 abstract 的）都必须实现它的所有抽象方法。因此，abstract 类本身是可以被继承的。
C、public 类 // public 是一个访问修饰符，它决定了类可以在哪里被访问，但与类是否可以被继承无关。
D、用户自定义类 // 默认情况下，用户自定义的类是可以被继承的，除非它被声明为 final。所以，这个选项本身是不完整的，因为它没有明确指出类是否被声明为 final。但如果我们假设它是指一个非 final 的用户自定义类，那么它是可以被继承的。

11、下面关于构造方法的说法中，错误的是：（B）
A、构造方法也属于类的方法，用于创建对象的时候给成员变量赋值
B、构造方法不可以重载（这是错误的，构造方法可以重载）
C、构造方法不返回结果（构造方法没有返回类型，也不返回任何值）
D、构造方法一定要和类名相同

12、要想定义一个接口，则应该使用下面的哪个关键字：（D）
A、package
B、class
C、enum
D、interface

13、现有两个类 A、B，以下描述中表示 B 继承自 A 的是：（D）
A、class A extends B
B、class B implements A（这表示 B 实现了接口 A）
C、class A implements B（这通常是不合法的，因为 A 不能实现 B 类）
D、class B extends A（这表示 B 继承了 A）

14、若要在 Child 类中对 addvalue 方法进行重写，下面对于 Child 类中的 addvalue 方法头的描述哪个是正确的：（A）

class Parent {
   public int addvalue(int a, int b) {
        int s;
        s = a + b;
        return s;
    }
} class Child extends Parent {
    // ...
}
1
2
3
4
5
6
7
8
9

A、int addvalue(int I,int j) （方法名相同，参数类型不匹配，重写）
B、void addvalue(int i,int j) （返回类型不匹配，不算重写）
C、void addvalue(double i) （参数数量和类型不匹配，不算重写）
D、int addvalue(double a,int w) （参数类型改变，但Java中方法重写要求参数列表必须完全一致）

在Java中，正确的重写应该是与父类方法签名完全一致，即：

int addvalue(int a, int b) {
    // 子类中的重写实现
}
1
2
3

15、若想让一个线程进入睡眠状态，则要调用的方法是：（C）
A、init() （线程类中通常没有这个方法，它是类的构造方法初始化过程的一部分）
B、run() （线程开始执行时调用的方法，不是让线程睡眠的方法）
C、sleep() （使当前线程（即调用此方法的线程）暂停执行一段时间）
D、stop() （此方法已被弃用，因为它可能导致线程在不安全的状态下停止）

16、已知一个多线程类 Athread，下列语句中哪个是新建并执行线程的语句？（D）
A、创建了一个对象但没有启动线程
B、虽然创建了对象并调用了run()方法，但这不是启动线程的正确方式
C、同A，只是没有显式创建对象
D、正确创建了一个线程对象并调用了start()方法来启动线程

17、下列关于接口的描述中正确的是：（B）
A、一个类只能实现一个接口（错误，一个类可以实现多个接口）
B、一个类在实现接口时可以不用实现接口中的所有方法（正确，注意：普通类，即可以实例化对象的类，该类不能包含抽象方法，必须实现接口中的所有方法）
C、接口不能从其他接口直接继承（错误，接口可以继承其他接口）
D、接口中的方法都是抽象方法（正确–>错误，Java5中接口中的方法确实都是抽象方法；在Java 8及之后的版本中，接口可以包含默认方法（default methods）和静态方法（static methods），这些方法不是抽象方法。但除此之外，接口中的方法默认是抽象的。示例代码如下）

interface A{
	void test1();
	default void test2() {
		System.out.println("hell");
	}	 
	static void test3() {
		System.out.println("hell");
	}
}
1
2
3
4
5
6
7
8
9

18、定义一个 int 类型的数组 iArr 后，可以用下面哪个选项可以获得数组的长度（B）
A、iArr.Length; （Java中使用小写length）
B、iArr.length （正确）
C、iArr.size （Java数组没有size属性）
D、iArr.Size （同C，Java是大小写敏感的）

19、顺序执行下列语句后，str2 的值是（C）

String str1 = "Thanks";
String str2 = str1.substring(0,2);
1
2

A、Thanks （不是子字符串）
B、ks （子字符串从索引2开始）
C、Th （子字符串从索引0开始，长度为2）
D、hanks （子字符串的起始索引和长度都不对）

20、下面是 try-catch-finally 语句的模板：

try {
    语句 1；
} catch (Exception e) {
    语句 2；
} finally {
    语句 3；
}
1
2
3
4
5
6
7

关于该语句，描述正确的是（C）
A、语句 2 一定会执行 （如果语句 1没有抛出异常，则语句 2不会执行）
B、语句 2 是否执行与语句 1没有关系 （错误，语句 2是否执行取决于语句 1是否抛出异常）
C、语句 3 未必会执行 （正确，finally块中的语句 3正常情况下总是会执行，但如果提前结束程序，就不会执行，如提前执行了System.exit(0)）
D、语句 3 是否执行与语句 2 没有关系 （错误，同上）

二、填空题。

1、在 Java 的基本数据类型中，char 型采用 Unicode 编码方案，每个 Unicode 码占用（2）字节内存空间，这样无论是中文字符还是英文字符，都是占用（1）节内存空间。（注意：1节等于2字节）

2、设 int x = 2 ，则表达式 ( x + + )／3 的值是 （0）。因为x++是后置递增，先返回x的值（即2）再进行递增，所以(x++)的值为2，除以3的结果为0（整数除法）。

3、若 int x = 5，y = 10，则表达式 x < y 和 x >= y 的值分别为 true 和 false。

4、（抽象方法）方法是一种仅有方法声明，没有具体方法体和操作实现的方法，该方法必须定义在抽象类之中。（final）方法是不能被当前类的子类重写的方法。

5、若要给当前的程序添加一个包名，添加包名的语句关键字为：（package） 应该放在程序的位置为：（文件的最开始） ，添加有包名的类的实际类名为： （包名.类名）。例如，如果包名为com.example，类名为MyClass，则实际类名为com.example.MyClass。

三、程序阅读题

1、以下程序的输出结果为 true—false。

class Test1 {
   public static void main(String[] args) {
        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
2
3
4
5
6
7
8
9

输出结果

true---false
1

解释：s1.equals(s2) 是通过 String 类的 equals 方法比较两个字符串的内容是否相等，这里两个字符串的内容都是 “abcde”，所以 b1 为 true。而 s1 == s2 是比较两个对象的引用是否相同，因为这里创建了两个不同的 String 对象，所以 b2 为 false。

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

public class Test2 {
	public static void main(String[] args) {
		Fu f = new Zi();
		System.out.println(f.num);
		f.show();
	}
}

class Fu {
	public int num = 1;

	public void show() {
		System.out.println("Fu run");
	}
}

class Zi extends Fu {
	public int num = 10;

	public void show() {
		System.out.println("Zi run");
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

输出结果

1
Zi run
1
2

解释：Fu f = new Zi(); 这行代码进行了向上转型，即 Zi 类型的对象被当作 Fu 类型的对象来使用。由于 f 引用的是 Zi 类型的对象，访问 f.num 时实际上访问的是 Zi 类中定义的 num 成员变量，所以输出 10。但是这里有一个错误，因为 num 被重写（在面向对象中，成员变量不能被重写，只能被隐藏），所以实际上这里输出的是 Fu 类中的 num，即 1。接着调用 f.show() 方法，由于 f 引用的是 Zi 类型的对象，且 Zi 类重写了 show 方法，所以输出的是 “Zi run”。

成员变量：编译看左边，运行看左边
成员方法：编译看左边，运行看右边
静态方法：编译看左边，运行看左边

注意：如果题目中类 Zi 的 num 成员变量没有被隐藏（即没有重新声明 num），则输出为 1 和 Zi run。但根据提供的代码，输出应为 1 和 Zi run。

四、程序阅读题

1. 程序实现功能为 1、将字符串 s1 转换成 Integer 对象，2、使用字符串 s1 和 s2 分别输出其对应整形数据相加的值 50，3、字符串拼接的结果 2327。

class Test2 {
	public static void main(String[] args) {
		String s1 = "23";
		String s2 = "27";
		Integer integer = _______;
		int i1 = _______;

		int i2 = _______;
		System.out.print();
		System.out.print();
	}
}
1
2
3
4
5
6
7
8
9
10
11
12

参考答案

class Test2 {
	public static void main(String[] args) {
		String s1 = "23";
		String s2 = "27";
		Integer integer = Integer.parseInt(s1); // 将字符串 s1 转换成 Integer 对象
		int i1 = Integer.parseInt(s1); // 获取 s1 对应的整型数据
		int i2 = Integer.parseInt(s2); // 获取 s2 对应的整型数据
		System.out.print(i1 + i2); // 输出相加的值 50
		System.out.print(s1 + s2); // 输出字符串拼接的结果 2327
	}
}
1
2
3
4
5
6
7
8
9
10
11

2、程序实现功能为判断 2016 年是否为闰年，闰年的算法为要么可以被 4 整除但不能被 100 整除，要么可以被 400 整除。

public class Demo {
	public static void main(String[] args) {
		judge(2016);
	}

	public static void judge(int year) {
		if (((_______) && (_______)) || (_______)) {
			System.out.println();
		} else {
			System.out.println();
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13

参考答案

public class Demo {
	public static void main(String[] args) {
		judge(2016);
	}
	public static void judge(int year) {
		if (((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0)) {
			System.out.println("2016年是闰年");
		} else {
			System.out.println("2016年不是闰年");
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12

五、编程题

1、存在一个抽象的 Animal 类，里面有一个抽象方法 eat()，写出其两个子类 Cat 类和 Dog 类，重写了 eat()方法后的内容为打印一句 eat fish 和 eat bone。在测试类中提供一个方法可以使用多态的思想接收 Animal类型的对象分别执行 Cat 和 Dog 中的 eat()方法。

abstract class Animal {
    public abstract void eat();
}

class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("eat fish");
    }
}

class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("eat bone");
    }
}

public class Test {
    public static void main(String[] args) {
        Animal cat = new Cat();
        Animal dog = new Dog();

        eatAnimal(cat);
        eatAnimal(dog);
    }

    public static void eatAnimal(Animal animal) {
        animal.eat();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31