Java程序设计试卷2011-A.doc

一、 选择题（共20分，每小题2分）
1、面向对象程序设计语言的三个基本特征是？( D )
A. 封装、接口和多态 B. 继承、接口和动态
C. 跨平台、接口和动态 D. 封装、继承和多态

2、关于抽象类的叙述正确的是？( B )
A. 抽象类不可以实例化，或者说抽象类不能声明为对象
B. 抽象类就是一种特殊的接口
C. 抽象类的方法都是抽象方法
D. 抽象类的导出类一定不是抽象类

3、要导入java/awt/event下面的所有类，叙述正确的是？（ A ）
A、import java.awt.*和import java.awt.event.*都可以
B、只能是import java.awt.*
C、只能是import java.awt.event.*
D、import java.awt.*和import java.awt.event.*都不可以

4、下列修饰符中与访问控制权限无关的是？（ D ）
A．private B．public
C．protected D．final

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

6、关于static说法不正确的是（ D ）
A．可以直接用类名来访问类中静态方法(public权限)
B．静态块仅在类加载时执行一次
C．static方法就是没有this的方法
D．不可以用对象名来访问类中的静态方法(public权限)

7、关于容器下面说法正确的是？( )
A) 列表(List)和集合(Set)存放的元素都是可重复的。
B) 集合(Set)中至多只有一个空对象
C) 映射(Map)的key和value都不可重复
D) 映射(Map)的key和value都可以重复

8、关于对象成员占用内存的说法哪个正确？（ ）
A．同一个类的对象共用同一段内存
B、同一个类的对象使用不同的内存段，但静态成员共享相同的内存空间
C．对象的方法不占用内存
D．以上都不对

9、关于构造器的说法哪个正确？（ ）
A、一个类只能有一个构造器
B、一个类可以有多个不同名的构造器
C、构造器与类同名
D、构造器必须自己定义，不能使用父类的构造器

10、覆盖与重载的关系是（ ）
A、覆盖只有发生在父类与子类之间，而重载可以发生在同一个类中
B．覆盖方法可以不同名，而重载方法必须同名
C．final修饰的方法可以被覆盖，但不能被重载
D．覆盖与重载是同一回事

二、 填空题（共20分，每空2分）
1、java的private、static和final方法都是 绑定，其他都是 绑定，后者是java具有多态特性的必要条件。

2、JDK中的编译和运行命令分别是 和 。

3、Java源程序文件编译后将产生相应的字节码文件，这些字节码文件的扩展名为 。

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

5、如果一个类要实现一个接口，则要用到 关键字。

6、 是一种不能有构造器的内部类。

7、下列程序段执行后，sum的结果为 。
int n=1,sum=0;
while(n<=10)
{
n++;
sum=sum+n;
}

三、 判断题（共10分，每小题2分）
1、protected访问权限要小于包访问权限。（ ）

2、Stack通常是指“先进先出”的容器。（ ）

3、静态内部类不可以直接访问外围类的数据，而非静态内部类可以直接访问外围类的数据，包括私有数据。（ ）

4、在Java中，对于不再使用的内存资源，“垃圾回收器”自动将其释放。（ ）

5、一个接口不能继承多个接口。（ ）

四、 程序阅读题（共30分）
1、阅读以下程序，写出输出结果。(5分)
public class Abc {
public static void main(String args[]) {
Ab s = new Ab("Hello!", "I love JAVA.");
System.out.println(s);
}
}

class Ab {
String s1;
String s2;

Ab(String str1, String str2) {
s1 = str1;
s2 = str2;
}

public String toString() {
return s1 + s2 + "You?";
}
}
输出：

2、阅读以下程序，写出输出结果。(5分)
class Cup {
Cup(int marker) {
System.out.println("Cup(" + marker + ")");
}
void f(int marker) {
System.out.println("f(" + marker + ")");
}
}

class Cups {
static Cup cup1;
static Cup cup2;
static {
cup1 = new Cup(1);
cup2 = new Cup(2);
}
Cups() {
System.out.println("Cups()");
}
}

public class ExplicitStatic {
public static void main(String[] args) {
System.out.println("Inside main()");
Cups.cup1.f(99);
}
}
输出：

3、阅读以下程序，写出输出结果。(6分)
class Tree {
int height;
Tree() {
System.out.println("Planting a seedling");
height = 0;
}
Tree(int initialHeight) {
height = initialHeight;
System.out.println("Creating new Tree that is " +
height + " feet tall");
}
void info() {
System.out.println ("Tree is " + height + " feet tall");
}
void info(String s) {
System.out.println (s + ": Tree is " + height + " feet tall");
}
}

public class Overloading {
public static void main(String[] args) {
for(int i = 0; i < 5; i++) {
Tree t = new Tree(i);
t.info();
t.info("overloaded method");
}
// Overloaded constructor:
new Tree();
}
}
输出：
Creating new Tree that is 0 feet tall
Tree is 0 feet tall
overloaded method: Tree is 0 feet tall
Creating new Tree that is 1 feet tall
Tree is 1 feet tall
overloaded method: Tree is 1 feet tall
Creating new Tree that is 2 feet tall
Tree is 2 feet tall
overloaded method: Tree is 2 feet tall
Creating new Tree that is 3 feet tall
Tree is 3 feet tall
overloaded method: Tree is 3 feet tall
Creating new Tree that is 4 feet tall
Tree is 4 feet tall
overloaded method: Tree is 4 feet tall
Planting a seedling

4、阅读以下程序，写出输出结果。(6分)
public class Class3 {
public static void main(String args[]) {
SubSubClass x = new SubSubClass(10, 20, 30);
x.show();
}
}

class SuperClass {
int a, b;

SuperClass(int aa, int bb) {
a = aa;
b = bb;
}

void show() {
System.out.println("a=" + a + "\nb=" + b);
}
}

class SubClass extends SuperClass {
int c;

SubClass(int aa, int bb, int cc) {
super(aa, bb);
c = cc;
}
}

class SubSubClass extends SubClass {
int a;

SubSubClass(int aa, int bb, int cc) {
super(aa, bb, cc);
a = aa + bb + cc;
}

void show() {
System.out.println("a=" + a + "\nb=" + b + "\nc=" + c);
}
}
输出：
a=60
b=20
c=30

7