java笔记---javase常见易错笔试题及答案（长期更新）

1、下列java程序的输出结果为____。

public class Example{
    String str=new String("hello");
    char[]ch={'a','b'};
    public static void main(String args[]){
        Example ex=new Example();
        ex.change(ex.str,ex.ch);
        System.out.print(ex.str+" and ");
        System.out.print(ex.ch);
    }
    public void change(String str,char ch[]){
        str="test ok";
        ch[0]='c';
    }
}

正确答案: B 你的答案: F (错误)

A. hello and ab
B. hello and cb
C. hello and a
D. test ok and ab
E. test ok and cb
F. test ok and c

解析：
String类是不可变的，不能继承和修改这个类。str=“tesk ok”，其实是隐含的让Java生成一个新的String对象，那么就与原来的“Hello”没有任何关系，当函数结束，str作用结束，所以输出的还是“Hello”。 char ch[] 是传递引用，修改了原内容。

2、给出以下代码

public class TestObj{
    public static void main(String[] args){
        Object o=new Object(){
            public boolean equals(Object obj){
                return true;
            }
        };
        System.out.println(o.equals(“Fred”));
    }
}

请给出结果：（）
正确答案: B 你的答案: D (错误)

A. 运行时抛出异常
B. true
C. Fred
D. 第三行编译错误

解析：创建了一个匿名内部类，并将所创建的匿名对象赋给 Objec同时，该匿名内部类重写了 Object 类的 equals 方法。任何情况下都返回true。

3、关于protected 修饰的成员变量，以下说法正确的是
正确答案: A 你的答案: B (错误)

A. 可以被该类自身、与它在同一个包中的其它类、在其它包中的该类的子类所访问
B. 只能被该类本身和该类的所有的子类访问
C. 只能被该类自身所访问
D. 只能被同一个包中的类访问

解析：

                public   protected   默认   private
同一个类            Y          Y       Y        Y
同一个包            Y          Y       Y        N
不同包的子类         Y          Y       N        N
不同包的非子类       Y          N       N        N

4、下面哪种情况会导致持久区jvm堆内存溢出？
正确答案: C 你的答案: D (错误)

A. 循环上万次的字符串处理
B. 在一段代码内申请上百M甚至上G的内存
C. 使用CGLib技术直接操作字节码运行，生成大量的动态类
D. 不断创建对象

解析：

java的堆内存分为两块:permantspace（持久带） 和 heap space。
持久带中主要存放用于存放静态类型数据，如 Java Class, Method 等， 与垃圾收集器要收集的Java对象关系不大。
而heapspace分为年轻带和年老带 
年轻代的垃圾回收叫 Young GC， 年老代的垃圾回收叫 Full GC。
在年轻代中经历了N次（可配置）垃圾回收后仍然存活的对象，就会被复制到年老代中。因此，可以认为年老代中存放的都是一些生命周期较长的对象
年老代溢出原因有  循环上万次的字符串处理、创建上千万个对象、在一段代码内申请上百M甚至上G的内存，既A B D选项
持久代溢出原因  动态加载了大量Java类而导致溢出

5、执行以下程序，最终输出可能是：
*代表空格
正确答案: C 你的答案: B (错误)

A. 010 2123012 3434
B. 01201 340124 2334
C. 0012314 01223344**
D. 12345 12345 12345

解析：

第一个空格之前必然有 0 1 2 3 4 这四个数字，这是因为第一个空格出现，意味着第一个线程执行完毕，
必然会打印这四个数字。又因为线程并发执行，所以后面两个线程个别数字可能会提前打印。

6、下面哪个不对？
正确的答案：C你的答案：A （错误）

A. RuntimeException是在Java虚拟机的正常操作期间可能引发的那些异常的超类。
B. 方法不需要在其throws子句中声明在方法执行期间可能抛出但未被捕获的RuntimeExeption的任何子类。
C. RuntimeException是Throwable的子类，它指示合理的应用程序不应尝试捕获的严重问题。
D. NullPointerException是RuntimeException的一种

解析：

7、下面哪些赋值语句是正确的（）

正确答案: A B D 你的答案: A (错误)

A. long test=012
B. float f=-412
C. int other =(int)true
D. double d=0x12345678
E. byte b=128

解析：

A：012，int转long，低转高                                         正确
B：-412，默认是int，int转float，低转高                             正确
C：不同的类型不能转                                                错误
D：0x12345678，16进制的123456，默认是int，int转double，低转高        正确
E：byte默认范围是(-128 ~ 127)                                     错误

8、java是一门支持反射的语言,基于反射为Java提供了丰富的动态性支持，下面关于Java反射的描述，哪些是错误的：( )
正确答案: A D F 你的答案: B D (错误)

A. Java反射主要涉及的类如Class, Method, Filed,等，他们都在java.lang.reflet包下
B. 通过反射可以动态的实现一个接口，形成一个新的类，并可以用这个类创建对象，调用对象方法
C. 通过反射，可以突破Java语言提供的对象成员、类成员的保护机制，访问一般方式不能访问的成员
D. Java反射机制提供了字节码修改的技术，可以动态的修剪一个类
E. Java的反射机制会给内存带来额外的开销。例如对永生堆的要求比不通过反射要求的更多
F. Java反射机制一般会带来效率问题，效率问题主要发生在查找类的方法和字段对象，因此通过缓存需要反射类的字段和方法就能达到与之间调用类的方法和访问类的字段一样的效率

解析：

Class在java.lang包下， Java反射机制一般会带来效率问题，性能会降低。

9、代码 的运行结果是（）

package com.sunline.java;
public class A implements B extends C{
    public static void main(String args[]){
        System.out.println("hello sunline!");
    }
}

正确答案: C 你的答案: B (错误)

A. 在控制台打印hello sunline！
B. 报异常java.lang.NullPoninterException
C. 编译报错
D. 报异常java.lang.RuntimeExcception

解析：

Java 中单实现通过 implements 关键字，多实现通过 extends 关键字。Java 中单继承通过 extends 关键字，没有多继承。如果同时出现继承和实现，则必须先继承（extends）再实现（implements）

10、下列关于java并发的说法中正确的是：
正确答案: B 你的答案: 空 (错误)

A. copyonwritearraylist适用于写多读少的并发场景
B. readwritelock适用于读多写少的并发场景
C. concurrenthashmap的写操作不需要加锁，读操作需要加锁
D. 只要在定义int类型的成员变量i的时候加上volatile关键字，那么多线程并发执行i++这样的操作的时候就是线程安全的了

解析：

CopyOnWriteArrayList适合使用在读操作远远大于写操作的场景里，比如缓存。
ReadWriteLock 当写操作时，其他线程无法读取或写入数据，而当读操作时，其它线程无法写入数据，但却可以读取数据 。适用于 读取远远大于写入的操作。
ConcurrentHashMap是一个线程安全的Hash Table，它的主要功能是提供了一组和HashTable功能相同但是线程安全的方法。ConcurrentHashMap可以做到读取数据不加锁，并且其内部的结构可以让其在进行写操作的时候能够将锁的粒度保持地尽量地小，不用对整个ConcurrentHashMap加锁。
volatile只能保证变量的安全，不能保证线程的安全。

11、下面哪些描述是正确的：（ ）

public class Test {
public static class A {
private B ref;
public void setB(B b) {
ref = b;
}
}
public static Class B {
private A ref;
public void setA(A a) {
ref = a;
}
}
public static void main(String args[]) {
…
start();
….
}
public static void start() { A a = new A();
B b = new B();
a.setB(b);
b = null; //
a = null;
…
}
}

正确答案: B C 你的答案: 空 (错误)
A. b = null执行后b可以被垃圾回收
B. a = null执行后b可以被垃圾回收
C. a = null执行后a可以被垃圾回收
D. a,b必须在整个程序结束后才能被垃圾回收
E. 类A和类B在设计上有循环引用，会导致内存泄露
F. a, b 必须在start方法执行完毕才能被垃圾回收

解析：

a引用指向一块空间，这块空间里面包含着b对象
b引用指向一块空间，这块空间是b对象
A选项，b = null执行后b可以被垃圾回收。这里"b可以被垃圾回收"中的b指的是引用b指向的内存。这块内存即使不被引用b指向，还是被引用a指向着，不会被回收。
B选项，a = null执行后b可以被垃圾回收。从代码中可以看到，a = null是在b = null后执行的，该行执行后，引用a和b都没有指向对象，对象会被回收。
C选项，同理。

12、以下哪种方式实现的单例是线程安全的
正确答案: A B C D 你的答案: B D (错误)

A. 枚举
B. 静态内部类
C. 双检锁模式
D. 饿汉式

解析：

1.饿汉式(线程安全，调用效率高，但是不能延时加载)；
2.懒汉式(线程安全，调用效率不高，但是能延时加载)；
3.Double CheckLock实现单例：DCL也就是双重锁判断机制（由于JVM底层模型原因，偶尔会出问题，不建议使用）；
4.静态内部类实现模式（线程安全，调用效率高，可以延时加载）； 
5.枚举类（线程安全，调用效率高，不能延时加载，可以天然的防止反射和反序列化调用）。

13、关于继承和实现说法正确的 是 ？ ( )
正确答案: A 你的答案: B (错误)

A. 类可以实现多个接口，接口可以继承（或扩展）多个接口
B. 类可以实现多个接口，接口不能继承（或扩展）多个接口
C. 类和接口都可以实现多个接口
D. 类和接口都不可以实现多个接口

解析：

类与类之间的关系为继承，只能单继承，但可以多层继承。 类与接口之间的关系为实现，既可以单实现，也可以多实
现。接口与接口之间的关系为继承，既可以单继承，也可以多继承。

14、下面程序的运行结果：()

public static void main(String args[]) {
        Thread t=new Thread(){
        public void  run(){
            dianping();
             
        }
    };
    t.run();
    System.out.print("dazhong");
    }
    static void dianping(){
        System.out.print("dianping");
}

正确答案: B 你的答案: C (错误)

A. dazhongdianping
B. dianpingdazhong
C. a和b都有可能
D. dianping循环输出，dazhong夹杂在中间

解析：

在上面main()方法中，并没有创建一个新的线程，只是简单地方法调用而已，如果想要创建线程，需要t.start();创建线程，等待cpu时间片，而run()方法只是简单地方法调用，所以先执行run()，在输出dazhong

15、以下程序段的输出结果为：

public class EqualsMethod
{
    public static void main(String[] args)
    {
        Integer n1 = new Integer(47);
        Integer n2 = new Integer(47);
        System.out.print(n1 == n2);
        System.out.print(",");
        System.out.println(n1 != n2);
    }
}

正确答案: B 你的答案: C (错误)

A. false，false
B. false，true
C. true，false
D. true，true

16、假定Base b = new Derived（）; 调用执行b.methodOne（）后，输出结果是什么？

public class Base
{
public void methodOne()
{
System.out.print("A");
methodTwo();
}
 
public void methodTwo()
{
System.out.print("B");
}
}
 
public class Derived extends Base
{
public void methodOne()
{
super.methodOne();
System.out.print("C");
}
 
public void methodTwo()
{
super.methodTwo();
System.out.print("D");
}
}

正确答案: A 你的答案: D (错误)

A. ABDC
B. AB
C. ABCD
D. ABC

解析：

不管是methodTwo（）还是this.methodTwo()都是父类类型Base 的Derived（多态），只有super才会直接使用父类的对
象方法，所以父类中的methodTwo()是调用Derived对象的

17、在Java中，对于不再使用的内存资源，如调用完成的方法，“垃圾回收器”会自动将其释放。（ ）
正确答案: B 你的答案: A (错误)

A. 正确
B. 错误

解析：

方法调用时，会创建栈帧在栈中，调用完是程序自动出栈释放，而不是gc释放，gc释放的一般是对象。

18、在JAVA中，下列哪些是Object类的方法（）
正确答案: B C D 你的答案: B C D E (错误)

A. synchronized()
B. wait()
C. notify()
D. notifyAll()
E. sleep()

解析：

A.Synchronized是一个关键字不是方法
E.sleep()是Thread的方法。对了，sleep与wait的区别经常出题

19、
下面程序的输出是:()

String x="fmn";
x.toUpperCase();
String y=x.replace('f','F');
y=y+"wxy";
System.out.println(y);

正确答案: D 你的答案: A (错误)

A. FmNwxy
B. fmnwxy
C. wxyfmn
D. Fmnwxy

解析：

本题主要考察String对象的不可变性。
toUpperCase()会对当前对象进行检查 如果不需要转换直接返回当前对象，否则new一个新对象返回；
replace()如果两个参数相同，则直接返回，否则new一个新对象，所以这里y指向"Fmn";
y=y+"wxy" 这里修改y所指向的字符串对象，让它由指向"Fmn"变成指向"Fmnxyz".

20、运行下面代码，输出的结果是（）

class A {
    public A() {
        System.out.println("class A");
    }
    { System.out.println("I'm A class"); } 
    static { System.out.println("class A static"); }
}
public class B extends A {
    public B() {
        System.out.println("class B");
    }
    { System.out.println("I'm B class"); }
    static { System.out.println("class B static"); }
     
    public static void main(String[] args) { 
 new B(); 
}
}

正确答案: A 你的答案: B (错误)

A. class A static
   class B static
   I'm A class
   class A
   I'm B class
   class B

B. class A static
   I'm A class
   class A
   class B static
   I'm B class
   class B

C. class A static
   class B static
   class A
   I'm A class
   class B
   I'm B class

D. class A static
   class A
   I'm A class
   class B static
   class B
   I'm B class

解析：

Java程序初始化顺序：
父类的静态代码块
子类的静态代码块
父类的普通代码块
父类的构造方法
子类的普通代码块
子类的构造方法

21、下列代码执行结果为（）

public static void main(String args[])throws InterruptedException{
            Thread t=new Thread(new Runnable() {
                public void run() {
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    System.out.print("2");
                }
            });
            t.start();
             
            t.join();
            System.out.print("1");
        }

正确答案: A 你的答案: C (错误)

A. 21
B. 12
C. 可能为12，也可能为21
D. 以上答案都不对

解析：

因为子线程的休眠时间太长，因此主线程很有可能在子线程之前结束也就是输出结果是12，但是子线程用了join函
数，因此主线程必须等待子线程执行完毕才结束因此输出结果只能是21

22、关于Spring MVC的核心控制器DispatcherServlet的作用，以下说法错误的是（ ）？

正确答案: C 你的答案: A (错误)

A. 它负责处理HTTP请求
B. 加载配置文件
C. 实现业务操作
D. 初始化上下应用对象ApplicationContext

解析：

23、有一个源代码，只包含import java.util.* ; 这一个import语句，下面叙述正确的是？ ( )
正确答案: C 你的答案: B (错误)

A. 只能写在源代码的第一句
B. 可以访问java/util目录下及其子目录下的所有类
C. 能访问java/util目录下的所有类，不能访问java/util子目录下的所有类
D. 编译错误

解析：

导入java.util.*不能读取其子目录的类，因为如果java.util里面有个a类，java.util.regex里面也有个a类，
我们若是要调用a类的方法或属性时，应该使用哪个a类呢。所以也应该选C

24、
关于下面的程序Test.java说法正确的是( )。

public class Test {
    static String x="1";
    static int y=1;
    public static void main(String args[]) {
        static int z=2;
        System.out.println(x+y+z);
    }
}

正确答案: D 你的答案: B (错误)

A. 3
B. 112
C. 13
D. 程序有编译错误

25、下面有关 java 类加载器,说法正确的是?()
正确答案: A B C D 你的答案: 空 (错误)

A. 引导类加载器(bootstrap class loader):它用来加载 Java 的核心库,是用原生代码来实现的
B. 扩展类加载器(extensions class loader):它用来加载 Java 的扩展库。
C. 系统类加载器(system class loader):它根据 Java 应用的类路径(CLASSPATH)来加载 Java 类
D. tomcat 为每个 App 创建一个 Loader,里面保存着此 WebApp 的 ClassLoader。需要加载 WebApp 下的类时,就取出 ClassLoader 来使用

解析：

类的加载是由类加载器完成的，类加载器包括：根加载器（ BootStrap ）、扩展加载器（ Extension ）、系统加
载器（ System ）和用户自定义类加载器（ java.lang.ClassLoader 的子类）。从 Java 2 （ JDK 1.2 ）
开始，类加载过程采取了父亲委托机制（ PDM ）。 PDM 更好的保证了 Java 平台的安全性，在该机制中， JVM 自带的 Bootstrap 是根加载器，其他的加载器都有且仅有一个父类加载器。类的加载首先请求父类加载器加载，父类加载器无能为力时才由其子类加载器自行加载。 JVM 不会向 Java 程序提供对 Bootstrap 的引用。下面是关于几个类加载器的说明：
Bootstrap ：一般用本地代码实现，负责加载 JVM 基础核心类库（ rt.jar ）；
Extension ：从 java.ext.dirs 系统属性所指定的目录中加载类库，它的父加载器是 Bootstrap ；
system class loader ：又叫应用类加载器，其父类是 Extension 。它是应用最广泛的类加载器。它从环境变量 classpath 或者系统属性 java.class.path 所指定的目录中记载类，是用户自定义加载器的默认父加载器。
用户自定义类加载器： java.lang.ClassLoader 的子类 
父类委托机制是可以修改的，有些服务器就是自定义类加载器优先的。

26、java 接口的修饰符可以为（）
正确答案: D 你的答案: C (错误)

A. private
B. protected
C. final
D. abstract

解析：

接口是通用的，用来描述方法是干什么用的，方法的默认修饰符为public abstract.不可以为final 是因为方法要
被重写， 描述符如果为private或者protected，那么子类重写的方法的描述符也可以为private或者
protected，这样就是有了访问显示，不符合接口所要达到的的任何人都可以使用了

27、
下列关于计算机系统和Java编程语言的说法，正确的是（）

A. 计算机是由硬件、操作系统和软件组成，操作系统是缺一不可的组成部分。
B. Java语言编写的程序源代码可以不需要编译直接在硬件上运行。
C. 在程序中书写注释不会影响程序的执行，可以在必要的地方多写一些注释。
D. Java的集成开发环境（IDE），如Eclipse，是开发Java语言必需的软件工具。

解析：

裸机也可以跑,以前搞嵌入式的时候,并不一定要安装操作系统,直接操作寄存器就可以了,操作系统不是必须的。
计算机是由硬件和软件组成，操作系统是软件部分。
没有IDE，用txt和javac也可以写java

28、编译并执行以下代码片段的结果是什么：

Boolean flag = false;
if (flag = true)
{
    System.out.println(“true”);
}
else
{
    System.out.println(“false”);
}

正确的答案：C你的答案：空 （错误）

A. 该代码无法在“ if”语句处编译。
B. 运行时在“ if”语句中引发异常。
C. 显示文本“ true”。
D. 显示文本“ false”。
E. 什么都没有显示。

if（flag = true）{
}
中，只是一个赋值语句=======》隐含条件为
if（（flag = true）== true）{
}

29、What will happen when you attempt to compile and run the following code?

public class Test{
static{
   int x=5;
}
static int x,y;
public static void main(String args[]){
   x--;
   myMethod( );
   System.out.println(x+y+ ++x);
}
public static void myMethod( ){
  y=x++ + ++x;
 }
}

正确答案: D 你的答案: C (错误)

A. compiletime error
B. prints:1
C. prints:2
D. prints:3
E. prints:7
F. prints:8

解析：

1.静态语句块中x为局部变量，不影响静态变量x的值
2.x和y为静态变量，默认初始值为0，属于当前类，其值得改变会影响整个类运行。
3.java中自增操作非原子性的 
main方法中：
执行x--后 x=-1
调用myMethod方法，x执行x++结果为-1(后++)，但x=0，++x结果1，x=1 ，则y=0
x+y+ ++x,先执行x+y，结果为1，执行++x结果为2，得到最终结果为3

30、局部内部类可以用哪些修饰符修饰？
正确答案: C D 你的答案: B D (错误)

A. public
B. private
C. abstract
D. final

解析：

31、关于依赖注入，下列选项中说法错误的是（）

A. 依赖注入能够独立开发各组件，然后根据组件间关系进行组装
B. 依赖注入使组件之间相互依赖，相互制约
C. 依赖注入提供使用接口编程
D. 依赖注入指对象在使用时动态注入

解析：

依赖注入（Dependency Injection，简称DI）是一个重要的面向对象编程的法则来削减计算机程序的耦合问题。

32、AccessViolationException异常触发后，下列程序的输出结果为（ ）

static void Main(string[] args)  
{  
    try  
    {  
        throw new AccessViolationException();  
        Console.WriteLine("error1");  
    }  
    catch (Exception e)  
    {  
        Console.WriteLine("error2");  
    }  
    Console.WriteLine("error3");  
} 

正确答案: A 你的答案: C (错误)

A. error2
    error3
B. error3
C. error2
D. error1

33、以下说法错误的是（）

A. 虚拟机中没有泛型，只有普通类和普通方法
B. 所有泛型类的类型参数在编译时都会被擦除
C. 创建泛型对象时请指明类型，让编译器尽早的做参数检查
D. 泛型的类型擦除机制意味着不能在运行时动态获取List<T>中T的实际类型

解析：

D通过反射可以得到。

34、在java中重写方法应遵循规则的包括（）
正确答案: B C 你的答案: A C (错误)

A. 访问修饰符的限制一定要大于被重写方法的访问修饰符
B. 可以有不同的访问修饰符
C. 参数列表必须完全与被重写的方法相同
D. 必须具有不同的参数列表

解析：

方法的重写（override）两同两小一大原则：
方法名相同，参数类型相同
子类返回类型小于等于父类方法返回类型，
子类抛出异常小于等于父类方法抛出异常，
子类访问权限大于等于父类方法访问权限。

35、java运行时内存分为“线程共享”和“线程私有”两部分，以下哪些属于“线程共享”部分
正确答案: B D 你的答案: A B D (错误)

A. 程序计算器
B. 方法区
C. java虚拟机栈
D. java堆

解析：

私有线程区域：程序计数器、虚拟机栈、本地方法栈
线程共享区域：堆、方法区

36、关于多线程和多进程，下面描述正确的是（）：
正确答案: A C 你的答案: A B (错误)

A. 多进程里，子进程可获得父进程的所有堆和栈的数据；而线程会与同进程的其他线程共享数据，拥有自己的栈空间。
B. 线程因为有自己的独立栈空间且共享数据，所有执行的开销相对较大，同时不利于资源管理和保护。
C. 线程的通信速度更快，切换更快，因为他们在同一地址空间内。
D. 一个线程可以属于多个进程。

解析：

1、一个线程只能属于一个进程，而一个进程可以有多个线程，但至少有一个线程（通常说的主线程）。
2、资源分配给进程，同一进程的所有线程共享该进程的所有资源。
3、线程在执行过程中，需要协作同步。不同进程的线程间要利用消息通信的办法实现同步。
4、处理机分给线程，即真正在处理机上运行的是线程。
5、线程是指进程内的一个执行单元，也是进程内的可调度实体。

37、以下哪些jvm的垃圾回收方式采用的是复制算法回收
正确答案: A D 你的答案: B E (错误)

A. 新生代串行收集器
B. 老年代串行收集器
C. 并行收集器
D. 新生代并行回收收集器
E. 老年代并行回收收集器
F. cms收集器

解析：

复制算法：两个区域A和B，初始对象在A，继续存活的对象被转移到B。此为新生代最常用的算法
新生代：初始对象，生命周期短的，要清理的对象多。

38、

byte b1=1,b2=2,b3,b6,b8;
final byte b4=4,b5=6,b7;
b3=(b1+b2);  /*语句1*/
b6=b4+b5;    /*语句2*/
b8=(b1+b4);  /*语句3*/
b7=(b2+b5);  /*语句4*/
System.out.println(b3+b6);

下列代码片段中，存在编译错误的语句是()
正确答案: B C D 你的答案: A D (错误)

A. 语句2
B. 语句1
C. 语句3
D. 语句4

解析：

ava表达式转型规则由低到高转换：
1、所有的byte,short,char型的值将被提升为int型；
2、如果有一个操作数是long型，计算结果是long型；
3、如果有一个操作数是float型，计算结果是float型；
4、如果有一个操作数是double型，计算结果是double型；
5、被fianl修饰的变量不会自动改变类型，当2个final修饰相操作时，结果会根据左边变量的类型而转化。
--------------解析--------------
语句1错误：b3=(b1+b2);自动转为int，所以正确写法为b3=(byte)(b1+b2);或者将b3定义为int；
语句2正确：b6=b4+b5;b4、b5为final类型，不会自动提升，所以和的类型视左边变量类型而定，即b6可以是任意数值类型；
语句3错误：b8=(b1+b4);虽然b4不会自动提升，但b1仍会自动提升，所以结果需要强转，b8=(byte)(b1+b4);
语句4错误：b7=(b2+b5); 同上。同时注意b7是final修饰，即只可赋值一次，便不可再改变。

39、对于子类的构造函数说明，下列叙述中错误的是（ ）。
正确答案: A 你的答案: D (错误)

A. 子类可以继承父类的构造函数。
B. 子类中调用父类构造函数不可以直接书写父类构造函数，而应该用super();。
C. 用new创建子类的对象时，若子类没有带参构造函数，将先执行父类的无参构造函数，然后再执行自己的构造函数。
D. 子类的构造函数中可以调用其他函数。

解析：

java继承中对构造函数是不继承的，只是显式或者隐式调用

40、麦秋时节，庄园主雇了个力大无穷的农民来帮他收割田里的麦子。收获的劳动量很大，农民必须在七天之内收割完。庄园主答应每天给他一块金块作工钱。但是这七块相等的金子是连在一起的，然而工钱是必须每天结清的。农民不愿意庄园主欠帐，而庄园主也不肯预付一天工钱。请问最少掰金子几次可以完成上述任务？
正确答案: A 你的答案: C (错误)

A. 2
B. 3
C. 4
D. 7

41、What results from the following code fragment?

int i = 5;
int j = 10;
System.out.println(i + ~j);

正确答案: C 你的答案: A (错误)

A. Compilation error because”~”doesn’t operate on integers
B. -5
C. -6
D. 15

解析：

10原码：0000000000000000,0000000000001010；
~10： 1111111111111111,1111111111110101  变为负数，计算机用补码存储
~10反码：10000000000000000,0000000000001010
~10补码：10000000000000000,0000000000001011，等于 -11
故程序结果-6

42、针对以下代码，哪些选项执行后是true的：（）

class CompareReference{
   public static void main(String [] args){
   float f=42.0f;
   float f1[]=new float[2];
   float f2[]=new float[2];
   float[] f3=f1;
   long x=42;
   f1[0]=42.0f;
  }
}

正确答案: B C 你的答案: B (错误)

A. f1==f2
B. x==f1[0]
C. f1==f3
D. f2==f1[1]

解析：

C，f1 == f3，f3没有new创建，而是由f1赋值，所以f3地址是指向f1的，f1值改变，相当于改变f3值，所以相等。