零基础入门到精通II课后测试（Part 2）

(II 03)面向对象进阶（共10题）
下列选项中关于Java封装的说法错误的是（） 2 Points
○A.通常狭义的封装就是指将属性私有化，提供公有方法访问私有属性
○B.属性的访问方法包括setter方法和getter方法
○C.setter方法用于赋值，getter方法用于取值
●D.包含属性的类都必须封装属性，否则无法通过编译
Correct Answer（+2 Points）
在Java语言中，下列关于类的继承描述，正确的是（） 2 Points
○A.一个类可以同时继承多个父类
●B.一个类可以具有多个子类
○C.子类可以调用父类中的所有方法
○D.子类一定比父类有更多的方法
Correct Answer（+2 Points）
正确描述如下类和类关系的选项是（）
“Man has a best friend who is a Dog” 2 Points
○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; }
Wrong Answer（+0 Points）
Correct Answer:
D.class Man { private Dog bestFriend; }
解析：该题第一个考查点Dog和best friend那个才是具体的类，Dog是具体的类，bestfriend只是一个抽象的描述，人类的bestfriend可以是狗这个类，也可以是其他的人类；第二个考查点是Dog类和Man类的关系，他俩是Man包含Dog的关系，因此Dog应该作为Man类的属性。
关于类中static修饰的元素，说法正确的是（） 2 Points
○A.静态属性不能再次赋值
○B.方法中声明的静态变量在被调用的过程中保持值不变
●C.静态属性被该类的所有实例对象共享
○D.静态属性只能使用初始值
Correct Answer（+2 Points）
下列声明，哪一种可防止该类产生子类（） 2 Points
○A.static class Test{}
○B.class Test{}
○C.abstract class Test{}
●D.final class Test{}
Correct Answer（+2 Points）
Given:
class Mammal{ }
class Raccoon extends Mammal{
Mammal m = new Mammal();
}
class BabyRaccoon extends Mammal{}
Which four statements are true(Choose four) 2 Points
●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.
Wrong Answer（+0 Points）
Correct Answer:
解析：考查类和类之间的关系，类可以 is a 这个类本身。
A.Raccoon is-a Mammal.┋B.Raccoon has-a Mammal.┋C.BabyRaccoon is-a Mammal.┋F.BabyRaccoon is-a BabyRaccoon.
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();
}
} 2 Points
○A.Afoo Afoo
○B.Afoo Bfoo
○C.Bfoo Afoo
●D.Bfoo Bfoo
○E.Compilation fails
○F.An exception is thrown at runtime
Correct Answer（+2 Points）
在JDK1.8之前，下列哪一种叙述是正确的（） 2 Points
○A.abstract修饰符可以修饰属性、方法和类
○B.抽象方法的body部分必须用一对大括号{}包住
○C.声明抽象方法，大括号可有可无
●D.声明抽象方法不可写出大括号
Correct Answer（+2 Points）
下面选项可以在interface中合法定义的是（） 2 Points
○A.public static void main(String[] args);
○B.boolean setFlags(Boolean[] results);
○C.private float get(int x);
●D.static int getCount();
Wrong Answer（+0 Points）
Correct Answer:
解析：接口中没有块，构造方法，可以有主方法（A选项主方法没有{}结构体因此错误），接口方法修饰符只有public abstract，而属性只能是public static final修饰。
B.boolean setFlags(Boolean[] results);
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);
}
} 2 Points
○A.s 14
●B.s 16
○C.s 10
○D.Compilation fails.
○E.An exception is thrown at runtime.
Wrong Answer（+0 Points）
Correct Answer:
D.Compilation fails.
解析：继承、实现时子类重写方法时权限修饰符只能大于等于父类或者接口的权限修饰符，方法的返回值类型只能小于等于父类或者接口的返回值类型（该题中接口的修饰符是public abstract，虽然没写但默认的就是它，也只能是它，而实现接口的方法权限修饰符为默认不写的修饰符小于了public，因此轩D）；
(II 04)枚举及工具类（共10题）
如下哪些语句编译无错误（） 2 Points
○A.Byte b = new Byte(“123”);
●B.Byte b = new Byte(123);
○C.Byte b = new Byte();
○D.Byte b = new Byte((int)123.4);
○E.Byte b = new Byte(0x123);
Wrong Answer（+0 Points）
Correct Answer:
A.Byte b = new Byte(“123”);
解析：Byte为基本类型byte的包装类型，所有的跟数值相关的包装类的构造方法（没有无参的构造方法）只有两个：一个是参数为和自己类型一样的数据，另一个是String类型的参数的构造方法；Character包装类没有String参数类型的构造方法；B、D（虽然D选项中传递的是16进制但依然默认的是int）选项虽然123没有超过byte类型的取值范围（-128—127）但是常量默认取值类型是int类型，而Byte类没有参数为int类型的构造方法；
关于Float，下列说法错误的是（） 2 Points
○A.Float是一个类
○B.Float在java.lang包中
●C.Float a = 1.0是正确的赋值方法
○D.Float a = new Float(1.0)是正确的赋值方法
Correct Answer（+2 Points）
以下选项中，关于int和Integer的说法错误的是（） 2 Points
○A.int是基本数据类型，Integer是int的包装类，是引用数据类型
●B.int的默认值是0，Integer的默认值也是0
●C.Integer可以封装属性和方法，提供更多的功能
○D.Integer i=5;该语句在JDK1.5之后可以正确执行，使用了自动拆箱功能
Wrong Answer（+0 Points）
Correct Answer:
解析：基本类型：（byte short int long）对应的默认值均为0，（float double）对应的默认值均为0.0，（char）对应的默认值为 ‘’ 而’’中间放的是0所对应的code码，（boolean）对应的默认值为false，所有的引用数据类型对应的默认值均为null；D选项是实现了自动装箱功能。
B.int的默认值是0，Integer的默认值也是0┋D.Integer i=5;该语句在JDK1.5之后可以正确执行，使用了自动拆箱功能
运行如下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);
}
}
运行的打印结果是什么? 2 Points
○A.5
○B.6
○C.7
●D.9
Correct Answer（+2 Points）
下面（）不是String类提供的合法方法 2 Points
○A. equals()
○B. trim()
●C. append()
○D. indexOf()
Correct Answer（+2 Points）
对于语句String s = “my name is kitty”;,以下选项中可以从其中截取”kitty”的是（） 2 Points
○A.s.substring(11,16);
○B.s.substring(12);
●C.s.substring(12,17);
○D.s.substring(12,16);
Wrong Answer（+0 Points）
*Correct Answer:
A.s.substring(11,16);
解析：字符串substring方法截取的范围：[start—end），而字符串对应的索引位置是从0开始的。
分析如下Java代码，该程序编译后的运行结果是（）
public static void main(String[] args){
String str = null
str.concat(“abc”);
str.concat(“def”);
System.out.println(str);
} 2 Points
○A.null
○B.abcdef
○C.编译错误
●D.运行时出现NullPointerException
Correct Answer（+2 Points）
以下程序片段中，可以正常编译的是（） 2 Points
○A.String s = “zzt”; String k = s+t; String t = “ is good”;
○B.String s = “zzt”; String t; t = s[3] + “ is good”;
●C.String s = “zzt”; String v = s.toUpperCase();
○D.String s = “zzt”; String t = s - “t”;
Correct Answer（+2 Points）
分析下面的Java程序段，编译运行后输出结果是（）
public class Test{
public void changeString(StringBuffer sb){
sb.append(“stringbuffer2”);
}
public static void main(String[] args){
Test a = new Test();
StringBuffer sb = new StringBuffer(“stringbuffer1”);
a.changeString(sb);
System.out.println(“sb = “ + sb);
}
} 2 Points
○A.sb = stringbuffer2stringbuffer1
○B.sb = stringbuffer1
○C.sb = stringbuffer2
●D.sb = stringbuffer1stringbuffer2
Correct Answer（+2 Points）
分析下面的Java程序，编译运行后的输出结果是（）
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’;
}
} 2 Points
○A.good and abc
●B.good and gbc
○C.testok and abc
○D.testok and gbc
○E.Compilation fails
Correct Answer（+2 Points）
(II 05)枚举及工具类（共10题
ArrayList类的底层数据结构是（） 2 Points
●A.数组结构
○B.链表结构
○C.哈希表结构
○D.红黑树结构
Correct Answer（+2 Points）
LinkedList类的特点是（） 2 Points
○A.查询快
●B.增删快
○C.元素不重复
○D.元素自然排序
Correct Answer（+2 Points）
以下选项遵循”FIFO”的是（） 2 Points
○A.Stack
●B.Queue
○C.HashMap
○D.ArrayList
Correct Answer（+2 Points）
关于迭代器说法错误的是（） 2 Points
○A.迭代器是取出集合元素的方式
○B.迭代器的hasNext()方法返回值是boolean类型
○C.List集合和Set集合均可以获取迭代器
●D.迭代器的next方法将返回集合中的上一个元素
Correct Answer（+2 Points）
欲构造ArrayList类的一个实例，下列哪个方法是正确的（） 2 Points
○A.ArrayList myList = new Object();
●B.List myList = new ArrayList();
○C.ArrayList myList = new List();
○D.List myList = new List();
Correct Answer（+2 Points）
若使用TreeSet集合来存储元素，该元素必须（） 2 Points
●A.实现Comparable接口
○B.有main方法
○C.有get和set方法
○D.实现Serializable接口
Correct Answer（+2 Points）
在Java中，LinkedList类和ArrayList类同属于集合框架类
下列（）选项中的方法是LinkedList类而ArrayList类没有的 2 Points
○A.add(Object o)
○B.add(int index,Object o)
○C.remove(Object o)
●D.removeLast()
Correct Answer（+2 Points）
给定如下Java程序代码片段，编译运行这段代码，结果是（）
java.util.HashMap map = new java.util.HashMap();
map.put(“name”,null);
map.put(“name”,”Jack”);
System.out.println(map.get(“name”)); 2 Points
○A. null
●B. Jack
○C. nullJack
○D. 运行时出现异常
Correct Answer（+2 Points）
分析如下Java代码，编译运行后将输出（）
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);
} 2 Points
○A.编译错误
○B.null
○C.[4,5]
●D.[2,4]
○E.[]
Correct Answer（+2 Points）
分析如下Java代码，编译运行后将输出（）
public class Test{
static void fun(ArrayList a){
a.add(1);
a = new ArrayList();
a.add(3);
a.add(4);
}
public static void main(String[] args){
ArrayList a = new ArrayList();
a.add(10);
fun(a);
System.out.println(a);
}
} 2 Points
○A.[10]
●B.[10,1]
○C.[10,1,3,4]
○D.[0,0,3,4]
Correct Answer（+2 Points）
(II 06)Java的异常（共5题）
下列关键字不能单独使用，必须与try一起使用的有 2 Points
○A.final
●B.finally
●C.catch
○D.finalize
Correct Answer（+2 Points）
以下关于JAVA语言异常处理描述正确的有?（） 2 Points
○A.throw关键字可以在方法上声明该方法要抛出的异常
○B.throws用于抛出异常对象
○C.try是用于检测被包住的语句块是否出现异常，如果有异常，则抛出异常，并执行catch语句
●D.finally语句块是不管有没有出现异常都要执行的内容
○E.在try块中不可以抛出异常
Correct Answer（+2 Points）
给定如下所示的Java代码，则运行时，会产生（）类型的异常
public static void main(String[] args){
int a = 10;
System.out.println(a/0);
} 2 Points
●A.ArithmeticException
○B.NullPointerException
○C.IOException
○D.ClassNotFoundException
Correct Answer（+2 Points）
关于异常的编程，以下描述错误的是（） 2 Points
●A.在有除法存在的代码处，为了防止分母为零，必须抛出并捕获异常
○B.int i = Integer.parseInt(“123a”);将产生NumberFormatException
○C.int a[] = null; a[0] = 1;将产生NullPointerException
○D.输入输出流编程中，读和写时都要抛出IOException
Correct Answer（+2 Points）
代码如下，运行的结果是（）
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();
}
} 2 Points
○A.打印ABC
○B.打印C
●C.打印BC
○D.打印BCA
Correct Answer（+2 Points）