零基础入门到精通2课后测试错题集

1.Given:
class Mammal{ }
class Raccoon extends Mammal{
Mammal m = new Mammal();
}
class BabyRaccoon extends Mammal{}Which four statements are true(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(浣熊) is a (继承，实现) has a (组合，聚合，关联)
use a（依赖） 2.Given:（D）
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();
} A.Afoo Afoo B.Afoo Bfoo C.Bfoo Afoo D.Bfoo Bfoo E.Compilation fails F.An exception is thrown at runtime 解析：Beta继承了Alpha类，Beta类中的方法被重写，a,b调用了两次foo方法，所以a.foo()输出应该是Bfoo,b.foo()输出也应该是Bfoo
3.在JDK1.8之前，下列哪一种叙述是正确的（D） A.abstract修饰符可以修饰属性、方法和类 B.抽象方法的body部分必须用一对大括号{}包住 C.声明抽象方法，大括号可有可无 D.声明抽象方法不可写出大括号 解析： abstract修饰符用来修饰的类表示抽象类，不能被实例化 A.abstract可以用来修饰类和方法 B,C:声明抽象方法不能有函数执行体，如果用{}包住，即没有返回值的空白函数体不符合抽象方法的语法，所以不能有{}大括号

4.下面选项可以在interface中合法定义的是（B）
A.public static void main(String[] args); B.boolean setFlags(Boolean[] results); C.private float get(int x); D.static int getCount(); 解析：接口可以理解为抽象类抽象到极致（还是一个类的结构）
接口内可定义 属性：共有的，静态的的常量（public static final）
方法：共有的，抽象的方法（jdk1.8default修饰）

       不含有块和构造方法

5.Given:(D)
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);
}
}
A.s 14
B.s 16
C.s 10
D.Compilation fails.
E.An exception is thrown at runtime.
解析： 接口的的权限修饰符默认为public，而实现接口类的权限修饰符应该大于等于接口

6.运行如下Java类
public class Test{
public static void main(String[] args){
int i = 0;
float f = 2.3f;
double d = 2.7;
i = (int)Math.ceil(f) (int)Math.round(d);
System.out.println(i);
}
}
运行的打印结果是什么?(D)
A.5
B.6
C.7
D.9
解析：Math.ceil（）向上取整，所以Math.ceil(2.3)=3
Math.round()四舍五入，所以Math.round(2.7)=3
i=Math.ceil(2.3)Math.round(2.7)=9

7.分析下面的Java程序，编译运行后的输出结果是（B）
public class Example{
String str = new String(“good”);
char ch[] = {‘a’,’b’,’c};
public static void main (String args[]){
Example ex = new Example();
ex.change(ex.str,ex.ch);
System.out.print(ex.str + “ end “);
System.out.print(ex.ch);
}
public void change(String str,char ch[]){
str = “testok”;
ch[0] = ‘g’;
}
}
A.good and abc
B.good and gbc
C.testok and abc
D.testok and gbc
E.Compilation fails
解析：String类的不可变特性，体现在长度及内容
长度不变是由于：数组的长度是固定的，用final修饰数组
内容不可变是由于：private修饰的属性只能在本类中访问

8.以下选项中，关于int和Integer的说法错误的是（B,D）
A.int是基本数据类型，Integer是int的包装类，是引用数据类型
B.int的默认值是0，Integer的默认值也是0
C.Integer可以封装属性和方法，提供更多的功能
D.Integer i=5;该语句在JDK1.5之后可以正确执行，使用了自动拆箱功能
解析：B.int的默认值是0，Integer是引用数据类型，所以默认值是null
D.在JDK1.5之后，Integer i=5会自动封装成包装类

9.分析如下Java代码，编译运行后将输出（D）
public static void main(String[] args){
List list = new ArrayList();
for(int i=0;i<5;i++){
list.add(i+1);
}
for(int i=0;i list.remove(i);
}
System.out.println(list);
}
A.编译错误
B.null
C.[4,5]
D.[2,4]
E.[]
解析:当i=0时，size=5，调用一次list.remove(), size=4;

   当i=1时，size=4，调用一次list.remove(), size=3;<br />       当i=2时，size=3，调用一次list.remove(), size=2;<br />       当i=2，size=2时，不满足i<list.size（）,输出[2.4]

10.分析如下Java代码，编译运行后将输出（）
static void fun(ArrayList a){

    a.add(1);<br />        a = new ArrayList();<br />        a.add(3);<br />        a.add(4);<br />    }<br />    public static void main(String[] args){<br />        ArrayList a = new ArrayList();<br />        a.add(10);<br />        fun(a);<br />        System.out.println(a);<br />    }<br />}  <br /> A.[10]<br /> B.[10.1]

C.[10.1.3.4]
D.[0.0.3.4]
解析：主程序中创建一个ArrayList 对象，添加方法中的a为10，然后调用fun 方法添加 方法中的a 为1.此时的a为[10.1]
fun方法里的 a = new ArrayList()是一个局部变量,跟主程序里的a不是一样的，他们的地址不一样，所以再次添加不会添加到原来的a里面

11.以下关于JAVA语言异常处理描述正确的有?（D）
A.throw关键字可以在方法上声明该方法要抛出的异常
B.throws用于抛出异常对象
C.try是用于检测被包住的语句块是否出现异常，如果有异常，则抛出异常，并执行catch语句
D.finally语句块是不管有没有出现异常都要执行的内容
E.在try块中不可以抛出异常
解析：关于throw：

             异常只能在方法上抛出，属性是不能处理异常的<br />                 方法可以抛出不止一个异常，通过逗号隔开<br />            关于try;<br />                   try不能单独出现，后面必须添加catch或finally<br />                   catch有一组括号目的是为了捕获某一组异常<br />            关于finally：<br />                   finally不是必须存在的，若存在finally，则必须执行

12.代码如下，运行的结果是（C）
public class Test {
public static void main(String [] args) {
try {
badMethod();
System.out.print(“A”);
} catch (Exception e) {
System.out.print(“C”);
}
}
public static void badMethod() throws Exception {
System.out.print(“B”);
throw new Exception();
}
}
A.打印ABC
B.打印C
C.打印BC
D.打印BCA
解析：先执行badMethod里的语句，输出B，扔出一个异常.
try捕获异常，异常到catch前的语句都不执行