Java错题笔记1

1. 下列JavaDOC注释正确的是（）
   ●A. /阿拓老师很帅/
   ○B. //阿拓老师很帅/
   ○C. /**阿拓老师很帅/
   ○D. /阿拓老师很帅/
   Correct Answer: **C
   解析：
   1）Java中有三种注释：单行注释// 多行注释/ / 文档注释/** /
   JavaDoc指的是Java中的文档注释 即/* /
   2）多行注释中能有单行注释 但不能有多行注释和文档注释
   因为系统会无法识别哪里是结束标志
   如 /A /B/ C/ 那么系统会识别的是 /A /B*/

2 .执行语句int a = ‘2’后，a的值是（）
●A.2
○B.50
○C.49
○D.0
Correct Answer: B
解析：
此句的意思相当于 char x = ‘2’; int a = x;
字符型可以直接转换为整型 任何一个字符都会有一个对应的Unicode码 所以此时 变量a 中的值应该是 字符’2’ 对应的Unicode码—->50
‘0’—‘9’ ——-> 48 — 57 ‘A’—‘Z’ ——-> 65 — 90 ‘a’—‘z’ ——-> 97 — 122

3 .在Java中下列关于自动类型转换说法正确的是（）【多选题】
○A. 基本数据类型和String相加结果一定是字符串型
○B. char类型和int类型相加结果一定是字符
○C. double类型可以自动转换为int
●D. char + int + double结果一定是double
Correct Answer: AD
解析：
注意题目为多选
A选项基本类型和String相加时 加号是拼接符 所以得到的结果就是String类型
B选项char类型与int类型相加结果应为int类型
C选项浮点型都不可以自动转换为整型 因为浮点型的精度比整型的精度高
浮点型需要强制类型转换成整型

1. 下列输出结果是（）
   int a = 0;
   while(a<5){
   switch(a){
   case 0 :
   case 3 : a = a + 2;
   case 1 :
   case 2 : a = a + 3;
   default : a = a + 5;
   }
   }
   System.out.println(a);
   ○A. 0
   ●B. 5
   ○C. 10
   ○D. 其他
   Correct Answer: C
   解析：
   程序中只要没有break 就会执行到底

2. 以下代码，执行结果为（）
   public class IfTest{
   public static void main(String[] args){
   int x = 3;
   int y = 1;
   if(x=y)
   System.out.println(“不相等”);
   else
   System.out.println(“相等”);
   }
   }

○A.不相等
●B.相等
○C.第五行代码会引起编译错误
○D.程序正常执行，但没有任何输出结果
Correct Answer: C
解析：
if括号中只能写布尔类型的值

1. public static void main(String [] args){
   int x = 5;
   boolean b1 = true;
   boolean b2 = false;
   if((x == 4) && !b2)
   System.out.print(“1 “);
   System.out.print(“2 “);
   if((b2 = true) && b1)
   System.out.print(“3 “);
   }
   上述程序的执行结果是（）
   ○2
   ●3
   ○1 2
   ○2 3
   Correct Answer: D
   解析：
   if()后面如果不加大括号{ } 那么只有if()后的第一条代码属于if()结构
   即System.out.print(“2 “);这行代码不属于第一个if()结构
   所以程序在执行 if((x == 4) && !b2)时 因为不满足if条件 所以直接执行System.out.print(“2 “); 最后执行System.out.print(“3 “);

2. 在Java中，关于构造方法，下列说法错误的是（）
   ○A.构造方法的名称必须与类名相同
   ○B.构造方法可以携带参数
   ○C.构造方法不可以重载
   ●D.构造方法没有返回值
   Correct Answer: C
   解析：
   仔细审题就行 构造方法是没有返回值的 且可以重载

3. 下列代码输出结果是（）
   int i = 10;
   while(i > 0){
   i = i++;
   if(i == 10){
   break;
   }
   }
   ○A.while循环执行10次
   ○B.死循环
   ○C.循环一次都不执行
   ●D.循环执行一次
   Correct Answer: D
   解析：
   注意 i = i++; 与 i++的区别
   i = i++；中 i 的值一直不变 为10 所以程序只会执行一次
   若改为i++ 则程序为死循环

4. 下面代码输出结果是（）
   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
   解析：
   注意 continue 的使用 continue中断当前循环后 都要先去判断 如果满足循环条件才会继续执行

5. 下列说法错误的有(多选题)
   ○A.数组是一种对象
   ●B.数组属于一种原生类
   ●C.int number = []{31,23,33,43,35,63};
   ●D.数组的大小可以任意改变
   解析：
   A选项 只要是引用类型 都是一种对象
   B选项 原生类指的是基本类型

6. 以下代码的输出结果是?（）
   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.构造块 构造块 构造块 静态块
   解析：
   创建对象前会先加载类 即开辟内存空间 往空间里装东西 此时加载顺序为 属性 方法 块 构造方法
   如果是静态成员 会比一般的成员先出现
   即 先加载 静态属性 静态方法 静态块 然后再到 一般属性 一般方法 一般块

   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类中有很多静态元素
          //加载
          //静态属性 ---->加载静态属性调用了构造方法 这个构造方法是为了属性加载用的 又因为构造方法前默认执行一般快
          //             所以一般块的执行是为了加载静态属性
          //             因为加载了两个静态属性---->先输出两个一般快
          //静态方法（没有方法）
          //静态块
          //执行
          //自动执行静态块---->输出静态块
          //创建B类对象  创建对象的前提需要一个B类模板
          //类加载完毕 调用构造方法 默认先执行一般块---->输出一般块
          B t = new B();
      }
   }

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; }
   Correct Answer: D
   解析：
   1）“我有一只狗，他是我的朋友”
   一个人有一条狗 即为has-a关系 即Dog做为人的属性
   狗的名字是朋友 狗的属性名即为朋友
   2）Dog 编译就不好使 因为没有变量名
   Dog代表类型 代表泛型
   类型和泛型通常有一个就够了 若同时出现 通常泛型是为了给类型做进一步的描述的
   比如 集合是一个类型 但是集合里面装的是什么 这时候就用到泛型了

2. 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.
   Correct Answer: D
   解析：
   接口中的方法默认就是public abstract修饰的
   那么子类重写时 就必须把方法重写掉
   但是方法重写时不写修饰符 那么修饰符就是默认修饰符 而不是public修饰的
   所以编译错误
   如果写了public修饰符 那么答案就是16

3. 以下选项中，关于int和Integer的说法错误的是（）
   ○A.int是基本数据类型，Integer是int的包装类，是引用数据类型
   ●B.int的默认值是0，Integer的默认值也是0
   ○C.Integer可以封装属性和方法，提供更多的功能
   ○D.Integer i=5;该语句在JDK1.5之后可以正确执行，使用了自动拆箱功能
   Correct Answer: BD
   D选项实现的是自动装箱的功能 即将int类型包装成Integer类型

4. 对于语句String s = “my name is kitty”;,以下选项中可以从其中截取”kitty”的是（）
   ○A.s.substring(11,16);
   ●B.s.substring(12);
   ○C.s.substring(12,17);
   ○D.s.substring(12,16);
   Correct Answer: A
   解析：
   注意索引从0开始 substring的截取区间为左闭右开

5. 以下程序片段中，可以正常编译的是（）
   ●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: C
   解析：
   A选项 变量t未定义 所以会出现编译时异常

6. 关于迭代器说法错误的是（）
   ○A.迭代器是取出集合元素的方式
   ○B.迭代器的hasNext()方法返回值是boolean类型
   ●C.List集合和Set集合均可以获取迭代器
   ○D.迭代器的next方法将返回集合中的上一个元素
   Correct Answer: D
   解析：
   迭代器的next方法将返回集合中的当前元素

7. 关于异常的编程，以下描述错误的是（）
   ○A.在有除法存在的代码处，为了防止分母为零，必须抛出并捕获异常
   ○B.int i = Integer.parseInt(“123a”);将产生NumberFormatException
   ○C.int a[] = null; a[0] = 1;将产生NullPointerException
   ●D.输入输出流编程中，读和写时都要抛出IOException
   Correct Answer: A
   解析：
   A选项 分母可以为0 编译时好使 但是运行不行 所以不是必须捕获异常

8. 下面选项可以在interface中合法定义的是（）
   ○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，不写也行
   方法是公有的抽象方法 即public abstract，不写也行
   A选项 方法不是公有的抽象方法 而且方法不能是静态的
   B选项 没有修饰符 默认的就是public abstract
   C选项 方法不能为私有的 接口就是为了定义规则让子类实现的 私有就无法实现了
   D选项 方法不能是静态的

9. 如下哪些语句编译无错误（）
   ●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);
   解析：
   Byte的构造方法只有带byte类型和String类型的 没有无参的构造方法
   B、D选项本质上都是调用int类型的构造方法 但是Byte没有

10. 分析如下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);
    }
    }
    ○A.[10]
    ●B.[10,1]
    ○C.[10,1,3,4]
    ○D.[0,0,3,4]
    解析：
    即复制了一份对象引用 传给了方法 若是通过这个引用改变内容 那么对象本身也会改变
    若是传递后把引用改变了 那么后面无论怎么修改 都不会影响对象本身
    所以集合中现存有[10,1] 然后改变了地址引用 这时无论怎么修改 都不会影响集合本身

23 在Java中，下列继承的说法，正确的是（）
A 子类能继承父类的所有成员
B 子类继承父类的非私有方法和状态
C 子类只能继承父类的public方法和状态
D 子类只能继承父类的方法
Correct Answer: A
解析：
1）构造方法每个类都有的 如果不写 也存在默认的构造方法
所以可以认为构造方法是属于类的
而 属性 普通方法 块 是需要后来添加的
所以类的成员严格意义上来说只有三个 属性 普通方法 块
即构造方法不存在继承这一说 而且子类也不能继承父类的构造方法
2）注意区分继承和访问权限
继承是继承所有的成员 私有的成员也能继承
只是无法访问到私有成员

24 short x = 1;
x = x+1; 与 x += 1; 有什么区别
解析：
1为int类型 存储的范围是32bit位
x为short类型 存储的范围是16bit位
如果用 x = x+1 那么会出现编译时异常
而 x += 1 底层会有强制的类型装换 即 x = (short)(x+1)

25 byte a = 1; byte b = 2; byte c = ab; 是否可以
解析：
不可以
1）注意这里1与2为int类型的 所以ab为int类型的
则int类型转为byte类型需要进行强制类型转换
2）byte在声明时如果赋的值大于127就需要强制类型转换
不然发生编译时异常 如 byte b = （byte）128;

26 Java类Demo类中存在fun1、fun2、fun3、fun4，请问哪个方法定义不合法（）多选
A fun1
B fun2
C fun3
D fun4
public class Demo{
float fun1{
int i = 1;
return;
}
float fun2{
short i = 2;
return i;
}
float fun3{
long i = 3;
return i;
}
float fun4{
double i = 4;
return i;
}
}
Correct Answer: AD
解析：
1）A选项没有返回值 所以错误
2）C选项注意 float可以存入long类型的
3）D选项double类型转换为float类型会出错 需要强转

27 下列构造方法的叙述中，错误的是（）
A Java语言规定构造方法名需要与类名必须相同
B Java语言规定构造方法没有返回值 但不同void声明
C Java语言规定构造方法不可以重载
D Java语言规定构造方法只能通过new自动调用
Correct Answer: C
解析：
1）构造方法是有返回值的 当通过new来调用构造方法时 构造器会返回该类的实例
即构造器的返回值总是当前类
2）构造方法无需定义返回值类型 也不能用void来规定返回值类型
否则该构造方法就不是构造方法 而是普通方法
3）不要在构造方法中显示的使用return 因为构造器返回值是隐式的

28 instance of运算符能够用来判断一个对象是否为：
A 一个类的实例
B 一个实现指定接口的类的实例
C 全部正确
D 一个子类的实例
Correct Answer: C
解析：
instance of为Java的二元运算符 用来判断左边的对象是否为右边（接口 抽象类 父类）的实例

29 如下哪些是Java中有效的关键字
A native
B NULL
C false
D true

Correct Answer: A
解析：
常考的 不是关键字的有 true false null sizeof friendly
保留的关键字 goto const

30 如下代码运行结果为
A numcount = 505000
B numcount = 0
C numcount = 505
D 运行错误
public static void main(String[] args){
int num = 0;
int count = 0;
for(int i = 0;i<=100;i++){
num = num+i;
count = count++;
}
System.out.println(“numcount”+(numcount));
}
*Correct Answer: C
解析：
注意 count = count++; 原理是先把count复制一份给count 然后再执行count自加1
所以count至始至终都是0

31 下列关于异常处理的描述，错误的是（）
A 程序运行时异常由Java虚拟机自动进行处理
B 使用try-catch-finally语句捕获异常
C 可使用throw抛出异常
D 捕获到的异常只能在当前方法中处理，不能在其他方法中处理
Correct Answer: D
解析：
1）编译时异常必须显式处理 运行时异常交给虚拟机
2）运行时异常可以不处理
当出现这样的异常时 总是由虚拟机接管
出现运行时异常后 系统会把异常一直往上层抛 一直遇到处理异常的代码
如果没有处理块 到最上层
如果是多线程就由Thread.run()抛出
如果是单线程就被main()抛出
抛出之后，如果是线程 这个线程也就退出了
如果是主程序抛出的异常 整个程序也就退出了
如果不对运行时异常进行处理 那么出现运行时异常之后 要么是线程中止 要么是主程序终止
3）捕获到的异常可以选择在当前方法中处理 也可以在调用它的上一级方法中抛出

32 下列哪些操作会使线程释放资源（）
A sleep()
B wait()
C join()
D yield()
Correct Answer: BC
解析：
1）sleep()会使当前线程睡眠指定时间 不释放锁
sleep()会使当前线程进入阻塞状态 在指定时间内不会执行 不推荐使用
2）yield()会使当前线程重回到可执行状态 等待cpu的调度 不释放锁
3）wait()会使当前线程回到线程池中等待 释放锁
当被其他线程使用notify / notifyAll唤醒时进入可执行状态
4）B线程通过join()加入到A线程中 会使A线程等待B线程执行完毕再继续执行
join()方法其实底层调用了wait()方法 所以也会释放锁

33 下面程序的输出结果为（）

public class Demo {
        public static String str = "";
        public static void func(int i){
            try{
                if(i%2==0){
                    throw new Exception();
                }
            }catch (Exception e){
                str += "0";
                return;
            }finally {
                str += "1";
            }
            str += "2";
        }
        public static void main(String[] args){
            func(1);
            func(2);
            System.out.println(str);
        }
}

A 120
B 1201
C 12012
D 101
Correct Answer: B
解析：
1）注意执行func（2）时 先抛出了一个异常 然后进入catch块中
执行 str += “0”; 再执行return return先约定好要返回什么 但是此时没有直接返回
因为有finally 那么会先执行finally中的语句 再把return中存的值返回
即执行 str += “1”; 然后 return; return后面的语句自然就不执行了
2）若finally中也有return 那么finally中的return结果会覆盖之前的return结果

34 一个以 .java 为后缀的源文件，哪些说法正确？
A 只能包含一个类，类名必须与文件名相同
B 只能包含与文件名相同的类，以及其中的内部类
C 只能有一个与文件名相同的类，可以包含其他类
D 可以包含任意类
Correct Answer: C
解析：
一个java文件可以包含多个java类 但是只能包含一个public类
并且public类的类名必须与java文件名相同

35 以下对选择语句描述错误的时（）
A 根据某一条件重复执行一部分代码 直到满足终止条件
B 可以根据条件控制程序流程 改变程序执行顺序
C 选择语句可以嵌套使用
D 当条件满足时就会执行相应的语句
Correct Answer: A
解析：
循环语句：while for do…while
选择语句（分支语句）：if switch
跳转语句：break continue label
异常处理语句：try…catch…finally throw
A选项是循环语句

36 面向对象方法的多态性是指（）
A 一个类可以派生出多个特殊类
B 一个对象在不同的运行环境中可以有不同的变体
C 针对一消息 不同的对象可以以适应自身的方式加以响应
D 一个对象可以是由多个其他对象组合而成的
Correct Answer: C
解析：
多态：同一类型的变量 调用同一个方法时呈现出多种行为特征
简单来说就是 父类引用指向子类对象

37 如下代码运行结果为（）
A 输出：ename
B 输出：123
C 编译报错
D 输出：name

class Test {
    String name = "name";
    public Test(String nm) {
        name = nm;
    }
}
class Test1 extends Test {
    String ename = "ename";
    public Test1(String id){
        ename = id;
    }
}
public class Demo{
    public static void main(String[] args){
        Test1 t = new Test1("123");
        System.out.println(t.ename);
    }
}

Correct Answer: C
解析：
如果子类构造器没有显式地调用超类的构造器 则将自动地调用超类默认（没有参数）的构造器
如果超类没有不带参数的构造器 并且在子类的构造器中有没有显示地调用超类的其他构造器 则Java编译器将报告错误
使用super调用构造器的语句必须是子类构造器的第一条语句

38 如下代码运行结果为（）

public class Demo{
    public static void main(String[] args){
       String str1 = new String("hello");
       String str2 = new String("hello");
       String str3 = "hello";
       String str4 = "hello";
       String str5 = "he"+"llo";
       String str6 = "he";
       String str7 = "llo";
       String str8 = str6+str7;
       System.out.println(str1==str2);
       System.out.println(str1==str3);
       System.out.println(str3==str4);
       System.out.println(str4==str5);
       System.out.println(str4==str8);
    }
}

Correct Answer: false false true true false
解析：
注意 字符串如果是变量相加 先开空间 后相加
如果是常量相加 先相加 然后在常量池中找
1）==判断的是对象的引用地址是否相同
new String得到的对象存储在堆内存中
而”hello”字符串存储在字符串常量池中
地址不同 所以str1==str3为false
2）String str5 = “he”+”llo”;
常量相加 即str5在编译时就已经确定
得到结果后在字符串常量池中找值
所以 str4==str5 为true
3）String str8 = str6+str7;
变量相加 即str8在编译之前是未知的 所以编译时会在堆中新建一个hello对象
然后再把对象的引用交给str8
所以 str4==str8 为false
4）如果 str6 以及 str7 用final修饰 此时就是常亮
那么此时在比较结果就为true
final String str6 = “he”;
final String str7 = “llo”;
String str8 = str6+str7;
str4==str8 为true

39 下面不是面向对象的基本原则的是（）
A 单一职责原则（Single-Responsibility Principle）
B 开放封闭原则（Open-Closed Principle）
C 抽象类原则（Abstract-Class Principle）
D 依赖倒置原则（Dependecy-Inversion Principle）
E 接口隔离原则（Interface-Segregation Principle）
Correct Answer: C
解析：
面向对象的原则：
单一职责原则（Single-Responsibility Principle）
开闭原则（Open-Closed Principle）
替换（里氏）原则（Liskov Susstitution Principle）
依赖倒置原则（Dependecy-Inversion Principle）
接口隔离原则（Interface-Segregation Principle）
迪米特原则 LOD
组合/聚合复用原则CARP

40 下面哪个不是赋值符号（）
A +=
B <<=
C <<<=
D >>>=
Correct Answer: C
解析：
B << 表示左位移
D >>> 表示无符号右位移
Java中没有<<<运算符

41 在创建派生类对象时，构造函数的执行顺序（）
A 基类构造函数 —> 派生类对象成员构造函数 —> 派生类本身的构造函数
B 派生类本身的构造函数 —> 基类构造函数 —> 派生类对象成员构造函数
C 基类构造函数 —> 派生类本身的构造函数 —> 派生类对象成员构造函数
D 派生类对象成员构造函数 —> 基类构造函数 —> 派生类本身的构造函数
Correct Answer: A
解析：
对象成员构造函数指的是非静态的代码块
所以类的初始化过程就是：
1 父类静态成员（静态成员的执行顺序 根据定义时的顺序 谁先定义谁先执行）
2 子类静态成员（静态成员的执行顺序 根据定义时的顺序 谁先定义谁先执行）
3 父类非静态成员
4 父类构造函数
5 子类非静态成员
6 子类构造函数

public class Demo{
   public static Demo demo = new Demo();
   static {
      System.out.println("静态代码块");
   }
   {
      System.out.println("普通代码块");
   }
    public static void main(String[] args){
       Demo demo1 = new Demo();
    }
    //普通代码块
    //静态代码块
    //普通代码块
}

静态属性定义先与静态块
输出结果为：普通代码块 静态代码块 普通代码块

public class Demo{
   static {
      System.out.println("静态代码块");
   }
   public static Demo demo = new Demo();
   {
      System.out.println("普通代码块");
   }
    public static void main(String[] args){
       Demo demo1 = new Demo();
    }
}

静态块定义先与静态属性
输出结果为：静态代码块 普通代码块 普通代码块

42 如下代码执行结果为（）
A 输出结果：13
B 语句：b3 = (b1+b2);编译出错
C 语句：b4 = b5+b6;编译出错
D 运行期抛出异常

public static void main(String[] args){
    byte b1 = 1,b2 = 2,b3,b4;
    final byte b5 = 5,b6 = 6;
    b3 = (b1+b2);
    b4 = b5+b6;
}

Correct Answer: B
解析：
1）final修饰的变量会被JVM优化 视为常量 数据类型不会发生自动提升
final修饰后 空间大小 和 值 都不能改变
2）常量是存储在常量区中 变量是在栈内存中
而常量区的内存空间是32bit位的
对于byte b1 = 1;
b1为变量 存在栈内存中
1为常量 存在常量区中
b1 = 1 是把常量区中的值复制一份存入b1的变量空间中
发现byte只能存8位 那么 = 在经过判断后 会把常量1中的前24bit位砍掉再存入
对于int a = 1; byte b1 = a;
这时候会出现编译时异常
因为a是变量 在编译之前是未知的
所以就无法确定其空间大小和值 那么 = 就无法进行判断
所以就会显示编译时异常
3）b3 = （b1+b2）
因为b1和b2都是byte类型的 空间大小为8bit
但是在做运算时会在临时的执行空间进行运算 而临时的执行空间是32bit的
也就是b1+b2做运算时 会自动的类型提升 变为32bit的 而b3为8bit的 存不下
所以就会显示编译时异常
4）b4 = b5+b6
因为b5和b6是byte类型的 且是final修饰的 空间大小为8bit
所以即使临时执行空间是32bit
但final修饰的变量空间大小不会改变 即数据类型不会发生自动提升
b5+b6结果仍然是8bit 那么就可以存入b4

43 下列说法正确的是（）
A 在类方法中可用this来调用本类的类方法
B 在类方法中调用本类的类方法时可直接调用
C 在类方法中只能调用本类的类方法
D 在类方法中绝对不能调用实例方法
Correct Answer: B
解析：
1）类方法即为static修饰的方法
普通方法叫对象方法
2）在类方法中不可以使用this关键字

44 一般情况下，以下哪些选项不是关系数据模型与对象模型之间匹配关系？
A 表对应类
B 记录对应对象
C 表的字段对应类的属性
D 表之间的参考关系对应类之间的依赖关系
Correct Answer: D
解析：
ORM框架

45 jdk1.8中，下面有关java抽象类和接口的区别，说法错误的是？（多选）
A 抽象类可以有构造方法 接口中不能有构造方法
B 抽象类可以包含非抽象的普通方法 接口中的方必须是抽象的 不能有非抽象的普通方法
C 一个类可以实现多个接口 但只能继承一个抽象类
D 接口中可以有普通成员变量 抽象类没有普通成员变量
Correct Answer: BD
解析：
1）Java中一个类只能继承一个类 但是一个接口可以继承多个接口 注意不是实现
2）jdk1.8中 可以允许接口定义默认方法（default）、类方法（static）
3）jdk1.9中 可以允许接口定义为private类型的

46 下面那个语句是创建数组的正确语句？（多选）
A float f[][] = new float[6][6];
B float []f[] = new float[6][6];
C float f[][] = new float[][6];
D float [][]f = new float[6][6];
E float [][]f = new float[6][];
Correct Answer: ABDE

47 关于Java的一些概念，下面那些描述时正确的
A 所有的Java异常和错误的基类都是java.lang.Exception 包括java.lang.RuntimeException
B 通过try…catch…finally语句 finally中的语句不管发生什么异常都会得到执行
C Java中所有的数据都是对象
D Java通过垃圾回收不再引用的变量 垃圾回收时对象的finallize方法一定会得到执行
E Java是跨平台语言 无论通过哪个版本的Java编写的程序都能在所有的Java运行平台执行
F Java通过synchronized进行访问的同步 synchronized作用非静态成员方法和静态成员方法上同步的目标是不同的
Correct Answer: BF
解析：
1）Exception与Error的基类是Throwable
2）C选项 基本类型不是对象
3）
4）采用高版本JDK编写的程序 在低版本的JRE中无法运行
5） synchronized作用非静态成员方法锁的是对象 即 对象锁
synchronized作用静态成员方法锁的是类 即 类锁

48 下面代码，以下说法正确的是（）
A 同一个对象 分别调用方法a和b 锁住的是同一个对象
B 同一个对象 分别调用方法a和c 锁住的是同一个对象
C 同一个对象 分别调用方法b和c 锁住的不是同一个对象
D 同一个对象 分别调用方法a、b、c 锁住的不是同一个对象

public class Demo{
    private synchronized void a(){}
    private void b(){
        synchronized (this){}
    }
    private synchronized static void c(){}
    private void d(){
        synchronized(Demo.class){}
    }
}

Correct Answer: AC
解析：

49 如下代码运行结果（）
A 1 1
B 1.0 1.0
C 1 1.0
D 1.0 1

    public static void main(String[] args){
        Object o1 = true?new Integer(1):new Double(2.0);
        Object o2;
        if (true){
            o2 = new Integer(1);
        }else{
            o2 = new Double(2.0);
        }
        System.out.println(o1);
        System.out.println(o2);
    }

Correct Answer: D
解析：
三元操作符类型的转换规则：
1）若两个操作数不可转换 则不做转换 返回值为Object类型
2）若两个操作数是明确类型的表达式（比如变量） 则按照正常的二进制数字来转换 int类型转换为long类型 long类型转换为float类型等
3）若两个操作数中有一个是数字S 另外一个是表达式
假设表达式类型标示为T 那么当数字S在T的范围内 则转换为T类型
若S超出了T类型的范围 则T转换为S类型
4）若两个操作数都是直接量数字 则返回值类型为范围较大者
即 三目运算符会对两个结果的数据类型进行自动的数据提升
自动将结果转换为两个结果中表示范围更大的那个类型

50 下列存储键值对的类，哪个提供了基本的多线程安全支持（）
A java.util.ConcurrentHashMap
B java.util.Map
C java.util.TreeMap
D java.util.SortMap
E java.util.HashTable
F java.util.HashMap
Correct Answer: AE
解析：
线程安全的map有HashTable、SynchronizedMap、ConcurrentHashMap

51 HashMap和HashTale的区别

52 以下代码执行结果为（）
A Son.test()flag=1
Son.Son()flag=5
B Son.Son()flag=5
Son.test()flag=5
C Son.test()flag=0
Son.Son()flag=5
D Super.test()flag=1
Son.Son()flag=5

public class Demo{
    class Super{
        int flag = 1;
        Super(){
            test();
        }
        void test(){
            System.out.println("Super.test()flag="+flag);
        }
    }
    class Son extends Super{
        Son(int x){
            flag = x;
            System.out.println("Son.Son()flag="+flag);
        }
        void test(){
            System.out.println("Son.test()flag="+flag);
        }
    }
    public static void main(String[] args){
        new Demo().new Son(5);
    }
}

Correct Answer: A
解析：

1.加载父类
2.父类产生自己的静态空间
加载静态空间时的顺序 加载属性 加载方法 加载块 执行静态块
3.加载子类
4.子类产生自己的静态空间 加载属性 加载方法 加载块 执行静态块
5.开辟对象空间
6.加载父类中的非静态成员 属性 方法 块 构造方法
7. 执行块 执行构造方法
8.加载子类中的非静态成员 属性 方法 块 构造方法
9. 执行块 执行构造方法
对于本题来说 在new Son(5)的时候 父类先初始化了 int flag = 1
然后执行父类的构造函数Super（）而父类构造函数中执行的test（）方法
因为这里new的是子类对象 且子类重写了test（）方法
因此父类构造函数中的test（）方法实际执行的是子类的test（）方法
所以输出为Son.test() flag=1
接着执行子类构造函数Sub(5) 将flag赋值为5
因此输出结果Sub.Sub() flag=5

53 如下代码运行结果为（）
A 编译出错
B true
C false
D 什么也没有输出
Bolean flag = false;
if(flag = true){
System.out.println(“true”);
}else{
System.out.println(“false”);
}
Correct Answer: B
解析：

if语句判断条件需要为布尔类型的 而flag恰为布尔类型 所以相当于把true赋值给flag
所以判断条件就是true

54 如下代码运行结果为（）
A 循环体一次也不执行
B 循环体执行一次 是无限循环
C 有限次循环
D 循环结束判断条件不合法 运行出错
for( m = 0,n = -1;n = 0;m++,n++）
n++;
Correct Answer: D
解析：
for(初始化语句 ; 判断条件语句 ; 控制条件语句){
循环执行体;
}
判断条件语句要为布尔类型的 所以这里不合法

55 下面哪个修饰符修饰的变量是所有同一个类生成的，所有对象共享的（）
A public
B private
C static
D final
Correct Answer: C
解析：

static修饰的变量归类所有 该类的所有对象共享
所以可以通过 类名来调用 也可以通过对象来调用

56 下面代码运行结果为（）
public class Test{
public static void main(String[] args){
String str = “”;
System.out.print(str.split(“,”).length());
}
}
输出结果为：
A. 0
B. 1
C. Compilation fails.
D. An exception is thrown at runtime.
Correct Answer: C
解析：

注意str.split(“,”) 得到的是一个数组 数组中只有length属性 没有length()方法
而若是 “”.length()才是对的 空串长度为0

57 What is the result?
public class WrappedString {
private String s;
public WrappedString(String s){
this.s = s;
}
public static void main(String[] args) {
HashSet