Java测试错题题解

博主声明：
本文由博主luoru_LR原创，请多支持与指教。
转载请在开头附加本文链接及作者信息，并标记为转载。
博主主页

假定Base b = new Derived（）; 调用执行b.methodOne（）后，输出结果是什么？		正确答案：A
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.ABDC
B.AB
C.ABCD
D.ABC
解析：
	这是一道类多态的向上转型题。
	Base b = new Derived();
	向上转型：父类只能调用父类方法或者子类覆写后的方法,而子类中的单独方法则是无法调用的。 

（多选）关于身份证号，以下正确的正则表达式为（  ）	正确答案：AC
A.isIDCard=/^[1-9]\d{7}((0\d)|(1[0-2]))(([0|1|2]\d)|3[0-1])\d{3}$/;
B.isIDCard=/^[1-9]\d{7}((9\d)|(1[0-2]))(([0|1|2]\d)|3[9-1])\d{3}$/;
C.isIDCard=/^[1-9]\d{5}[1-9]\d{3}((0\d)|(1[0-2]))(([0|1|2]\d)|3[0-1])\d{4}$/;
D.isIDCard=/^[1-9]\d{5}[1-9]\d{3}((9\d)|(1[9-2]))(([0|1|2]\d)|3[9-1])\d{4}$/;
解析：
	A选项是15位身份证的正则表达式
	C选项是18位身份证的正则表达式
	15位身份证的构成：六位出生地区码+六位出身日期码+三位顺序码
	18位身份证的构成：六位出生地区码+八位出生日期码+三位顺序码+一位校验码

（多选）以下哪些方法是Object类中的方法	正确答案：ABCD
A.clone()
B.toString()
C.wait()
D.finalize()
	解析：API中这四个方法都是Object的方法

（多选）下面关于volatile的功能说法正确的是哪个	正确答案：BC
A.原子性
B.有序性
C.可见性
D.持久性
解析：
	synchronized保证三大性，原子性，有序性，可见性，volatile保证有序性，可见性，不能保证原子性

（多选）以下程序执行后，错误的结果是（）	正确答案：ABC
public class Test {
    private String name = "abc";
    public static void main(String[] args) {
        Test test = new Test();
        Test testB = new Test();
        String result = test.equals(testB) + ",";
        result += test.name.equals(testB.name) + ",";
        result += test.name == testB.name;
        System.out.println(result);
    }
}

A.true,true,true
B.true,false,false
C.false,true,false
D.false,true,true
解析：
	1、首先应该注意到作为成员变量的 name 是使用字面量直接赋值的 （ privateString name 
	="abc"; ） 这种赋值的执行过程是先看字符串常量池中有没有 value 数组为 ['a', 'b', 'c'] 的 String
	对象，如果没有的话就创建一个，有的话就拿到他的一个引用。
	2、name 没有被static 修饰，所以每实例化一个对象都会执行 private String name ="abc"; 第一
	次执行的时候发现字符串常量池没有 value 数组为 ['a', 'b', 'c']的String 对象，所以创建一个，拿到
	他的一个引用，但是第二次的时候发现已经有了这样的对象了， 所以只是拿到这个拿到这个对象
	的一个引用而已。
	3、执行 test.name == testB.name; 的时候比较的是两个name指向的内存是不是同一个（比较引
	用本身没有意义），所以 test.name == testB.name; 的结果是true。

（多选）下面哪些具体实现类可以用于存储键，值对，并且方法调用提供了基本的
多线程安全支持：(  )		正确答案：AE
A.java.util.ConcurrentHashMap
B.java.util.Map
C.java.util.TreeMap
D.java.util.SortMap
E.java.util.Hashtable
F.java.util.HashMap
解析：
	线程安全的map:HashTable,SynchronizedMap,ConcurrentHashMap

jdbc的事务必须在一个数据库连接上完成。编程时必须去掉数据库的自动提交功能。当成功后调
用commit，当失败后调用rollback。判断这句话正确与否 		正确答案：A
A.T
B.F
解析：
	在JDBC编程模式中，一个数据库连接建立时，就处于一个自动提交模式，每一个SQL语句被执
	行完成后就会被自动提交，反映到数据库中。当需要把几条逻辑上相关的SQL组成的一个事务执
	行时，就需要关闭事务自动提交模式。如下面的语句所示： con.setAutoCommit(false); // 关闭自
	动提交模式 一旦关闭了事务自动提交模式，不会有任何SQL语句被提交至数据库系统执行，除非
	显式的调用提交方法。

（多选）关于下面的一段代码，以下哪些说法是正确的：		正确答案：AD
public static void main(String[] args) {
   String a = new String("myString");
    String b = "myString";
    String c = "my" + "String";
    String d = c;
    System.out.print(a == b);
    System.out.print(a == c);
    System.out.print(b == c);
    System.out.print(b == d);
}

A.System.out.print(a == b)打印出来的是false
B.System.out.print(a == c)打印出来的是true
C.System.out.print(b == c)打印出来的是false
D.System.out.print(b == d)打印出来的是true
解析：
	A：a指向堆内存，b指向常量池，因此地址不相等，false
	B：java有常量优化机制，c也指向常量池，且与b指向同一个，则a与c地址不相等,false；
	C：b与c地址相等，true
	D：d是c的副本，地址相同，所以b与d地址相等，true 

（多选）接口和抽象类描述正确的有（ ）	正确答案：BC
A.抽象类没有构造函数。
B.接口没有构造函数。
C.抽象类不允许多继承。
D.接口中的方法可以有方法体。
解析：
	jdk1.8后接口中用static或default修饰的方法可以有方法体，所以D选项也应该是正确的。

下面哪个行为被打断不会导致InterruptedException：（ ）？ 	正确答案：E
A.Thread.join
B.Thread.sleep
C.Object.wait
D.CyclicBarrier.await
E.Thread.suspend
解析：
	抛InterruptedException的代表方法有：
	java.lang.Object 类的 wait 方法
	java.lang.Thread 类的 sleep 方法
	java.lang.Thread 类的 join 方法

关于Java以下描述正确的有(  )		正确答案：CD
A.Class类是Object类的超类
B.Object类是一个final类
C.String类是一个final类
D.Class类可以装载其它类
解析：
	Object类是所有类的父类，所以Object类不能用final修饰（因为被final修饰的类不能被继承）
	String类是一个不变类，只有String是不可变的，才实现字符串常量池，节省空间，提高效率，同
	一个字符串常量被多个线程共享，实现线程安全

下面有个hibernate延迟加载，说法错误的是？		正确答案：C
A.Hibernate2延迟加载实现：a)实体对象 b)集合（Collection）
B.Hibernate3 提供了属性的延迟加载功能
C.get支持延迟加载，load不支持延迟加
D.hibernate使用Java反射机制，而不是字节码增强程序来实现透明性
解析：
	load方法来得到一个对象时，此时hibernate会使用延迟加载的机制来加载这个对象，即：当 我们
	使用session.load()方法来加载一个对象时，此时并不会发出sql语句，当前得到的这个对象其实是
	一个代理对象，这个代理对象只保存了实 体对象的id值，只有当我们要使用这个对象，得到其它
	属性时，这个时候才会发出sql语句，从数据库中去查询我们的对象。
	相对于load的延迟加载方式，get就直接的多，当我们使用session.get()方法来得到一个对象时
	不管我们使不使用这个对象，此时都会发出sql语句去从数据库中查询出来。

Which of the following can be applied to constructors: 		正确答案：E
A.final
B.static
C.synchronized
D.native
E.None of these.
解析：
	识别合法的构造方法；
	  1：构造方法可以被重载，一个构造方法可以通过this关键字调用另一个构造方法，this语句必须位于构造方法的第一行；
	    重载：方法的重载(overload)：重载构成的条件：方法的名称相同，但参数类型或参数个数不同，才能构成方法的重载。 
	  2 当一个类中没有定义任何构造方法，Java将自动提供一个缺省构造方法；
	  3 子类通过super关键字调用父类的一个构造方法；
	  4 当子类的某个构造方法没有通过super关键字调用父类的构造方法，通过这个构造方法创建子类对象时，会自动先调用父类的缺省构造方法
	  5 构造方法不能被static、final、synchronized、abstract、native修饰，但可以被public、private、protected修饰；
	  6 构造方法不是类的成员方法；
	  7 构造方法不能被继承。

关于ThreadLocal类 以下说法正确的是		正确答案：DE
A.ThreadLocal继承自Thread
B.ThreadLocal实现了Runnable接口
C.ThreadLocal重要作用在于多线程间的数据共享
D.ThreadLocal是采用哈希表的方式来为每个线程都提供一个变量的副本
E.ThreadLocal保证各个线程间数据安全，每个线程的数据不会被另外线程访问和破坏
解析：
	（1）、ThreadLocal的类声明：
	public class ThreadLocal<T>
	可以看出ThreadLocal并没有继承自Thread，也没有实现Runnable接口。所以AB都不对。
	（2）、ThreadLocal类为每一个线程都维护了自己独有的变量拷贝。每个线程都拥有了自己独立的一个变量。
	所以ThreadLocal重要作用并不在于多线程间的数据共享，而是数据的独立，C选项错。
	由于每个线程在访问该变量时，读取和修改的，都是自己独有的那一份变量拷贝，不会被其他线程访问，
	变量被彻底封闭在每个访问的线程中。所以E对。
	（3）、ThreadLocal中定义了一个哈希表用于为每个线程都提供一个变量的副本：
	 static class ThreadLocalMap {
	 
	        static class Entry extends WeakReference<ThreadLocal> {
	            /** The value associated with this ThreadLocal. */
	            Object value;
	 
	            Entry(ThreadLocal k, Object v) {
	                super(k);
	                value = v;
	            }
	        }
	 
	        /**
	         * The table, resized as necessary.
	         * table.length MUST always be a power of two.
	         */
	        private Entry[] table;
	}
	所以D对。

Java是一门支持反射的语言,基于反射为Java提供了丰富的动态性支持，下面关于Java反射的描述，哪些是错误的：( )		正确答案：ADF
A.Java反射主要涉及的类如Class, Method, Filed,等，他们都在java.lang.reflet包下
B.通过反射可以动态的实现一个接口，形成一个新的类，并可以用这个类创建对象，调用对象方法
C.通过反射，可以突破Java语言提供的对象成员、类成员的保护机制，访问一般方式不能访问的成员
D.Java反射机制提供了字节码修改的技术，可以动态的修剪一个类
E.Java的反射机制会给内存带来额外的开销。例如对永生堆的要求比不通过反射要求的更多
F.Java反射机制一般会带来效率问题，效率问题主要发生在查找类的方法和字段对象，因此通过缓存需要反射类的字段和方法就能达到与之间调用类的方法和访问类的字段一样的效率
解析：
	反射指的是在运行时能够分析类的能力的程序。
	反射机制可以用来：
		1.在运行时分析类的能力--检查类的结构--所用到的就是java.lang.reflect包中的Field、Method、Constructor，分别用于描述类的与、方法和构造器。A中的Class类在java.lang中。
		2.在运行时查看对象。
		3.实现通用的数组操作代码。
	反射机制的功能：
		在运行时判断任意一个对象所属的类；在运行时构造任意一个类的对象；在运行时判断任意一个类所具有的成员变量和方法；在运行时调用任意一个对象的方法；生成动态代理。
	反射机制常见作用：
		动态加载类、动态获取类的信息（属性、方法、构造器）；动态构造对象；动态调用类和对象的任意方法、构造器；动态调用和处理属性；获取泛型信息（新增类型：ParameterizedType,GenericArrayType等）；处理注解（反射API:getAnnotationsdeng等）。
	反射机制性能问题：
		反射会降低效率。
	void setAccessible(boolean flag):是否启用访问安全检查的开关，true屏蔽Java语言的访问检查，使得对象的私有属性也可以被查询和设置。禁止安全检查，可以提高反射的运行速度。
	可以考虑使用：cglib/javaassist操作。

表达式(short)10/10.2*2运算后结果是什么类型？	正确答案：C
A.short
B.int
C.double
D.float
解析：
	强制类型转换的优先级高于+ - * /，所以short只把10强制转换为了short

下列说法正确的是（）？	正确答案:AB
A.对于局部内部类，只有在方法的局部变量被标记为final或局部变量是effctively final的，内部类才能使用它们
B.成员内部类位于外部类内部，可以直接调用外部类的所有方法（静态方法和非静态方法）
C.由于匿名内部类只能用在方法内部，所以匿名内部类的用法与局部内部类是一致的
D.静态内部类可以访问外部类的成员变量
解析：
	A、对。
	B、对。
	C、错。匿名内部类用法与局部内部类不一致，首先从定义上就不一样，匿名类用在任何允许存在表达式的地方，而局部内部类用于在任何允许出现局部变量的地方出现。
	还有更重要的是匿名类只能使用一次，而局部类则可以在自己的定义域内多次使用。
	D、错。静态内部类不能直接访问外部类的非静态成员，但可以通过new外部类（）.成员的方式访问。

下列流当中，属于处理流的是：（）    正确答案：CD
A.FilelnputStream
B.lnputStream
C.DatalnputStream
D.BufferedlnputStream
解析：
	按照流是否直接与特定的地方（如磁盘、内存、设备等）相连，分为节点流和处理流两类。
	    节点流：可以从或向一个特定的地方（节点）读写数据。如FileReader.
	    处理流：是对一个已存在的流的连接和封装，通过所封装的流的功能调用实现数据读写。如BufferedReader.处理流的构造方法总是要带一个其他的流对象做参数。一个流对象经过其他流的多次包装，称为流的链接。
	
	JAVA常用的节点流：
	    文 件 FileInputStream FileOutputStrean FileReader FileWriter 文件进行处理的节点流。
	    字符串 StringReader StringWriter 对字符串进行处理的节点流。
	    数 组 ByteArrayInputStream ByteArrayOutputStreamCharArrayReader CharArrayWriter 对数组进行处理的节点流（对应的不再是文件，而是内存中的一个数组）。
	    管 道 PipedInputStream PipedOutputStream PipedReaderPipedWriter对管道进行处理的节点流。
	
	常用处理流（关闭处理流使用关闭里面的节点流）
	    缓冲流：BufferedInputStrean BufferedOutputStream BufferedReader BufferedWriter  增加缓冲功能，避免频繁读写硬盘。
	    转换流：InputStreamReader OutputStreamReader 实现字节流和字符流之间的转换。
	    数据流 DataInputStream DataOutputStream  等-提供将基础数据类型写入到文件中，或者读取出来.
	
	流的关闭顺序
	    一般情况下是：先打开的后关闭，后打开的先关闭
	    另一种情况：看依赖关系，如果流a依赖流b，应该先关闭流a，再关闭流b。例如，处理流a依赖节点流b，应该先关闭处理流a，再关闭节点流b
	    可以只关闭处理流，不用关闭节点流。处理流关闭的时候，会调用其处理的节点流的关闭方法。

局部变量能否和成员变量重名？		正确答案：A
A.可以，局部变量可以与成员变量重名，这时可用“this”来指向成员变量
B.可以，这时可用“local”关键字来指向局部变量
C.不能，局部变量不能与成员变量重名
D.不能，在一个类中不能有重名变量，不管是成员变量还是函数中的局部变量
解析：
	Java采用同名替换原则，与变量的类型无关，只要变量名相同就替换。
	Java变量：
		成员变量：就是声明为类的属性的变量。
		静态变量（也叫做类变量）：就是声明为静态属性的变量。
		局部变量：就是方法里面声明的变量。
		volatile变量：和多线程相关，用于简化同步的变量
		transient变量：用于使该变量不会被持久化
		final变量：基本上就是常量

下面哪种情况会导致持久区jvm堆内存溢出？		正确答案：C
A.循环上万次的字符串处理
B.在一段代码内申请上百M甚至上G的内存
C.使用CGLib技术直接操作字节码运行，生成大量的动态类
D.不断创建对象
解析：
	建议看看这篇博客 入门通俗易懂 http://blog.csdn.net/sivyer123/article/details/17139443
	简单的来说 java的堆内存分为两块:permantspace（持久带） 和 heap space。
	持久带中主要存放用于存放静态类型数据，如 Java Class, Method 等， 与垃圾收集器要收集的Java对象关系不大。
	而heapspace分为年轻带和年老带 
	年轻代的垃圾回收叫 Young GC， 年老代的垃圾回收叫 Full GC。
	在年轻代中经历了N次（可配置）垃圾回收后仍然存活的对象，就会被复制到年老代中。因此，可以认为年老代中存放的都是一些生命周期较长的对象
	年老代溢出原因有  循环上万次的字符串处理、创建上千万个对象、在一段代码内申请上百M甚至上G的内存，既A B D选项
	持久代溢出原因  动态加载了大量Java类而导致溢出

关于中间件特点的描述.不正确的是（）	正确答案：A
A.中间件运行于客户机/服务器的操作系统内核中，提高内核运行效率
B.中间件应支持标准的协议和接口
C.中间件可运行于多种硬件和操作系统平台上
D.跨越网络,硬件，操作系统平台的应用或服务可通过中间件透明交互
解析：
	中间件是一种独立的系统软件或服务程序，分布式应用软件借助这种软件在不同的技术之间共
	享资源。中间件位于客户机/ 服务器的操作系统之上，管理计算机资源和网络通讯。是连接两
	个独立应用程序或独立系统的软件。相连接的系统，即使它们具有不同的接口，但通过中间件
	相互之间仍能交换信息。执行中间件的一个关键途径是信息传递。通过中间件，应用程序可以
	工作于多平台或OS环境。
	（简单来说，中间件并不能提高内核的效率，一般只是负责网络信息的分发处理）
	中间件特点的描述：
	1. 中间件应支持标准的协议和接口
	2. 中间件可运行于多种硬件和操作系统平台上
	3. 跨越网络,硬件，操作系统平台的应用或服务可通过中间件透明交互

PS：主要选择了一些我觉得比较好的题记录在了这里，其他题看了一遍解析。
总结：JVM内存模型不是很懂，立个flag，大二一定看完《深入理解Java虚拟机》