—————————————————— 以下选择的结果，皆是我选择错的—————————
1、正确描述如下类和类关系的选项是（）
“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
解析：
由题可知 “人最好的朋友是狗”
并且Java中定义方法是这样的：修饰符 返回值类型 方法名
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
2、Given:
class Mammal{ }
class Raccoon extends Mammal{
Mammal m = new Mammal();
}
class BabyRaccoon extends Mammal{}
Which four statements are true(Choose four)
●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.
解析：
A.Raccoon is-a Mammal. // Racoon 继承 Mammal
B.Raccoon has-a Mammal. // 包含/合作关系
C.BabyRaccoon is-a Mammal. // BabyRaccoon 继承 Mammal
D.BabyRaccoon is-a Raccoon. // BabyRaccoon 继承 Raccoon
E.BabyRaccoon has-a Mammal. // 包含/合作关系
F.BabyRaccoon is-a BabyRaccoon. // is -a 说明这两个类有共同性，自己跟自己是肯定有共同性的
3、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();
}
}
○A.Afoo Afoo
○B.Afoo Bfoo
●C.Bfoo Afoo
○D.Bfoo Bfoo
○E.Compilation fails
○F.An exception is thrown at runtime
解析：
Alpha a = new Beta(); // 创建了一个以Beta()类，类型的对象
Beta b = (Beta)a; // 将a对象进行转型，转为 Beta类
a.foo();
b.foo();
4、在JDK1.8之前，下列哪一种叙述是正确的（）
●A.abstract修饰符可以修饰属性、方法和类
○B.抽象方法的body部分必须用一对大括号{}包住
○C.声明抽象方法，大括号可有可无
○D.声明抽象方法不可写出大括号
解析：
抽象方法的定义就是没有体的方法，如果写了大括号那么就代表这个抽象方法已经实现了。
所以声明抽象方法时，是不需要写大括号的。
5、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);
}
}
○A.s 14
○B.s 16
●C.s 10
○D.Compilation fails.
○E.An exception is thrown at runtime.
解析：
TestDeclare类调用DeclareStuff接口重写doStuff时，没有在方法前面加 Public。
因为如果实现类或子类的范围缩小的话，当调用接口的方法时，其实现类的方法就无法访问，这样其实现类就没有任何意义。
6、如下哪些语句编译无错误（）
○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);
解析：
A.Byte b = new Byte(“123”);
B.Byte b = new Byte(123); // Byte类调用构造方法时，有两种传参方式，一是 byte类型，二是 String 类型
C.Byte b = new Byte(); // 没有传入参数
D.Byte b = new Byte((int)123.4); // 不能接收 int 类型的
E.Byte b = new Byte(0x123); // 这种写法是错的
7、以下选项中，关于int和Integer的说法错误的是（）
●A.int是基本数据类型，Integer是int的包装类，是引用数据类型
○B.int的默认值是0，Integer的默认值也是0
●C.Integer可以封装属性和方法，提供更多的功能
●D.Integer i=5;该语句在JDK1.5之后可以正确执行，使用了自动拆箱功能
解析：
B.int的默认值是0，Integer的默认值也是0 // Integer是引用型，引用型的默认值是 null
D.Integer i=5;该语句在JDK1.5之后可以正确执行，使用了自动拆箱功能 // 这里应该是 自动装箱功能
自动装箱：基本类型自动转换为 包装类型。
自动拆箱：包装类型自动转换为基本类型。
8、运行如下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
解析：
int i = 0;
float f = 2.3f;
double d = 2.7;
i = (int)Math.ceil(f) (int)Math.round(d);
// ceil() 方法可对一个数进行上舍入，返回值大于或等于给定的参数，所以这里的(int)Math.ceil(f) 就等于 3
// round() 方法是四舍五入，所以 (int)Math.round(d) = 3
9、分析如下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
解析：
String str = null // 这里字符串变量未初始化，就不能调用后面的 concat() 方法,不然会报出异常 NullPointerException
10、以下程序片段中，可以正常编译的是（）
●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”;
解析：
A.String s = “zzt”; String k = s+t; String t = “ is good”; // 创建变量 k时，赋值为 s + t 这里的t识别不到。
B.String s = “zzt”; String t; t = s[3] + “ is good”; // s 是字符串类型，不是数组所以 s[3] 是错误的。
C.String s = “zzt”; String v = s.toUpperCase();
D.String s = “zzt”; String t = s - “t”; // 字符串不能进行 相减
11、分析下面的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
●A.sb = stringbuffer2stringbuffer1
○B.sb = stringbuffer1
○C.sb = stringbuffer2
○D.sb = stringbuffer1stringbuffer2
解析：StringBuffer 对象调用的 append方法是：将追加的内容到当前StringBuffer对象的末尾。
12、ublic static void main(String[] args){
List
for(int i=0;i<5;i++){
list.add(i+1);
}
for(int i=0;i
}
System.out.println(list);
}
○A.编译错误
○B.null
○C.[4,5]
○D.[2,4]
●E.[]
解析：
for(int i=0;i<5;i++){
list.add(i+1);
}
// 当地一个for循环结束，list的值为：[1,2,3,4,5]
for(int i=0;i
}
// 第二个for循环 每成功执行一次就会删除list里面对于下标为i的值，同时下一次判断的时候，list.size()的值会改变。
[1, 2, 3, 4, 5] // i = 0 list.size() 5
[2, 3, 4, 5] // i = 1 list.size() 4
[2, 4, 5] // i = 2 list.size() 3
[2, 4] // i = 3 list.size() 2 //这里就不满足条件，就不会继续删除了
12、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);
}
}
●A.[10]
○B.[10,1]
○C.[10,1,3,4]
○D.[0,0,3,4]
解析：
static void fun(ArrayList a){
a.add(1); // 将第一个数组 a 再增加一个值 [10,1]
a = new ArrayList(); // 创建第二个数组 a
a.add(3);
a.add(4);
}
public static void main(String[] args){
ArrayList a = new ArrayList(); // 创建第一个数组 a
a.add(10); // 给第一个数组 a 添加 10
fun(a); // 调用方法，此方法将第一个 a 传进去，返回的也是第一个 a
System.out.println(a); // 这里打印的是 第一个数组 a
}
13、下列关键字不能单独使用，必须与try一起使用的有
○A.final
○B.finally
●C.catch
○D.finalize
解析：
try{
}catce ( ){
}finally{
}
14、给定如下所示的Java代码，则运行时，会产生（）类型的异常
public static void main(String[] args){
int a = 10;
System.out.println(a/0);
}
○A.ArithmeticException
●B.NullPointerException
○C.IOException
○D.ClassNotFoundException
解析：
A.ArithmeticException // 算术异常 // 题目中分母就为零了
B.NullPointerException // 空指针异常
C.IOException // IO异常
D.ClassNotFoundException // 无法找到指定的类异常
15、关于异常的编程，以下描述错误的是（）
○A.在有除法存在的代码处，为了防止分母为零，必须抛出并捕获异常
○B.int i = Integer.parseInt(“123a”);将产生NumberFormatException
●C.int a[] = null; a[0] = 1;将产生NullPointerException
○D.输入输出流编程中，读和写时都要抛出IOException
解析：
A.在有除法存在的代码处，为了防止分母为零，必须抛出并捕获异常
// 分母为0 为运行时异常，jvm帮我们补货，无需代码里面显式捕获
==============================错题总结===============================
- 定义类中的方法时，要确定方法的作用，以及方法的类型
- 类与类中的 is-a 和 has-a 要多理解
- 创建类对象时，要注意创建的是这个类的对象还是另一个类的对象
- Java中定义 abstract 和 Interface 的时候要注意细节
- 基本数据类型 和 引用数据类型要多注意之间的转换
- 不同数据类型 相加或相减 要考虑是否能进行
- 教学视频中提到的部分主要的工具类 要多练习
若有收获，就点个赞吧
0 人点赞
