开班考错题集

1.下列JavaDOC注释正确的是（C）
A. /阿拓老师很帅/
B. //阿拓老师很帅*/
C. /阿拓老师很帅/
D. /阿拓老师很帅/

解析：JavaDoc注释的用法:
//注释一行
/……/注释若干行
/……/注释若干行，并写入javadoc文档。通常这种注释的多行写法如下：
/**
……….
*……….

2.为一个boolean类型变量赋值时，可以使用（B）
A.boolean = 1;
B.boolean a = (9>=10);
C.boolean a = “真”;
D.boolean a == false;

解析：boolean变量赋值只能是true或者false，A、C为整型和string型故错误，D项赋值时应为=，==表示一种判断，改为boolean a=false;则正确。B中9>=10为false。

3. 下列代码输出结果是（D）
int i = 10;
while(i > 0){
i = i++;
if(i == 10){
break;
}
}
A.while循环执行10次
B.死循环
C.循环一次都不执行
D.循环执行一次

解析：i=10，进入while循环i=i++，++在后先赋值后自增，所以i依旧等于10。碰上if语句，i等于10，执行break语句跳出while循环，循环结束，共执行一次。

4.下面代码输出结果是（B）
int i = 0,s = 0;
do{
if(i%2 == 0){
i++;
continue;
}
i++;
s = s + i;
}while(i < 7);
System.out.println(s);
A. 16
B. 12
C. 28
D. 21

解析：i=0，s=0，进入do循环，执行if语句，i=1，并且结束该次循环，i<7，不跳出循环。
i=1，s=0，不执行if语句内部语句，i=2，s=0+2=2，结束该次循环，i<7，不跳出循环。
i=2，s=2，执行if语句，i=3，并且结束该次循环，i<7，不跳出循环。
i=3，s=2，不执行if语句内部语句，i=4，s=2+4=6，结束该次循环，i<7，不跳出循环。
i=4，s=6，执行if语句，i=5，并且结束该次循环，i<7，不跳出循环。
i=5，s=6，不执行if语句内部语句，i=6，s=6+6=12，结束该次循环，i<7，不跳出循环。
i=6，s=6，执行if语句，i=7，并且结束该次循环，i=7，跳出循环。
执行输出语句，输出s=12。

5.下列说法错误的有(不定项选择)（**B,C,D**）
A.数组是一种对象
B.数组属于一种原生类
C.int number = []{31,23,33,43,35,63};
D.数组的大小可以任意改变

解析：B，基本数据类型为原生类，数组是引用数据类型不是原生类，但是一种对象。C，数组的声明与初始化格式不对，应为int []number=new int[]{31,23,33,43,35,63};D,数组大小一经指定则无法改变。

6.下面哪个选项编译不会出错（**B**）
A.import java.util.*;
package mypackage;
class MyClass {}
B.package mypackage;
import java.util.*;
class MyClass{}
C.package mypackage;
class MyClass{}
import java.util.*;
D.class MyClass{}
package mypackage;
import java.util.*;

解析：package语句可以省略，写的话要放在第一句。需要引用其他包放在package后，类的声明之前。
**

7.关于数组默认值，错误的是（B）
A.String—null
B.Boolean—true
C.float—0.0f
D.int—0

解析：整型默认值为0；浮点型默认值为0.0；字符型默认值为’0’；boolean型默认值为false；引用数据类型默认值为null。

8.有以下程序片段且Interesting不是内部类
下列哪个选项不能插入到1.行（**D**）
1.
2.public class Interesting{
3. //#省略代码
4.}
A.import java.util.*;
B.package mypackage;
C.class OtherClass{}
D.public class MyClass{}

解析：A为引用包，B为创建包，C是一个普通类。D，public修饰的类只能有一个

9.以下代码的输出结果是？（**C**）
public class B{
public static B t1 = new B();
public static B t2 = new B();
{
System.out.println(“构造块”);
}
static{
System.out.println(“静态块”);
}
public static void main(String[] args){
B t = new B();
}
}
A.静态块 构造块 构造块 构造块
B.构造块 静态块 构造块 构造块
C.构造块 构造块 静态块 构造块
D.构造块 构造块 构造块 静态块

解析：在一个类中，先加载类再执行main函数。所以先执行t1实例化语句public static B t1 = new B();程序块运行输出构造块。接着执行t2实例化语句 public static B t2 = new B();程序块运行输出构造块。接着按照顺序执行静态代码块输出静态块，最后实例化t生成t对象，程序块运行输出构造块。

10.下列选项中关于Java封装的说法错误的是（**D**）
A.通常狭义的封装就是指将属性私有化，提供公有方法访问私有属性
B.属性的访问方法包括setter方法和getter方法
C.setter方法用于赋值，getter方法用于取值
D.包含属性的类都必须封装属性，否则无法通过编译

解析：（1）对于public修饰符，它具有最大的访问权限，可以访问任何一个在CLASSPATH下的类、接口、异常等。它往往用于对外的情况，也就是对象或类对外的一种接口的形式。
（2）对于protected修饰符，它主要的作用就是用来保护子类的。它的含义在于子类可以用它修饰的成员，其他的不可以，它相当于传递给子类的一种继承的东西。
（3）(什么都不写就是default)对于default来说，有点的时候也成为friendly（友员），它是针对本包访问而设计的，任何处于本包下的类、接口、异常等，都可以相互访问，即使是父类没有用protected修饰的成员也可以。
（4）对于private来说，它的访问权限仅限于类的内部，是一种封装的体现，例如，大多数的成员变量都是修饰符为private的，它们不希望被其他任何外部的类访问。

11.正确描述如下类和类关系的选项是（**D**）
“Man has a best friend who is a Dog”
A.class Man extends Dog { }
B.class Man implements Dog { }
C.class Man { private BestFriend dog; }
D.class Man { private Dog bestFriend; }
E.class Man { private Dog; }
F.class Man { private BestFriend; }

解析：“Man has a best friend who is a Dog”人类有一个最好的朋友—狗。BestFriend是属性，Dog是属性的类型（成员变量可以叫做类属性）。**

12.Given:
class Alpha{
public void foo(){
System.out.print(“Afoo”);
}
}
public class Beta extends Alpha{
public void foo(){
System.out.print(“Bfoo”);
}
public static void main(String[] args){
Alpha a = new Beta();
Beta b = (Beta)a;
a.foo();
b.foo();
}
}
What is the result?（**D**）
A.Afoo Afoo
B.Afoo Bfoo
C.Bfoo Afoo
D.Bfoo Bfoo
E.Compilation fails
F.An exception is thrown at runtime

解析：考察多态性，编译器认为a是Alpha类型，b是Beta类型，但是虚拟机知道a和b的真实类型是Beta，重载发生过子类和父类中时会发生覆盖现象，子类优先调用自己的同名函数，所以调用Beta类的函数。

13.Given:
class Mammal{ }
class Raccoon extends Mammal{
Mammal m = new Mammal();
}
class BabyRaccoon extends Mammal{}
Which four statements are true(Choose four)（**A,B,C,F**）
A.Raccoon is-a Mammal.
B.Raccoon has-a Mammal.
C.BabyRaccoon is-a Mammal.
D.BabyRaccoon is-a Raccoon.
E.BabyRaccoon has-a Mammal.
F.BabyRaccoon is-a BabyRaccoon.

解析：Mammal为父类，拥有两个子类，Raccoon和BabyRaccoon，Raccoon类中创建了一个新对象m为Mammal类，故正确答案为A、B、C、F。

14.下面选项可以在interface中合法定义的是（**B**）
A.public static void main(String[] args);
B.boolean setFlags(Boolean[] results);
C.private float get(int x);
D.static int getCount();

解析：出现static、default关键字以及主方法时，需要有方法体，没有方法体则看为抽象方法，权限至少为protected。

15.Given:
interface DeclareStuff{
public static final int EASY = 3;
void doStuff(int t);
}
public class TestDeclare implements DeclareStuff{
public static void main(String [] args){
int x = 5;
new TestDeclare().doStuff(++x);
}
void doStuff(int s){
s += EASY + ++s;
System.out.println(“s “ + s);
}
}
What is the result?（D）
A.s 14
B.s 16
C.s 10
D.Compilation fails.
E.An exception is thrown at runtime.

解析：在interface中的void doStuff(int t);一定是public，而TestDeclare中实现的时候就变成了包可见性，reduce了可见性，所以编译要出错的。