牛客网刷题错题记录一(Java)

3月7日

一、运用下列哪个命令能够获取JVM的内存映像

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

A、jinfo
B、jmap
C、jhat
D、jstat

解析：

1、jps：查看本机java进程信息。

2、jstack：打印线程的栈信息，制作线程dump文件。

3、jmap：打印内存映射，制作堆dump文件

4、jstat：性能监控工具

5、jhat：内存分析工具

6、jconsole：简易的可视化控制台

7、jvisualvm：功能强大的控制台

二、下列哪个说法是正确的（）

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

A、ConcurrentHashMap使用synchronized关键字保证线程安全
B、HashMap实现了Collction接口
C、Array.asList方法返回java.util.ArrayList对象
D、SimpleDateFormat是线程不安全的

解析:

选D。

A选项中，ConcurrentHashMap 使用segment来分段和管理锁，segment继承自ReentrantLock，因此ConcurrentHashMap使用ReentrantLock来保证线程安全。

B中，HashMap定义规则如下：

public class HashMap<K,V>
    extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable

C中，应该是Arrays.asList()，其将一个数组转化为一个List对象，这个方法返回一个ArrayList类型的对象，这个ArrayList类并非java.util.ArrayList类，而是Arrays类的内部类：

图片说明

三、阅读如下代码。请问，对语句行 test.hello(). 描述正确的有（）

package NowCoder;
class Test {
	public static void hello() {
	    System.out.println("hello");
	}
}
public class MyApplication {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Test test=null;
		test.hello();
	}
}

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

A、能编译通过，并正确运行
B、因为使用了未初始化的变量，所以不能编译通过
C、以错误的方式访问了静态方法
D、能编译通过，但因变量为null，不能正常运行

解析：

Test test=null;这里也会加载静态方法，所以test数据中包含Test类的静态初始化数据,但是test并不能调用该类的非静态数据

因为Test类的hello方法是静态的，所以是属于类的，当实例化该类的时候，静态会被优先加载而且只加载一次，所以不受实例化new Test();影响，只要是使用到了Test类，都会加载静态hello方法！另外，在其他类的静态方法中也是可以调用公开的静态方法，此题hello方法是使用public修饰的所以在MyApplication中调用hello也是可以的。总结：即使Test test=null;这里也会加载静态方法，所以test数据中包含Test类的初始化数据。（静态的，构造的，成员属性）

四、给出下面的代码段:

public class Base{
int w, x, y ,z;
public Base(int a,int b)
{
x=a; y=b;
}
public Base(int a, int b, int c, int d)
{
// assignment x=a, y=b
w=d;z=c;
}}

在代码说明// assignment x=a, y=b处写入如下哪几个代码是正确的？（）

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

A、Base(a,b);
B、x=a, y=b;
C、x=a; y=b;
D、this(a,b);

解析：调用构造方法一定要先初始化！！！ new Base(a,b);

五、局部内部类可以用哪些修饰符修饰？

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

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

解析：局部内部类是放在代码块或方法中的，不能有访问控制修饰符，且不能用static修饰

六、Given the following code:

package cn.com.test;

public class EnclosingOne {
    public class InsideOne {}

}


package cn.com.cow;

import cn.com.test.EnclosingOne;
import cn.com.test.EnclosingOne.InsideOne;
public class InerTest
{
    public static void main(String[]args)
    {
        EnclosingOne eo = new EnclosingOne();
        //insert code here 
    }

}

Which statement at line 10 constructs an instance of the inner class?

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

A、InsideOne ei=eo.new InsideOne();
B、eo.InsideOne ei=eo.new InsideOne();
C、InsideOne ei=EnclosingOne.new InsideOne();
D、EnclosingOne.InsideOne ei=eo.new InsideOne();

解析：

public class Enclosingone {
	//非静态内部类
	public class InsideOne {}
	//静态内部类
	public static class InsideTwo{}
}

class Mytest02{
	public static void main(String args []){
		Enclosingone.InsideOne obj1 = new Enclosingone().new InsideOne();//非静态内部类对象
		Enclosingone.InsideTwo obj2 = new Enclosingone.InsideTwo();//静态内部类对象
	}
}

对于A答案主要在开头添加 import EnclosingOne.Insider这一句，不然的话A肯定是错误，其他类不能够直接引用内部类的

七、下面几个关于Java里queue的说法哪些是正确的（）？

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

A、LinkedBlockingQueue是一个可选有界队列，不允许null值
B、PriorityQueue，LinkedBlockingQueue都是线程不安全的
C、PriorityQueue是一个无界队列，不允许null值，入队和出队的时间复杂度是O（log(n)）
D、PriorityQueue，ConcurrentLinkedQueue都遵循FIFO原则

解析：

正确答案 AC 答案解析 A、LinkedBlockingQueue是一个基于节点链接的可选是否有界的阻塞队列，不允许null值。 B、LinkedBlockingQueue是一个线程安全的阻塞队列，实现了先进先出等特性。 C、PriorityQueue是一个***队列，不允许null值，入队和出队的时间复杂度是O（log(n)）。 D、PriorityQueue是不同于先进先出队列的另一种队列。每次从队列中取出的是具有最高优先权的元素。ConcurrentLinkedQueue是一个基于链接节点的***线程安全队列，该队列的元素遵循FIFO原则。

八、character流和byte流的的说法错误的是

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

A、每次读入的字节数不同
B、前者带有缓冲，后者没有。
C、前者是字符读入，后者是字节读入。
D、二者没有区别，可以互换。

解析：

字符流和字节流每次读入的字节数是不确定的，可能相同也可能不相同；字符流和字节流都有缓冲流

常识：

对于GBK编码标准，英文占用1个字节，中文占用2个字节对于UTF-8编码标准，英文占用1个字节，中文占用3个字节对于Unicode编码标准，英文中文都是2个字节。这也是为什么叫做unicode

3月8日

一、使用mvc模式设计的web应用程序具有以下优点,除了？

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

A、可维护行强
B、可扩展性强
C、代码重复少
D、大大减少代码量

解析：

MVC全名是Model View Controller，是模型(model)－视图(view)－控制器(controller)的缩写，一种软件设计典范，用一种业务逻辑、数据、界面显示分离的方法组织代码，将业务逻辑聚集到一个部件里面，在改进和个性化定制界面及用户交互的同时，不需要重新编写业务逻辑。MVC被独特的发展起来用于映射传统的输入、处理和输出功能在一个逻辑的图形化用户界面的结构中。 MVC只是将分管不同功能的逻辑代码进行了隔离，增强了可维护和可扩展性，增强代码复用性，因此可以减少代码重复。但是不保证减少代码量，多层次的调用模式还有可能增加代码量

二、socket编程中，以下哪个socket的操作是不属于服务端操作的（）？

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

A、accept
B、listen
C、connect
D、close

解析：

三、关于访问权限说法正确的是？ ( )

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

A、外部类定义前面可以修饰public,protected和private
B、局部内部类前面可以修饰public,protected和private
C、匿名内部类前面可以修饰public,protected和private
D、以上说法都不正确

解析：

在Java中，可以将一个类定义在另一个类里面或者一个方法里边，这样的类称为内部类，广泛意义上的内部类一般包括四种：成员内部类，局部内部类，匿名内部类，静态内部类。

1.成员内部类

（1）该类像是外部类的一个成员，可以无条件的访问外部类的所有成员属性和成员方法（包括private成员和静态成员）；

（2）成员内部类拥有与外部类同名的成员变量时，会发生隐藏现象，即默认情况下访问的是成员内部类中的成员。如果要访问外部类中的成员，需要以下形式访问：【外部类.this.成员变量或外部类.this.成员方法】；

（3）在外部类中如果要访问成员内部类的成员，必须先创建一个成员内部类的对象，再通过指向这个对象的引用来访问；

（4）成员内部类是依附外部类而存在的，也就是说，如果要创建成员内部类的对象，前提是必须存在一个外部类的对象；

（5）内部类可以拥有private访问权限、protected访问权限、public访问权限及包访问权限。如果成员内部类用private修饰，则只能在外部类的内部访问；如果用public修饰，则任何地方都能访问；如果用protected修饰，则只能在同一个包下或者继承外部类的情况下访问；如果是默认访问权限，则只能在同一个包下访问。外部类只能被public和包访问两种权限修饰。

2.局部内部类

（1）局部内部类是定义在一个方法或者一个作用域里面的类，它和成员内部类的区别在于局部内部类的访问仅限于方法内或者该作用域内；

（2）局部内部类就像是方法里面的一个局部变量一样，是不能有public、protected、private以及static修饰符的。

3.匿名内部类

（1）一般使用匿名内部类的方法来编写事件监听代码；

（2）匿名内部类是不能有访问修饰符和static修饰符的；

（3）匿名内部类是唯一一种没有构造器的类；

（4）匿名内部类用于继承其他类或是实现接口，并不需要增加额外的方法，只是对继承方法的实现或是重写。

4.内部静态类

（1）静态内部类是不需要依赖于外部类的，这点和类的静态成员属性有点类似；

（2）不能使用外部类的非static成员变量或者方法。

四、以下程序段执行后将有（）个字节被写入到文件afile.txt中。

try {
    FileOutputStream fos = new FileOutputStream("afile.txt");
    DataOutputStream dos = new DataOutputStream(fos);
    dos.writeInt(3);
    dos.writeChar(1);
    dos.close();
    fos.close();
} catch (IOException e) {}

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

A、3
B、5
C、6
D、不确定，与软硬件环境相关

解析：

java采用的uincode编码，两个字节表示一个字符，因此 char型在java中占两个字节，而int型占四个字节，故总共占6个字节

五、Java1.8之后，Java接口的修饰符可以为（）

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

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

解析：

应该是 public default(不写) abstract 可以修饰，证明

源代码，使用反编译软件可以看到这个源代码编译之后的结果，我们知道，我们不写的修饰符，都会在编译阶段被加上，所以 default 和 abstract 可以修饰接口。

源代码，也使用反编译软件进行反编译

抽象类中的抽象方法(其前有 abstract1修饰)不能用 private、 static、 synchronized、na tive访回修饰符修饰。原因如下:

1.private

抽象方法没有方法体,是用来被继承的,所以不能用 private修饰;

2.static

static修饰的方法可以通过类名来访间该方法(即该方法的方法体),抽象方法用static修饰没有意义;

3.synchronized

该关键字是为该方法加一个锁。而如果该关键字修饰的方法是 static方法。则使用的锁就是class变量的锁。如果是修饰类方法。则用this变量锁。但是抽象类不能实例化对象,因为该方法不是在该抽象类中实现的。是在其子类实现的。所以，锁应该归其子类所有。所以，抽象方法也就不能用 synchronized关键字修饰了;

4.native

native这个东西本身就和 abstract冲突,他们都是方法的声明,只是一个把方法实现移交给子类,另一个是移交给本地操作系统。如果同时出现,就相当于即把实现移交给子类,又把实现移交给本地操作系统,那到底谁来实现具体方法呢

六、以下哪个类包含方法flush()？（）

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

A、InputStream
B、OutputStream
C、A 和B 选项都包含
D、A 和B 选项都不包含

解析：

flush（）函数强制将缓冲区中的字符流、字节流等输出，原因是如果输出流输出到缓冲区完成后，缓冲区并没有填满，那么缓冲区将会一直等待被填满。所以在关闭输出流之前要调用flush（）。

七、以下哪项陈述是正确的？

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

A、垃圾回收线程的优先级很高，以保证不再使用的内存将被及时回收
B、垃圾收集允许程序开发者明确指定释放哪一个对象
C、垃圾回收机制保证了JAVA程序不会出现内存溢出
D、进入”Dead”状态的线程将被垃圾回收器回收
E、以上都不对

解析：

答案：E

A: 垃圾回收在jvm中优先级相当相当低。 B：垃圾收集器（GC）程序开发者只能推荐JVM进行回收，但何时回收，回收哪些，程序员不能控制。 C：垃圾回收机制只是回收不再使用的JVM内存，如果程序有严重BUG，照样内存溢出。 D：进入DEAD的线程，它还可以恢复，GC不会回收，如果是线程池，当线程执行完run方法时，进入dead状态，会被重新放回线程池，等待下一个资源进行支配。

深入理解java虚拟机当前判断一个对象是否需要回收的时候主要是采用可达性分析如果不可达的话会进行一个F-Queue队列之中在finalize（）方法执行中还会进行第二次标记是否可达如果可达那么就可以自救（恢复）不被回收不可达的话那么就彻底死了

八、下面代码运行结果是？

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
E、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

九、以下哪种JAVA的变量表达式使得变量a和变量b具有相同的内存引用地址( )

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

A、String a = "hello"; String b = "hello";
B、Integer a; Integer b = a;
C、int a = 1; Integer b = new Integer(1);
D、int a = 1; Integer b = 1;

解析：

内存引用地址，是指栈中存放的地址，来指向堆中的某个位置。

int 是基本类型，数据直接存放在栈中，不存在内存引用地址的说法

A对指向常量池里的"hello"。 B对题中没说声明的a是局部变量。 C错 int a =1;并不指向堆中，它只有值，没有引用地址，Integer b =new Integer(1);指向堆中地址为1的位置。 D错，比较的不是值，而是内存地址。int a=1，如果是成员变量，则存储在堆中，如果是局部变量，则存储在栈中，而Integer b = 1指向的是常量池 IntegerCache 中的1，地址肯定不一样。

十、哪个正确

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

A、abstract类只能用来派生子类，不能用来创建abstract类的对象。
B、final类不但可以用来派生子类，也可以用来创建final类的对象。
C、abstract不能与final同时修饰一个类。
D、abstract类定义中可以没有abstract方法。

解析：

1、abstract类不能用来创建abstract类的对象； 2、final类不能用来派生子类，因为用final修饰的类不能被继承； 3、如2所述，final不能与abstract同时修饰一个类，abstract类就是被用来继承的； 4、类中有abstract方法必须用abstract修饰，但abstract类中可以没有抽象方法，接口中也可以有abstract方法。

十一、下列流当中，属于处理流的是：（）

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

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 B C 你的答案: A B C D (错误)

A、Cookie是Web服务器发送给客户端的一小段信息，客户端请求时，可以读取该信息发送到服务器端
B、关闭浏览器意味着临时会话ID丢失，但所有与原会话关联的会话数据仍保留在服务器上，直至会话过期
C、在禁用Cookie时可以使用URL重写技术跟踪会话
D、隐藏表单域将字段添加到HTML表单并在客户端浏览器中显示

解析：

ABC

D:隐藏域在页面中对于用户（浏览器）是不可见的，在表单中插入隐藏域的目的在于收集或发送信息，以利于被处理表单的程序所使用。浏览者单击发送按钮发送表单的时候，隐藏域的信息也被一起发送到服务器。

十三、下面HttpServletResponse方法调用，那些给客户端回应了一个定制的HTTP回应头：( )

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

A、response.setHeader("X-MyHeader", "34");
B、response.addHeader("X-MyHeader", "34");
C、response.setHeader(new HttpHeader("X-MyHeader", "34"));
D、response.addHeader(new HttpHeader("X-MyHeader", "34"));
E、response.addHeader(new ServletHeader("X-MyHeader", "34"));
F、response.setHeader(new ServletHeader("X-MyHeader", "34"));

解析：

HttpServletResponse（接口）就只是提供了这么几个方法声明来设置响应头的数据。

1、同名Header可以有多个，Header[] getHeaders(String name)。 2、运行时使用的是第一个， Header getFirstHeader(String name)。 3、addHeader，如果同名header已存在，则追加至原同名header后面。 4、setHeader，如果同名header已存在，则覆盖一个同名header。

笔记：

类之间存在以下几种常见的关系：

**USES-A：**依赖关系，A类会用到B类，这种关系具有偶然性，临时性。但B类的变化会影响A类。这种在代码中的体现为：A类方法中的参数包含了B类。

**关联关系：**A类会用到B类，这是一种强依赖关系，是长期的并非偶然。在代码中的表现为：A类的成员变量中含有B类。

HAS-A：组合关系，拥有关系，是关联关系的一种特例，是整体和部分的关系。比如鸟群和鸟的关系是组合关系，鸟群中每个部分都是鸟。

**IS-A：**表示继承。父类与子类，这个就不解释了。

要注意：还有一种关系：组合关系也是关联关系的一种特例，它体现一种contains-a的关系，这种关系比聚合更强，也称为强聚合。它同样体现整体与部分的关系，但这种整体和部分是不可分割的。

3月9日

一、下面有关servlet中init,service,destroy方法描述错误的是？

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

A、init()方法是servlet生命的起点。一旦加载了某个servlet，服务器将立即调用它的init()方法
B、service()方法处理客户机发出的所有请求
C、destroy()方法标志servlet生命周期的结束
D、servlet在多线程下使用了同步机制，因此，在并发编程下servlet是线程安全的

解析：

答案为D。

servlet在多线程下其本身并不是线程安全的。

如果在类中定义成员变量，而在service中根据不同的线程对该成员变量进行更改，那么在并发的时候就会引起错误。最好是在方法中，定义局部变量，而不是类变量或者对象的成员变量。由于方法中的局部变量是在栈中，彼此各自都拥有独立的运行空间而不会互相干扰，因此才做到线程安全。

二、以下是java concurrent包下的4个类，选出差别最大的一个

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

A、Semaphore
B、ReentrantLock
C、Future
D、CountDownLatch

解析：

A、Semaphore：类，控制某个资源可被同时访问的个数;

B、ReentrantLock：类，具有与使用synchronized方法和语句所访问的隐式监视器锁相同的一些基本行为和语义，但功能更强大；

C、 Future：接口，表示异步计算的结果；

D、 CountDownLatch：类，可以用来在一个线程中等待多个线程完成任务的类。

Future：

a、它是个接口。

b、别的类都处理线程间的关系，处理并发机制，但该类只用于获取线程结果。

Future表示获取一个正在指定的线程的结果。对该线程有取消和判断是否执行完毕等操作。

CountDownLatch 是个锁存器，他表示我要占用给定的多少个线程且我优先执行，我执行完之前其他要使用该资源的都要等待。

Semaphore，就像是一个许可证发放者，也像一个数据库连接池。证就这么多，如果池中的证没换回来，其他人就不能用。

ReentrantLock 和 synchronized一样，用于锁定线程。

三、关于下面的程序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、程序有编译错误

解析：

被static修饰的变量称为静态变量，静态变量属于整个类，而局部变量属于方法，只在该方法内有效，所以static不能修饰局部变量

四、在jdk1.5之后，下列 java 程序输出结果为__。

int i=0;
Integer j = new Integer(0);
System.out.println(i==j);
System.out.println(j.equals(i));

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

A、true,false
B、true,true
C、false,true
D、false,false
E、对于不同的环境结果不同
F、程序无法执行

解析：

本题是一个自动拆装箱的考题(自动拆装箱JDK需在1.5上），下面的讨论都不针对新开辟对象的情况： 1、基本型和基本型封装型进行“==”运算符的比较，基本型封装型将会自动拆箱变为基本型后再进行比较，因此Integer(0)会自动拆箱为int类型再进行比较，显然返回true；

2、两个Integer类型进行“==”比较，Integer的==比较应该与其声明方式与值范围有关.像Integer a = new Integer(3),这样声明的两个Integer对象==比较返回的应该是false.因为堆中指向不同的地址值.但是像用Integer b = 3这样声明的,只要在-128~127的范围内时==比较返回的是true,这是因为在方法去存在一个数组,存储着-128~127的数,这时b的值是直接指向方法区的地址值.

3、两个基本型的封装型进行equals()比较，首先equals()会比较类型，如果类型相同，则继续比较值，如果值也相同，返回true

4、基本型封装类型调用equals(),但是参数是基本类型，这时候，先会进行自动装箱，基本型转换为其封装类型，再进行3中的比较。

int a=257;
Integer b=257;
Integer c=257;
Integer b2=57;
Integer c2=57;
System.out.println(a==b);
//System.out.println(a.equals(b)); 编译出错，基本型不能调用equals()
System.out.println(b.equals(257.0));
System.out.println(b==c);
System.out.println(b2==c2);

因此上面的代码的结果因此为 true, false, false, true

五、下面代码输出结果是？

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

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

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

解析：

公式-n=~n+1可推出~n=-n-1，所以~10=-11再加5结果为-6

六、给出以下代码,请给出结果.

class Two{
    Byte x;
}
class PassO{
    public static void main(String[] args){
        PassO p=new PassO();
        p.start();
    }
    void start(){
        Two t=new Two();
        System.out.print(t.x+””);
        Two t2=fix(t);
        System.out.print(t.x+” ” +t2.x);
    }
    Two fix(Two tt){
        tt.x=42;
        return tt;
    }
}

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

A、null null 42
B、null 42 42
C、0 0 42
D、0 42 42
E、An exception is thrown at runtime
F、Compilation

解析：

1.注意第二行代码，Byte x；Byte是包装类，不是byte（基本数据类型），因此Byte的默认是null，不是0

2.t是一个引用地址类型，在调用fit（Two tt）函数是，是一个实参到形参的传值，也就是把t的地址赋值给了tt，但是都是指向堆内存中新建的对象，因此当对tt.x和t.x指向是相同的。因此t.x也是42

3.Two t2=fit（t）；fit函数返回的还是一个引用地址，这句代码相当于把t（函数里面返回的是tt）的地址赋值给了t2，因此t2.x也是42

七、运行代码，输出的结果是（）

public class P {
    public static int abc = 123;
    static{
        System.out.println("P is init");
    }
}
public class S extends P {
    static{
        System.out.println("S is init");
    }
}
public class Test {
    public static void main(String[] args) {
        System.out.println(S.abc);
    }
}

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

A、P is init<br />123
B、S is init<br />P is init<br />123
C、P is init<br />S is init<br />123
D、S is init<br />123

解析：

属于被动引用不会出发子类初始化

1.子类引用父类的静态字段，只会触发子类的加载、父类的初始化，不会导致子类初始化

2.通过数组定义来引用类，不会触发此类的初始化

3.常量在编译阶段会进行常量优化，将常量存入调用类的常量池中，本质上并没有直接引用到定义常量的类，因此不会触发定义常量的类的初始化。

参考：《深入理解Java虚拟机》

这里有类主动引用和被动引用的demo：https://www.jianshu.com/p/3afa5d24bf71

不会初始化子类的几种

调用的是父类的static方法或者字段
调用的是父类的final方法或者字段
通过数组来引用

八、在使用super和this关键字时，以下描述错误的是（）

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

A、在子类构造方法中使用super()显示调用父类的构造方法，super()必须写在子类构造方法的第一行，否则编译不通过
B、super()和this()不一定要放在构造方法内第一行
C、this()和super()可以同时出现在一个构造函数中
D、this()和super()可以在static环境中使用，包括static方法和static语句块

解析：

super和this都只能位于构造器的第一行，而且不能同时使用，这是因为会造成初始化两次，this用于调用重载的构造器，super用于调用父类被子类重写的方法

九、下列哪些操作会使线程释放锁资源？

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

A、sleep()
B、wait()
C、join()
D、yield()

解析：

1.sleep会使当前线程睡眠指定时间，不释放锁，sleep()使当前线程进入阻塞状态，在指定时间内不会执行。

2.yield会使当前线程重回到可执行状态，等待cpu的调度，不释放锁

yield()只是使当前线程重新回到可执行状态，所以执行yield()的线程有可能在进入到可执行状态后马上又被执行。

yield()只能使同优先级或更高优先级的线程有执行的机会。

3.wait会使当前线程回到线程池中等待，释放锁，当被其他线程使用notify，notifyAll唤醒时进入可执行状态

在其他线程调用对象的notify或notifyAll方法前，导致当前线程等待。线程会释放掉它所占有的“锁标志”，从而使别的线程有机会抢占该锁。当前线程必须拥有当前对象锁。如果当前线程不是此锁的拥有者，会抛出IllegalMonitorStateException异常。

唤醒当前对象锁的等待线程使用notify或notifyAll方法，也必须拥有相同的对象锁，否则也会抛出IllegalMonitorStateException异常。

waite()和notify()必须在synchronized函数或synchronized　block中进行调用。如果在non-synchronized函数或non-synchronized　block中进行调用，虽然能编译通过，但在运行时会发生IllegalMonitorStateException的异常。

4.当前线程调用某线程.join（）时会使当前线程等待某线程执行完毕再结束，底层调用了wait，释放锁

十、以下哪些类是线程安全的（）

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

A、Vector
B、HashMap
C、ArrayList
D、StringBuffer
E、Properties

解析：

答案：ADE

A，Vector相当于一个线程安全的List

B，HashMap是非线程安全的，其对应的线程安全类是HashTable

C，Arraylist是非线程安全的，其对应的线程安全类是Vector

D，StringBuffer是线程安全的，相当于一个线程安全的StringBuilder

E，Properties 继承了Hashtable，因为Hashtable是线程安全的，所以Properties是线程安全的

十一、在Java语言中，下列关于字符集编码（Character set encoding）和国际化（i18n）的问题，哪些是正确的？

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

A、每个中文字符占用2个字节，每个英文字符占用1个字节
B、假设数据库中的字符是以GBK编码的，那么显示数据库数据的网页也必须是GBK编码的。
C、Java的char类型，通常以UTF-16 Big Endian的方式保存一个字符。
D、实现国际化应用常用的手段是利用ResourceBundle类

解析：

A 显然是错误的，Java一律采用Unicode编码方式，每个字符无论中文还是英文字符都占用2个字节。

B 也是不正确的，不同的编码之间是可以转换的，通常流程如下：

将字符串S以其自身编码方式分解为字节数组，再将字节数组以你想要输出的编码方式重新编码为字符串。

例：String newUTF8Str = new String(oldGBKStr.getBytes("GBK"), "UTF8");

C 是正确的。Java虚拟机中通常使用UTF-16的方式保存一个字符

D 也是正确的。ResourceBundle能够依据Local的不同，选择性的读取与Local对应后缀的properties文件，以达到国际化的目的。

十二、下面哪些类可以被继承？ Java.lang.Thread、java.lang.Number、java.lang.Double、java.lang.Math、 java.lang.ClassLoader

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

A、Thread
B、Number
C、Double
D、Math
E、ClassLoader

解析：

答案：ABE

A，Thread可以被继承，用于创建新的线程

B，Number类可以被继承，Integer，Float，Double等都继承自Number类

C，Double类的声明为

public final class Double extends Numberimplements Comparable<Double>

final生明的类不能被继承

D，Math类的声明为

public final class Math extends Object

不能被继承

E，ClassLoader可以被继承，用户可以自定义类加载器

十三、下面几个关于Java里queue的说法哪些是<正确>的（）？

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

A、LinkedBlockingQueue是一个可选有界队列，不允许null值
B、PriorityQueue，LinkedBlockingQueue都是线程不安全的
C、PriorityQueue是一个无界队列，不允许null值，入队和出队的时间复杂度是O（log(n)）
D、PriorityQueue，ConcurrentLinkedQueue都遵循FIFO原则

解析：

正确答案 AC 答案解析 A、LinkedBlockingQueue是一个基于节点链接的可选是否有界的阻塞队列，不允许null值。 B、LinkedBlockingQueue是一个线程安全的阻塞队列，实现了先进先出等特性。 C、PriorityQueue是一个***队列，不允许null值，入队和出队的时间复杂度是O（log(n)）。 D、PriorityQueue是不同于先进先出队列（不遵循FIFO原则）的另一种队列。每次从队列中取出的是具有最高优先权的元素。ConcurrentLinkedQueue是一个基于链接节点的***线程安全队列，该队列的元素遵循FIFO原则。

十四、以下哪种JAVA得<变量>声明方式可以避免程序在多线程竞争情况下读到不正确的值( )

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

A、volatile
B、static volatile
C、synchronized
D、static

解析：

synchronized不是修饰变量的它修饰方法或代码块或对象

3月10日

笔记：

常用ASCII码值：空格为32；数字0为48；“A”为65；“a”值为97。

编译看左边，运行看右边。父类型引用指向子类型对象，无法调用只在子类型里定义的方法

主要考核了这几个知识点：

1.静态内部类才可以声明静态方法

2.静态方法不可以使用非静态变量

3.抽象方法不可以有函数体

静态方法不能访问非静态变量；

抽象类中的抽象方法不能有方法提；

一个类中有多个类声明时，只能有一个public类

一、如下代码，执行test()函数后，屏幕打印结果为（）

public class Test2
{
    public void add(Byte b)
    {
        b = b++;
    }
    public void test()
    {
        Byte a = 127;
        Byte b = 127;
        add(++a);
        System.out.print(a + " ");
        add(b);
        System.out.print(b + "");
    }
}

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

A、127 127
B、128 127
C、129 128
D、以上都不对

解析：

public void add(Byte b){ b=b++; } 这里涉及java的自动装包/自动拆包(AutoBoxing/UnBoxing) Byte的首字母为大写，是类，看似是引用传递，但是在add函数内实现++操作，会自动拆包成byte值传递类型，所以add函数还是不能实现自增功能。也就是说add函数只是个摆设，没有任何作用。 Byte类型值大小为-128~127之间。 add(++a);这里++a会越界，a的值变为-128 add(b); 前面说了，add不起任何作用，b还是127

二、在一个基于分布式的游戏服务器系统中，不同的服务器之间，哪种通信方式是不可行的（）？

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

A、管道
B、消息队列
C、高速缓存数据库
D、套接字

解析：

对于管道，有下面这几种类型：

①普通管道（PIPE）：通常有两种限制，一是单工，即只能单向传输；二是血缘，即常用于父子进程间（或有血缘关系的进程间）。

②流管道（s_pipe）：去除了上述的第一种限制，实现了双向传输。

③命名管道（name_pipe）：去除了上述的第二种限制，实现了无血缘关系的不同进程间通信。

*显然，要求是对于不同的服务器之间的通信，是要要求全双工形式的，而管道只能是半双工**，虽然可以双向，*但是同一时间只能有一个方向传输，全双工和半双工的区别可以如下图示理解：

三、在创建派生类对象，构造函数的执行顺序（）

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

A、基类构造函数，派生类对象成员构造函数，派生类本身的构造函数
B、派生类本身的构造函数，基类构造函数，对象成员构造函数
C、基类构造函数，派生类本身的构造函数，派生类对象成员构造函数
D、对象成员构造函数，基类构造函数，派生类本身的构造函数

解析：

父类静态域——》子类静态域——》父类成员初始化——》父类构造块——》1父类构造方法——》2子类成员初始化——》子类构造块——》3子类构造方法；

加黑的123，对应为A

四、以下哪一个不是赋值符号？

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

A、+=
B、<<=
C、<<<=
D、>>>=

解析：

A.很明显是赋值符号 B.<<=左移赋值 C.不是 D.>>>= 右移赋值，左边空出的位以0填充

五、ResultSet中记录行的第一列索引为？

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

A、-1
B、0
C、1
D、以上都不是

解析：

ResultSet跟普通的数组不同，索引从1开始而不是从0开始

六、在各自最优条件下,对N个数进行排序,哪个算法复杂度最低的是? （）

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

A、插入排序
B、快速排序
C、堆排序
D、归并排序

解析：

七、关于OutOfMemoryError，下面说法正确的是（）？

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

A、java.lang.OutOfMemoryError: PermGen space 增加-XX:MaxPermSize这个参数的值的话，这个问题通常会得到解决。
B、java.lang.OutOfMemoryError: Requested array size exceeds VM limit当你正准备创建一个超过虚拟机允许的大小的数组时，这条错误将会出现
C、java.lang.OutOfMemoryError: Java heap space 一般情况下解决这个问题最快的方法就是通过-Xmx参数来增加堆的大小
D、java.lang.OutOfMemoryError: nativeGetNewTLA这个异常只有在jRockit虚拟机时才会碰到

解析：

关于此题，《深入理解java虚拟机》有关于OOM（OutOfMemory）问题的解释

A：属于运行时常量池导致的溢出，设置-XX：MaxPermSize可以解决这个问题，

B：属于堆空间不足导致的错误，问题比较少见，解决方式和C相同，

C：属于java堆内存问题，一般的手段是通过内存映像分析工具，对Dump出来的堆转储存快照进行分析，重点是确认内存中的对象是否是有必要的，也就是要判断是出现了内存泄漏，还是出现了内存溢出，如果是内存泄露，通过工具检查泄露对象打GC Roots的引用链信息，可以准确的确定出泄露代码的位置，不存在泄露，就应该检查虚拟机的堆参数，如果可以继续调大，可以设置-Xmx解决问题

D：java.lang.OutOfMemoryError: nativeGetNewTLA指当虚拟机不能分配新的线程本地空间(Thread Local Area）的时候错误信息，此错误是线程申请一个新的TLA时产生的，这个异常一般只会发生在jRockit虚拟机，只有过于绝对。

八、下面代码在main()方法中第八行后可以正常使用的是（）

public class Test
{ 
    private int a=10; 
    int b=20; 
    static int c=1; 
    public static void main(String arg[])
    { 
        Test t = new Test(); 
    } 
 }

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

A、t.a
B、this.c
C、Test.b
D、t.c

解析：

A : 在private 修饰不能在外部类中调用，main 方法属于Test类的方法，所以对象 t 可以在他自己的类方法中调用它的private

B ： static 方法中没有this 这么一说

C: b不是static变量

D: 合理

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

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

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

解析：

选ABD

A和B中long和float，正常定义需要加l和f，但是long和float属于基本类型，会进行转化，所以不会报出异常。AB正确

boolean类型不能和任何类型进行转换，会报出类型异常错误。所以C错。

D选项可以这样定义，D正确。

E选项中，byte的取值范围是-128—127。报出异常： cannot convert from int to byte.所以E选项错误。

A,B小赋大不需要转换不会报错，正解，E2^8. (-128,127)必错

十、下面关于变量及其范围的陈述哪些是不正确的（）

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

A、实例变量是类的成员变量
B、实例变量用关键字static声明
C、在方法中定义的局部变量在该方法被执行时创建
D、局部变量在使用前必须被初始化

解析：

A.类的成员变量包括实例变量和类变量（静态变量）,成员方法包括实例方法和类方法（静态方法）。 A正确

B.类变量（静态变量）用关键字static声明，B错误

C.方法中的局部变量在方法被调用加载时开始入栈时创建，方法入栈创建栈帧包括局部变量表操作数栈，局部变量表存放局部变量，并非在执行该方法时被创建，在线程为该方法创建栈桢时被创建，而不是方法执行时创建，C错误

D.局部变量被使用前必须初始化，否则程序报错。D正确

十一、以下程序执行后，错误的结果是（）

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 B C 你的答案: B C (错误)

A、true,true,true
B、true,false,false
C、false,true,false
D、false,true,true

解析：

Test 类没有重写equals方法，比较时调用的时object的equals方法，object的equals方法用==比较的时地址值。

3月11日

一、一般用()创建InputStream对象,表示从标准输入中获取数据,用()创建OutputStream对象，表示输出到标准输出设备中。

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

A、System.in System.out
B、System.out System.in
C、System.io.in System.io.out
D、System.io.out System.io.in

解析：

答案：A

System.in 和 System.out 是java中的标准输入输出流，一般情况下代表从控制台输入和输出到控制台

二、一个容器类数据结构，读写平均，使用锁机制保证线程安全。如果要综合提高该数据结构的访问性能，最好的办法是__。

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

A、只对写操作加锁，不对读操作加锁
B、读操作不加锁，采用copyOnWrite的方式实现写操作
C、分区段加锁
D、无法做到

解析：

答案：C

A，只对写操作加锁，不对读操作加锁，会造成读到脏数据

B，CopyOnWrite的核心思想是利用高并发往往是读多写少的特性，对读操作不加锁，对写操作，先复制一份新的集合，在新的集合上面修改，然后将新集合赋值给旧的引用**。这里读写平均，不适用**

C，分段加锁，只在影响读写的地方加锁，锁可以用读写锁，可以提高效率

三、JDK中提供的java、javac、jar等开发工具也是用Java编写的。

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

对
错

解析：

除了JVM是C++写的，其他大部分工具都是为Java语言自己实现的

四、jre 判断程序是否执行结束的标准是（）

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

A、所有的前台线程执行完毕
B、所有的后台线程执行完毕
C、所有的线程执行完毕
D、和以上都无关

解析：

选A

其实这个题，就是在说守护线程和非守护（用户）线程的问题。后台线程就是守护线程，前台线程就是用户线程。

守护线程：是指在程序运行时在后台提供一种通用服务的线程，这种线程并不是必须的。同时守护线程的线程优先级都很低的。JVM中的GC线程就是一个守护线程，只要JVM启动，GC线程就启动了。

用户线程和守护线程几乎没有什么区别，唯一的区别就在于，如果用户线程都已经退出了，只剩下了守护线程，那么JVM直接就退出了。

*五、以下代码执行的结果是多少（）？

		public class Demo {
	public static void main(String[] args) {
		Collection<?>[] collections = 
{new HashSet<String>(), new ArrayList<String>(), new HashMap<String, String>().values()};
				Super subToSuper = new Sub();
				for(Collection<?> collection: collections) {
	System.out.println(subToSuper.getType(collection));
}
}
abstract static class Super {
	public static String getType(Collection<?> collection) {
		return “Super:collection”;
}
public static String getType(List<?> list) {
		return “Super:list”;
}
public String getType(ArrayList<?> list) {
		return “Super:arrayList”;
}
public static String getType(Set<?> set) {
		return “Super:set”;
}
public String getType(HashSet<?> set) {
		return “Super:hashSet”;
}
}
static class Sub extends Super {
	public static String getType(Collection<?> collection) {
            return "Sub"; }
}
}

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

A、 	Sub:collection
	Sub:collection
	Sub:collection
B、	Sub:hashSet
	Sub:arrayList
	Sub:collection
C、	Super:collection
	Super:collection
	Super:collection
D、	Super:hashSet
	Super:arrayList
	Super:collection

解析：

考察点1：重载静态多分派——根据传入重载方法的参数类型，选择更加合适的一个重载方法

考察点2：static方法不能被子类覆写，在子类中定义了和父类完全相同的static方法，则父类的static方法被隐藏，Son.staticmethod()或new Son().staticmethod()都是调用的子类的static方法，如果是Father.staticmethod()或者Father f = new Son(); f.staticmethod()调用的都是父类的static方法。

考察点3：此题如果都不是static方法，则最终的结果是A. 调用子类的getType，输出collection

这是静态分派的过程，在编译时已经决定了使用super的方法，因为subToSuper 是指super对象，可是为什么会选择collection呢，for循环出来他们实际上指的是collection对象表示的，即类似于Collection col = new HashSet<>();这样传入方法getType（）中的参数就是col，左边是静态类型，右边是实际类型。由于重载实际上是使用静态分派的，重载时是通过参数的静态类型而不是实际类型作为判定依据的。详细参考深入理解java虚拟机248页解释。

六、关于匿名内部类叙述正确的是？ ( )

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

A、匿名内部类可以继承一个基类，不可以实现一个接口
B、匿名内部类不可以定义构造器
C、匿名内部类不能用于实参
D、以上说法都不正确

解析：

匿名内部类的创建格式为： new 父类构造器（参数列表）|实现接口（）{

//匿名内部类的类体实现

}

使用匿名内部类时，必须继承一个类或实现一个接口
匿名内部类由于没有名字，因此不能定义构造函数
匿名内部类中不能含有静态成员变量和静态方法

七、在Web应用程序中，( )负责将HTTP请求转换为HttpServletRequest对象

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

A、Servlet对象
B、HTTP服务器
C、Web容器
D、JSP网页

解析：

web容器是一种服务程序，在服务器一个端口就有一个提供相应服务的程序，而这个程序就是处理从客户端发出的请求，如JAVA中的Tomcat容器，ASP的IIS或PWS都是这样的容器。一个服务器可以多个容器。

八、单例模式中，两个基本要点是

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

A、构造函数私有
B、静态工厂方法
C、以上都不对
D、唯一实例

解析：

什么是单例模式？

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

单例模式有分为饿汉式和懒汉式

特点：

1、单例类只能有一个实例。
2、单例类必须自己创建自己的唯一实例。
3、单例类必须给所有其他对象提供这一实例。

单例模式-饿汉式

代码

//单例模式-饿汉式
public class SingletonDemo {
    public static void main(String[] args) {
        //编译错误：无法实例化
        // Singleton singleton = new Singleton();

        //正确获取对象的方法
        Singleton singleton = Singleton.getINSTANCE();
        singleton.hello();
    }
}

class Singleton{
    //创建一个本身对象
    private static final Singleton INSTANCE = new Singleton();

    //让构造方法为private，这样该类就不会被实例化
    private Singleton(){}

    //创建一个获取对象的方法
    public static Singleton getINSTANCE() {
        return INSTANCE;
    }

    public void hello(){
        System.out.println("Hello World! ——单例模式-饿汉式");
    }
}

单例模式-懒汉式

双重校验锁实现懒汉单例模式

public class Singleton{
    private volatile static Singleton instance;
    //私有构造函数
    private Singleton{
        
    }
    //唯一实例
    public static Singleton getInstacne(){
        if(instance == null){
            synchronized(Singleton.class){
                if(instance == null){
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

九、给出下面的代码段:

public class Base{
int w, x, y ,z;
public Base(int a,int b)
{
x=a; y=b;
}
public Base(int a, int b, int c, int d)
{
// assignment x=a, y=b
w=d;z=c;
}}
在代码说明// assignment x=a, y=b处写入如下哪几个代码是正确的？（）

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

A、Base(a,b);
B、x=a, y=b;
C、x=a; y=b;
D、this(a,b);

解析：

调用构造方法一定要先初始化！！！ new Base(a,b);

十、在使用super和this关键字时，以下描述错误的是（）

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

A、在子类构造方法中使用super()显示调用父类的构造方法，super()必须写在子类构造方法的第一行，否则编译不通过
B、super()和this()不一定要放在构造方法内第一行
C、this()和super()可以同时出现在一个构造函数中
D、this()和super()可以在static环境中使用，包括static方法和static语句块

解析：

十一、 Which statement declares a variable a which is suitable for referring to an array of 50 string objects?

下面哪个Java语句声明了一个适合于创建50个字符串对象数组的变量？

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

A、char a[][];
B、String a[];
C、String[] a;
D、Object a[50];
E、String a[50];
F、Object a[];

解析：

BCF

在java 中，声明一个数组时，不能直接限定数组长度，只有在创建实例化对象时，才能对给定数组长度.。

如下，1，2,3可以通过编译，4，5不行。而String是Object的子类，所以上述BCF均可定义一个存放50个String类型对象的数组。

String a[]=new String[50];
String b[];
char c[];
String d[50];
char e[50];

十二、关于ThreadLocal类以下说法正确的是

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

A、ThreadLocal继承自Thread
B、ThreadLocal实现了Runnable接口
C、ThreadLocal重要作用在于多线程间的数据共享
D、ThreadLocal是采用哈希表的方式来为每个线程都提供一个变量的副本
E、ThreadLocal保证各个线程间数据安全，每个线程的数据不会被另外线程访问和破坏

解析：

选DE.

1、ThreadLocal的类声明：

public class ThreadLocal

可以看出ThreadLocal并没有继承自Thread，也没有实现Runnable接口。所以AB都不对。

2、ThreadLocal类为每一个线程都维护了自己独有的变量拷贝。每个线程都拥有了自己独立的一个变量。

所以ThreadLocal重要作用并不在于多线程间的数据共享，而是数据的独立，C选项错。

由于每个线程在访问该变量时，读取和修改的，都是自己独有的那一份变量拷贝，不会被其他线程访问，

变量被彻底封闭在每个访问的线程中。所以E对。

3、ThreadLocal中定义了一个哈希表用于为每个线程都提供一个变量的副本：

static class ThreadLocalMap {

static class Entry extends WeakReference {

/** 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对。

十三、

public class NameList
{
    private List names = new ArrayList();
    public synchronized void add(String name)
    {
        names.add(name);
    }
    public synchronized void printAll() {
        for (int i = 0; i < names.size(); i++)
        {
            System.out.print(names.get(i) + "");
        }
    }

    public static void main(String[]args)
    {
        final NameList sl = new NameList();
        for (int i = 0; i < 2; i++)
        {
            new Thread()
            {
                public void run()
                {
                    sl.add("A");
                    sl.add("B");
                    sl.add("C");
                    sl.printAll();
                }
            } .start();
        }
    }
}

下面正确的2项是？

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

A、运行的时候可能抛异常
B、运行的时候可能没有输出，也没有正常退出
C、代码运行的时候可能没有输出，但是正常退出
D、代码输出"A B A B C C " 
E、代码输出"A B C A B C A B C "
F、代码输出"A A A B C A B C C "
G、代码输出"A B C A A B C A B C "

解析：

在每个线程中都是顺序执行的，所以sl.printAll();必须在前三句执行之后执行，也就是输出的内容必有（连续或非连续的）ABC。

而线程之间是穿插执行的，所以一个线程执行 sl.printAll();之前可能有另一个线程执行了前三句的前几句。

E答案相当于线程1顺序执行完然后线程2顺序执行完。

G答案则是线程1执行完前三句add之后线程2插一脚执行了一句add然后线程1再执行 sl.printAll();输出ABCA。接着线程2顺序执行完输出ABCABC

输出加起来即为ABCAABCABC。

F不可能，不可能连续加三个A再输出

D应该为ABABCABABCC

十四、character流和byte流的的说法错误的是

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

A、每次读入的字节数不同
B、前者带有缓冲，后者没有。
C、前者是字符读入，后者是字节读入。
D、二者没有区别，可以互换。

3月12日

一、对于非运行时异常，程序中一般可不做处理，由java虚拟机自动进行处理。

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

A、正确
B、错误

解析：

运行异常，可以通过java虚拟机来自行处理。非运行异常，我们应该捕获或者抛出

二、以下代码段执行后的输出结果为

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

正确答案: D 你的答案: D (正确)

A、-1
B、2
C、1
D、-2

解析：

Y(被除数) % X(除数) 当除数与被除数的符号相同时，取余和取模的结果是完全相同的；当除数与被除数的符号不相同时，结果不同。　　具体说，取余结果的符号与被除数相同；取模结果的符号与除数相同。通常取模运算也叫取余运算，他们都遵循处罚法则，返回结果都是余数； 1.取余 ‘%’　　 rem(3,2)=1 　　 rem(-3,-2)=-1 　　 rem(3,-2)=1 　　 rem(-3,2)=-1 　　

2.取模‘/’ 　　 mod(3,2)=1 　　 mod(-3,-2)=-1 　　 mod(3,-2)=-1 　　 mod(-3,2)=1

运算符或方法	含义
%	取余，结果符号和被除数一致。
Math.floorMod()	取模，结果符号和除数一致。

三、以下程序段执行后将有（）个字节被写入到文件afile.txt中。

try {
    FileOutputStream fos = new FileOutputStream("afile.txt");
    DataOutputStream dos = new DataOutputStream(fos);
    dos.writeInt(3);
    dos.writeChar(1);
    dos.close();
    fos.close();
} catch (IOException e) {}

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

A、3
B、5
C、6
D、不确定，与软硬件环境相关

解析：

java采用的uincode编码，两个字节表示一个字符，因此 char型在java中占两个字节，而int型占四个字节，故总共占六个字节

四、针对以下代码，哪些选项执行后是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 你的答案: C D (错误)

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

解析：

BC正确，选项B解释，java核心卷I中43页有如下表述：两个数值进行二元操作时，会有如下的转换操作：

如果两个操作数其中有一个是double类型，另一个操作就会转换为double类型。

否则，如果其中一个操作数是float类型，另一个将会转换为float类型。

否则，如果其中一个操作数是long类型，另一个会转换为long类型。

否则，两个操作数都转换为int类型。

故，x==f1[0]中，x将会转换为高精度的float类型。

==比较在比较值得同时还比较二者的引用，着f1和f2是不同的对象，所以不会相等。

五、在JDK1.7中，下述说法中抽象类与接口的区别与联系正确的有哪些？

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

A、抽象类中可以有普通成员变量，接口中没有普通成员变量。
B、抽象类和接口中都可以包含静态成员常量。
C、一个类可以实现多个接口，但只能继承一个抽象类
D、抽象类中可以包含非抽象的普通方法，接口中的方法必须是抽象的，不能有非抽象的普通方法。

解析：

jdk1.7

接口（interface）可以说成是抽象类的一种特例，接口中的所有方法都必须是抽象的。接口中的方法定义默认为public abstract类型，接口中的成员变量类型默认为public static final。另外，接口和抽象类在方法上有区别：

抽象类可以有构造方法，接口中不能有构造方法。
抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。
抽象类中可以有普通成员变量，接口中没有普通成员变量
抽象类中的抽象方法的访问类型可以是public，protected和默认类型
抽象类中可以包含静态方法，接口中不能包含静态方法
抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是public static final类型，并且默认即为public static final类型
一个类可以实现多个接口，但只能继承一个抽象类。二者在应用方面也有一定的区别：接口更多的是在系统架构设计方法发挥作用，主要用于定义模块之间的通信契约。而抽象类在代码实现方面发挥作用，可以实现代码的重用，例如，模板方法设计模式是抽象类的一个典型应用，假设某个项目的所有Servlet类都要用相同的方式进行权限判断、记录访问日志和处理异常，那么就可以定义一个抽象的基类，让所有的Servlet都继承这个抽象基类，在抽象基类的service方法中完成权限判断、记录访问日志和处理异常的代码，在各个子类中只是完成各自的业务逻辑代码。

jdk1.8

1.8里面接口可以写默认方法和静态方法了。而且可以在接口里面编写方法的实现了。在jdk1.9里接口里还引入了私有方法。

在JDK1.8之前的版本（不包括JDK1.8），接口中不能有静态方法，抽象类中因为有普通方法，故也可以有静态方法。

在JDK1.8后（包括JDK1.8），在抽象类中依旧可以有静态方法，同时在接口中也可以定义静态方法了。

以下代码在JDK1.8之后是没有问题的（可以通过接口名来调用静态方法：Main.prinf(); ）：

默认方法：使用default修饰，在接口的实现类中，可以直接调用该方法，也可以重写该方法。

静态方法：使用static修饰，通过接口直接调用。

jdk1.9

在JDK1.9，接口中新加了私有方法，使用private修饰，私有方法供接口内的默认方法调用。

六、java中 String str = "hello world"下列语句错误的是？

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

A、str+='      a'
B、int strlen = str.length
C、str=100
D、str=str+100

解析：

str += 'a' 和 str +="a"都是对的，但是如果a前面加一个空格，那么只能用双引号了。代表字符串

3月13日

一、非抽象类实现接口后，必须实现接口中的所有抽象方法，除了abstract外，方法头必须完全一致.

正确答案: B 你的答案: B (正确)

A、正确
B、错误

解析：

实际上这道题考查的是两同两小一大原则：

方法名相同，参数类型相同

子类返回类型小于等于父类方法返回类型，子类抛出异常小于等于父类方法抛出异常，子类访问权限大于等于父类方法访问权限。

补充两点：

本题是问关于接口，实现接口方法的约束和子类覆盖父类方法的约束基本上是一样的，但接口有一点特殊的地方是接口的方法默认是public abstract，所以在实现接口方法的时候，也必须使用public
“子类抛出异常小于等于父类方法抛出异常”——不管父类抛出何种异常，子类可以不抛出任何异常。同样的，如果接口方法定义抛出某种异常，在实现这个接口方法的时候，可以抛出小于等于接口方法异常的异常，也可以不抛出任何异常。

二、下列哪个说法是正确的（）

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

A、ConcurrentHashMap使用synchronized关键字保证线程安全
B、HashMap实现了Collction接口
C、Array.asList方法返回java.util.ArrayList对象
D、SimpleDateFormat是线程不安全的

解析：

A选项中，jdk1.7中ConcurrentHashMap 使用segment来分段和管理锁，segment继承自ReentrantLock，因此ConcurrentHashMap使用ReentrantLock来保证线程安全。jdk 1.8中，取消了分段锁，改用node数组+CAS算法+synchronized锁的机制，提高了效率。

B中，HashMap定义规则如下：

public class HashMap<K,V>
    extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable

三、当编译并运行下面程序时会发生什么结果（）

public class Bground extends Thread{
    public static void main(String argv[]){
        Bground b = new Bground();
        b.run();
    }
    public void start(){
        for(int i=0;i<10;i++){
            System.out.println("Value of i = "+i);
        }
    }
}

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

A、编译错误，指明run方法没有定义
B、运行错误，只鞥呢run方法没有定义
C、编译通过并输出0到9
D、编译通过，但无输出

解析：

选D

对于线程而言，start是让线程从new变成runnable（可执行状态）。run方法才是执行体的入口。

但是在Thread中，run方法是个空方法，没有具体实现。

Bground继承了Thread，但是没有重写run方法，那么调用run方法肯定是无输出。

Thread 的执行过程，Theard的启动方法是start().线程类调用start();然后执行start0()本地方法，然后就没办法再追溯下去了。 start我听过别人说，是一个准备工作（比如你要吃苹果，不得先洗一下，真正吃时间是洗完后），并没有获得cpu，调用run()才是获得了cpu。

线程五种状态：新建状态、就绪状态、运行状态、阻塞状态及死亡状态。

四、下列叙述中，错误的是（）

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

A、File类能够存储文件属性
B、File类能够读写文件
C、File类能够建立文件
D、File类能够获取文件目录信息

解析：

能够读写文件的是数据流（OutputStream和InputStream）

五、从以下四个选项选出不同的一个。

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

A、LVS
B、Nginx
C、Lighttpd
D、Apache

解析：

其他三个都是web服务器LVS是 Linux Virtual Server的简写，意即Linux虚拟服务器，是一个虚拟的服务器集群系统

六、下面代码输出是？

enum AccountType
{
    SAVING, FIXED, CURRENT;
    private AccountType()
    {
        System.out.println("It is a account type");
    }
}
class EnumOne
{
    public static void main(String[]args)
    {
        System.out.println(AccountType.FIXED);
    }
}

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

A、编译正确，输出”It is a account type”once followed by”FIXED”
B、编译正确，输出”It is a account type”twice followed by”FIXED”
C、编译正确，输出”It is a account type”thrice followed by”FIXED”
D、编译正确，输出”It is a account type”four times followed by”FIXED”
E、编译错误

解析：

答案：C

枚举类有三个实例，故调用三次构造方法，打印三次It is a account type

七、以下代码将打印出

 public static void main (String[] args) { 
    String classFile = "com.jd.". replaceAll(".", "/") + "MyClass.class";
    System.out.println(classFile);
}

A、com. jd
B、com/jd/MyClass.class
C、///////MyClass.class
D、com.jd.MyClass

解析：

C。由于replaceAll方法的第一个参数是一个正则表达式，而"."在正则表达式中表示任何字符，所以会把前面字符串的所有字符都替换成"/"。如果想替换的只是"."，那么久要写成"\.".

‘.’在这里是被认作了正则表达式，对应的作用范围就是All字符串。。然后目标的字符串就都成///了。如果只是要换‘.’的话，先用【.】说明搁这儿的点就是普通的点，跟正则表达式那个家族没关系！可是吧，‘\’在JAVA里又是另一个大家族【转义字符】里的一员，所以还得再转义一下，说明它在这里只是为了改变‘.’的既定命运罢了。

笔记：

不会初始化子类的几种

调用的是父类的static方法或者字段
调用的是父类的final方法或者字段
通过数组来引用

八、关于java集合下列说法不正确的有哪些（）

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

A、HashSet 它是线程安全的，不允许存储相同的对象
B、ConcurrentHashMap 它是线程安全的，其中存储的键对象可以重复，值对象不能重复
C、Collection接口是List接口和Set接口的父接口，通常情况下不被直接使用
D、ArrayList线程安全的，允许存放重复对象

解析：

A:  HashSet 它不是线程安全的，属于Set接口下的实现类，Set下的实现类特征就是无序，不允许存储相同的对象、HashTable才线程安全

B:  ConcurrentHashMap 它是线程安全的HashMap实现，特征也相似，其中存储的值对象可以重复，键对象不能重复

C:  Collection接口是List接口和Set接口的父接口，通常情况下不被直接使用

D:  ArrayList线程不安全的，底层是数组实现，允许存放重复对象

九、下述有关c++的虚类和java接口的描述，说法错误的是？

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

A、c++虚类相当与java里面的抽象类
B、c++中没有接口的概念，与之对应的是纯虚类，对应的是java的接口
C、纯虚函数和虚函数的区别在于前者只包含定义，而后者还可以包含函数体。
D、一个抽象类和接口中的方法必须是抽象方法

解析：

1、一个子类只能继承一个抽象类（虚类），但能实现多个接口；
2、一个抽象类可以有构造方法，接口没有构造方法；
3、一个抽象类中的方法不一定是抽象方法，即其中的方法可以有实现（有方法体），接口中的方法都是抽象方法，不能有方法体，只有声明；
4、一个抽象类可以是public、private、protected、default,
   接口只有public;
5、一个抽象类中的方法可以是public、private、protected、default，
   接口中的方法只能是public和default

十、Given the following code:

package cn.com.test;

public class EnclosingOne {
    public class InsideOne {}

}

package cn.com.cow;

import cn.com.test.EnclosingOne;
import cn.com.test.EnclosingOne.InsideOne;
public class InerTest
{
    public static void main(String[]args)
    {
        EnclosingOne eo = new EnclosingOne();
        //insert code here 
    }

}

Which statement at line 10 constructs an instance of the inner class?

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

A、InsideOne ei=eo.new InsideOne();
B、eo.InsideOne ei=eo.new InsideOne();
C、InsideOne ei=EnclosingOne.new InsideOne();
D、EnclosingOne.InsideOne ei=eo.new InsideOne();

解析：

public class Enclosingone {
	//非静态内部类
	public class InsideOne {}
	//静态内部类
	public static class InsideTwo{}
}

class Mytest02{
	public static void main(String args []){
		Enclosingone.InsideOne obj1 = new Enclosingone().new InsideOne();//非静态内部类对象
		Enclosingone.InsideTwo obj2 = new Enclosingone.InsideTwo();//静态内部类对象
	}
}

内部类其实和类的属性没什么区别，只是在声明的时候必须是Outer.Inner a，就像int a 一样，至于静态内部类和非静态内部类new的时候有点区别，Outer.Inner a=new Outer().new Inner()（非静态，先有Outer对象才能有属性） Outer.Inner a=new Outer.Inner()要把Outer.Inner看成一部分，就像类变量一样

十一、character流和byte流的的说法错误的是

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

A、每次读入的字节数不同
B、前者带有缓冲，后者没有。
C、前者是字符读入，后者是字节读入。
D、二者没有区别，可以互换。

解析：

字符流和字节流每次读入的字节数是不确定的，可能相同也可能不相同；字符流和字节流都有缓冲流

3月14日

一、关于JDK1.8中Java的抽象类、接口，以下描述错误的是？

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

A、抽象类不一定含有抽象方法，接口中的方法都是抽象方法
B、一个类只能继承一个抽象类，但可以实现多个接口；一个接口可以继承多个接口
C、抽象类和接口中的方法都没有方法体
D、抽象类可以含有私有成员变量，接口不含有私有成员变量

解析：

A----------抽象类不一定含有抽象方法，接口中的方法都是抽象方法。

接口中的方法默认修饰符有public abstract。 B----------一个类只能继承一个一个抽象类，但可以实现多个接口；一个接口可以继承多个接口。 Java里类是单继承的，接口是可以多继承的，用关键字extends。 C----------抽象类和接口中的方法都没有方法体。抽象类中的方法是可以有方法体的。JDK1.8之后，接口中的方法也可以有方法体，用default关键字修饰方法。 D----------抽象类可以含有私有成员变量，接口不含有私有成员变量。接口中的成员变量都是public static final的，一般用作常量。

二、下面有关SPRING的事务传播特性，说法错误的是？

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

A、PROPAGATION_SUPPORTS：支持当前事务，如果当前没有事务，就以非事务方式执行
B、PROPAGATION_REQUIRED：支持当前事务，如果当前没有事务，就抛出异常
C、PROPAGATION_REQUIRES_NEW：新建事务，如果当前存在事务，把当前事务挂起
D、PROPAGATION_NESTED：支持当前事务，新增Savepoint点，与当前事务同步提交或回滚

解析：

Spring的API设计很不错，基本上根据英文翻译就能知道作用:Required:必须的。说明必须要有事物，没有就新建事物。supports:支持。说明仅仅是支持事务，没有事务就非事务方式执行。mandatory:强制的。说明一定要有事务，没有事务就抛出异常。required_new:必须新建事物。如果当前存在事物就挂起。not_supported:不支持事物，如果存在事物就挂起。never:绝不有事务。如果存在事物就抛出异常

三、如下代码的输出结果是什么？

public class Test { 
    public int aMethod(){
        static int i = 0;
        i++; 
        return i;
    } 
public static void main(String args[]){
    Test test = new Test(); 
    test.aMethod(); 
    int j = test.aMethod();
    System.out.println(j);
    } 
}

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

A、0
B、1
C、2
D、编译失败

解析：

Java中静态变量只能在类主体中定义，不能在方法中定义。静态变量属于类所有而不属于方法。

四、下面代码的输出是什么？

public class Base
{
    private String baseName = "base";
    public Base()
    {
        callName();
    }

    public void callName()
    {
        System. out. println(baseName);
    }

    static class Sub extends Base
    {
        private String baseName = "sub";
        public void callName()
        {
            System. out. println (baseName) ;
        }
    }
    public static void main(String[] args)
    {
        Base b = new Sub();
    }
}

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

A、null
B、sub
C、base

解析：

答案：A

new Sub();在创造派生类的过程中首先创建基类对象，然后才能创建派生类。

创建基类即默认调用Base()方法，在方法中调用callName()方法，由于派生类中存在此方法，则被调用的callName（）方法是派生类中的方法，此时派生类还未构造，所以变量baseName的值为null

1.首先，需要明白类的加载顺序。

(1) 父类静态代码块(包括静态初始化块，静态属性，但不包括静态方法)

(2) 子类静态代码块(包括静态初始化块，静态属性，但不包括静态方法 )

(3) 父类非静态代码块( 包括非静态初始化块，非静态属性 )

(4) 父类构造函数

(5) 子类非静态代码块 ( 包括非静态初始化块，非静态属性 )

(6) 子类构造函数

其中：类中静态块按照声明顺序执行，并且(1)和(2)不需要调用new类实例的时候就执行了(意思就是在类加载到方法区的时候执行的)

2.其次，需要理解子类覆盖父类方法的问题，也就是方法重写实现多态问题。

Base b = new Sub();它为多态的一种表现形式，声明是Base,实现是Sub类， 理解为 b 编译时表现为Base类特性，运行时表现为Sub类特性。

当子类覆盖了父类的方法后，意思是父类的方法已经被重写，题中 父类初始化调用的方法为子类实现的方法，子类实现的方法中调用的baseName为子类中的私有属性。

由1.可知，此时只执行到步骤4.,子类非静态代码块和初始化步骤还没有到，子类中的baseName还没有被初始化。所以此时 baseName为空。所以为null。

编译看左边，运行看右边

五、假设 a 是一个由线程 1 和线程 2 共享的初始值为 0 的全局变量，则线程 1 和线程 2 同时执行下面的代码，最终 a 的结果不可能是（）

boolean isOdd = false;
for(int i=1;i<=2;++i){
    if(i%2==1)isOdd = true;
    else isOdd = false;
    a+=i*(isOdd?1:-1);
}

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

A、-1
B、-2
C、0
D、1

解析：

不管怎样线程对a的操作就是+1后-2

1.线程1执行完再线程2执行，1-2+1-2=-2

2.线程1和2同时+1，再-2不同时，1-2-2=-3

3.线程1和2不同时+1，同时-2，1+1-2=0

4.线程1和2既同时+1又同时-2，1-2=-1

没有结果为1的情况

六、下列哪些操作会使线程释放锁资源？

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

A、sleep()
B、wait()
C、join()
D、yield()

解析：

1.sleep会使当前线程睡眠指定时间，不释放锁

2.yield会使当前线程重回到可执行状态，等待cpu的调度，不释放锁

3.wait会使当前线程回到线程池中等待，释放锁，当被其他线程使用notify，notifyAll唤醒时进入可执行状态

4.当前线程调用某线程.join（）时会使当前线程等待某线程执行完毕再结束，底层调用了wait，释放锁

七、对 Map 的用法，正确的有：

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

A、new java.util.Map().put("key" , "value") ;
B、new java.util.SortedMap().put("key" , "value") ;
C、new java.util.HashMap().put( null , null ) ;
D、new java.util.TreeMap().put( 0 , null ) ;

解析：

选C、D。考察的是Map接口实现类的创建对象以及对象类型包含的方法。

A选项Map属于接口类型，不可以new的方式创建对象。所以A错误。

B选项SortedMap属于接口类型，不可以new的方式创建对象。所以B错误。

C选项HashMap基于哈希表实现Map接口的类，并允许null的值和null键。

D选项TreeMap通过红黑树实现Map接口的类，key不可以为null，会报NullPointerException异常,value可以为null。

八、Hashtable 和 HashMap 的区别是：

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

A、Hashtable 是一个哈希表，该类继承了 AbstractMap，实现了 Map 接口
B、HashMap 是内部基于哈希表实现，该类继承AbstractMap，实现Map接口
C、Hashtable 线程安全的，而 HashMap 是线程不安全的
D、Properties 类 继承了 Hashtable 类，而 Hashtable 类则继承Dictionary 类
E、HashMap允许将 null 作为一个 entry 的 key 或者 value，而 Hashtable 不允许。

解析：

选B、C、D、E。

Hashtable：

（1）Hashtable 是一个散列表，它存储的内容是键值对(key-value)映射。

（2）Hashtable 的函数都是同步的，这意味着它是线程安全的。它的key、value都不可以为null。

（3）HashTable直接使用对象的hashCode。

HashMap：

（1）由数组+链表组成的，基于哈希表的Map实现，数组是HashMap的主体，链表则是主要为了解决哈希冲突而存在的。

（2）不是线程安全的，HashMap可以接受为null的键(key)和值(value)。

（3）HashMap重新计算hash值

Hashtable扩容时，将容量变为原来的2倍加1，而HashMap扩容时，将容量变为原来的2倍。

properties继承自Hashtable类，因此是线程安全的。

Hashtable,HashMap,Properties继承关系如下：

public class Hashtable<K,V> extends Dictionary<K,V>
    implements Map<K,V>, Cloneable, java.io.Serializable

public class HashMap<K,V>extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable

笔记插入：

局部内部类是放在代码块或方法中的，不能有访问控制修饰符，且不能用static修饰

九、关于Java的一些概念，下面哪些描述是正确的：( )

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

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作用非静态成员方法和静态成员方法上同步的目标是不同的

解析：

A.错误（Error）的基类是Throwable

C.基本类型不是对象

D.垃圾回收器并不总是工作，只有当内存资源告急时，垃圾回收器才会工作；即使垃圾回收器工作，finalize方法也不一定得到执行，这是由于程序中的其他线程的优先级远远高于执行finalize（）函数线程的优先级。（这是楼下的答案）

E.低版本JRE无法运行高版本JRE

十、mysql数据库，game_order表表结构如下，下面哪些sql能使用到索引（）？

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

A、select * from game_order where plat_game_id=5 and plat_id=134
B、select * from game_order where plat_id=134 and plat_game_id=5 and plat_order_id=’100’
C、select * from game_order where plat_order_id=’100’
D、select * from game_order where plat_game_id=5 andplat_order_id=’100’ and plat_id=134
E、select * from game_order where plat_game_id=5 and plat_order_id=’100’

解析：

这道题目想考察的知识点是MySQL组合索引（复合索引）的最左优先原则。最左优先就是说组合索引的第一个字段必须出现在查询组句中，这个索引才会被用到。只要组合索引最左边第一个字段出现在Where中，那么不管后面的字段出现与否或者出现顺序如何，MySQL引擎都会自动调用索引来优化查询效率。
根据最左匹配原则可以知道B-Tree建立索引的过程，比如假设有一个3列索引(col1,col2,col3),那么MySQL只会会建立三个索引(col1),(col1,col2),(col1,col2,col3)。
所以题目会创建三个索引（plat_order_id）、（plat_order_id与plat_game_id的组合索引）、（plat_order_id、plat_game_id与plat_id的组合索引）。根据最左匹配原则，where语句必须要有plat_order_id才能调用索引（如果没有plat_order_id字段那么一个索引也调用不到），如果同时出现plat_order_id与plat_game_id则会调用两者的组合索引，如果同时出现三者则调用三者的组合索引。
题目问有哪些sql能使用到索引，个人认为只要Where后出现了plat_order_id字段的SQL语句都会调用到索引，只不过是所调用的索引不同而已，所以选BCDE。如果题目说清楚是调用到三个字段的复合索引，那答案才是BD。

带头大哥不能死，中间兄弟不能断！

like百分放左边，范围之后全失效！

3月15日

一、一般用()创建InputStream对象,表示从标准输入中获取数据,用()创建OutputStream对象，表示输出到标准输出设备中。

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

A、System.in System.out
B、System.out System.in
C、System.io.in System.io.out
D、System.io.out System.io.in

记好打印到控制台用System.out.println()，这题就永远不会错

二、关于访问权限说法正确的是？ ( )

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

A、外部类定义前面可以修饰public,protected和private
B、局部内部类前面可以修饰public,protected和private
C、匿名内部类前面可以修饰public,protected和private
D、以上说法都不正确

对于外部类来说，只有两种修饰，public和默认（default），因为外部类放在包中，只有两种可能，包可见和包不可见。

成员内部类可以拥有private访问权限、protected访问权限、public访问权限及包访问权限

局部内部类就像是方法里面的一个局部变量一样，是不能有public、protected、private以及static修饰符的。

匿名内部类是不能有访问修饰符和static修饰符的；

三、假如某个JAVA进程的JVM参数配置如下： -Xms1G -Xmx2G -Xmn500M -XX:MaxPermSize=64M -XX:+UseConcMarkSweepGC -XX:SurvivorRatio=3, 请问eden区最终分配的大小是多少？

正确答案: C 你的答案: C (正确)

A、64M
B、500M
C、300M
D、100M

这是网易2016年在线笔试题中的一道选择题。先分析一下里面各个参数的含义： -Xms：1G ，就是说初始堆大小为1G -Xmx：2G ，就是说最大堆大小为2G -Xmn：500M ，就是说年轻代大小是500M（包括一个Eden和两个Survivor） -XX:MaxPermSize：64M ，就是说设置持久代最大值为64M -XX:+UseConcMarkSweepGC ，就是说使用使用CMS内存收集算法 -XX:SurvivorRatio=3 ，就是说Eden区与Survivor区的大小比值为3：1：1

题目中所问的Eden区的大小是指年轻代的大小，直接根据-Xmn：500M和-XX:SurvivorRatio=3可以直接计算得出

500M*(3/(3+1+1)) =500M*（3/5） =500M*0.6 =300M 所以Eden区域的大小为300M。

四、URL u =new URL("http://www.123.com");。如果www.123.com不存在，则返回__。

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

A、http://www.123.com
B、””
C、null
D、抛出异常

new URL()时必须捕获检查异常，但这个异常是由于字符串格式和URL不符导致的，与网址是否存在无关。URL的toString方法返回字符串，无论网址是否存在。

五、以下代码段执行后的输出结果为

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

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

A、-7
B、-3
C、编译错误
D、-5

java中的i++和++i在java语言层面上来看使用中间量机制，i=i++，i不变，i=++i相当于++i，而结合在一个语句里使用则会报错，因为++后应该跟变量。同理，i=(++i)++也是不对的。

这题编译错误在于这一句： i = ++(i++); ++（）括号里面必须是一个变量，而 i ++ 是一个字面量。

字面量就是指这个量本身，比如字面量3。也就是指3. 再比如 string类型的字面量"ABC", 这个"ABC" 通过字来描述。所以就是字面量，虽然很难下定义。你就理解成一眼就能知道的量。对比下 string x; 那么x 是多少呢？它是个变量，你不确定它的值。但是string x="ABC"，你当然知道"ABC" 就是"ABC"了，一眼就能看到值的量（有点像常量）。 string x="ABC" 意思是把字面量"ABC" 赋值给变量X. 再举例 const string y="cbd". 意思是把字面量"cbd" 赋值给了常量y.

六、下面代码运行结果是？

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

七、下面代码在main()方法中第八行后可以正常使用的是（）

public class Test
{ 
    private int a=10; 
    int b=20; 
    static int c=1; 
    public static void main(String arg[])
    { 
        Test t = new Test(); 
    } 
 }

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

A、t.a
B、this.c
C、Test.b
D、t.c

A : 在private 修饰不能在外部类中调用，main 方法属于Test类的方法，所以对象 t 可以在他自己的类方法中调用它的private

B ： static 方法中没有this 这么一说

C: b不是static变量

D: 合理

八、以下哪些方法可以取到http请求中的cookie值（）?

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

A、request.getAttribute
B、request.getHeader
C、request.getParameter
D、request.getCookies

下面的方法可用在 Servlet 程序中读取 HTTP 头。这些方法通过 HttpServletRequest 对象可用：

1）Cookie[] getCookies() 返回一个数组，包含客户端发送该请求的所有的 Cookie 对象。

2）Object getAttribute(String name) 以对象形式返回已命名属性的值，如果没有给定名称的属性存在，则返回 null。

3）String getHeader(String name) 以字符串形式返回指定的请求头的值。Cookie也是头的一种；

4）String getParameter(String name) 以字符串形式返回请求参数的值，或者如果参数不存在则返回 null。

九、哪个正确

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

A、abstract类只能用来派生子类，不能用来创建abstract类的对象。
B、final类不但可以用来派生子类，也可以用来创建final类的对象。
C、abstract不能与final同时修饰一个类。
D、abstract类定义中可以没有abstract方法。

选 ACD

A，抽象类和接口都不可以实例化。

B，final类不能被继承。

**C，**abstract不能和final共用修饰类。

D，抽象类中可以没有抽象方法，有抽象方法的类一定是抽象类。

注意：abstract是用来修饰类和方法的：

1. 修饰方法：abstract不能和private、final、static共用。

2. 修饰外部类：abstract不能和final、static共用。（外部类的访问修饰符只能是默认和public）

3. 修饰内部类：abstract不能和final共用。（内部类四种访问修饰符都可以修饰）

十、以下说法哪个是正确的（）

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

A、IOException在编译时会被发现
B、NullPointerEception在编译时不被发现
C、SQLException在编译时会被发现
D、FileNotFoundException在编译时会被发现

十一、Servlet的生命周期可以分为初始化阶段，运行阶段和销毁阶段三个阶段，以下过程属于初始化阶段是（）。

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

A、加载Servlet类及.class对应的数据
B、创建servletRequest和servletResponse对象
C、创建ServletConfig对象
D、创建Servlet对象

Servlet的生命周期一般可以用三个方法来表示：

init()：仅执行一次，负责在装载Servlet时初始化Servlet对象
service() ：核心方法，一般HttpServlet中会有get,post两种处理方式。在调用doGet和doPost方法时会构造servletRequest和servletResponse请求和响应对象作为参数。
destory()：在停止并且卸载Servlet时执行，负责释放资源

初始化阶段：Servlet启动，会读取配置文件中的信息，构造指定的Servlet对象，创建ServletConfig对象，将ServletConfig作为参数来调用init()方法。所以选ACD。B是在调用service方法时才构造的

十二、下面有关 Java ThreadLocal 说法正确的有？

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

A、ThreadLocal存放的值是线程封闭，线程间互斥的，主要用于线程内共享一些数据，避免通过参数来传递
B、线程的角度看，每个线程都保持一个对其线程局部变量副本的隐式引用，只要线程是活动的并且 ThreadLocal 实例是可访问的；在线程消失之后，其线程局部实例的所有副本都会被垃圾回收
C、在Thread类中有一个Map，用于存储每一个线程的变量的副本。
D、对于多线程资源共享的问题，同步机制采用了“以时间换空间”的方式，而ThreadLocal采用了“以空间换时间”的方式

**ThreadLocal类用来提供线程内部的局部变量。这种变量在多线程环境下访问(通过get或set方法访问)时能保证各个线程里的变量相对独立于其他线程内的变量。**ThreadLocal实例通常来说都是private static类型的，用于关联线程和线程的上下文。可以总结为一句话：ThreadLocal的作用是提供线程内的局部变量，这种变量在线程的生命周期内起作用，减少同一个线程内多个函数或者组件之间一些公共变量的传递的复杂度。

ThreadLocal设计的初衷：提供线程内部的局部变量，在本线程内随时随地可取，隔离其他线程。

十三、在Java语言中，下列关于字符集编码（Character set encoding）和国际化（i18n）的问题，哪些是正确的？

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

A、每个中文字符占用2个字节，每个英文字符占用1个字节
B、假设数据库中的字符是以GBK编码的，那么显示数据库数据的网页也必须是GBK编码的。
C、Java的char类型，通常以UTF-16 Big Endian的方式保存一个字符。
D、实现国际化应用常用的手段是利用ResourceBundle类

A 显然是错误的，Java一律采用Unicode编码方式，每个字符无论中文还是英文字符都占用2个字节。

B 也是不正确的，不同的编码之间是可以转换的，通常流程如下：

将字符串S以其自身编码方式分解为字节数组，再将字节数组以你想要输出的编码方式重新编码为字符串。

例：String newUTF8Str = new String(oldGBKStr.getBytes("GBK"), "UTF8");

C 是正确的。Java虚拟机中通常使用UTF-16的方式保存一个字符

D 也是正确的。ResourceBundle能够依据Local的不同，选择性的读取与Local对应后缀的properties文件，以达到国际化的目的。

3月16日

一、下面对静态数据成员的描述中，正确的是

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

A、静态数据成员可以在类体内进行初始化
B、静态数据成员不可以被类的对象调用
C、静态数据成员不受private控制符的作用
D、静态数据成员可以直接用类名调用

D选项需要考虑在A类通过类名访问B类的静态成员变量时，B类的静态成员变量必须public修饰

二、下面哪个行为被打断不会导致InterruptedException：（）？

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

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 方法

三、已知x >= y and y >= z 为真，那么x > z or y = z 值为

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

A、真
B、假
C、无法确定
D、x y z同为正数时为真

答案应该是C

条件可以简单分析为数学不等式 x>=y>=z，那么x>z不一定为true

当x>z为true，后面的条件忽略，结果为真；

当x==z，x>z为fslae，继续判断后一个条件

如果z==0，则y=z为false，结果为假；

如果z!=0，则y=z为true，结果为真；

所以，最后的结果是不确定的。

四、在创建派生类对象，构造函数的执行顺序（）

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

A、基类构造函数，派生类对象成员构造函数，派生类本身的构造函数
B、派生类本身的构造函数，基类构造函数，对象成员构造函数
C、基类构造函数，派生类本身的构造函数，派生类对象成员构造函数
D、对象成员构造函数，基类构造函数，派生类本身的构造函数

构造块，就是对象成员构造函数

五、以下哪个式子有可能在某个进制下成立（）

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

A、13*14=204
B、12*34=568
C、14*14=140
D、1+1=3

六、下列有关java构造函数叙述正确的是（）

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

A、构造器的返回值为void类型
B、如果一个源文件中有多个类，那么构造器必须与公共类同名
C、构造器可以有0个，1个或一个以上的参数
D、每个类可以有一个以上的构造器

（1）A构造函数无返回值，错误；

（2）B中多个类时构造函数不一定与公共类同名，因为每个类都可以有构造函数，函数名同所属类，错误；

（3）C构造器可以有任意个参数，对的；

（4）D每个类都默认有一个构造函数，选项中“一个以上”的描述，让人误解至少要两个，所以错误。

所以答案对错不重要，理解就好。

七、下列代码片段中，存在编译错误的语句是()

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

------------知识点------------

Java表达式转型规则由低到高转换：

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修饰，即只可赋值一次，便不可再改变。

八、执行如下程序代码

char chr = 127;
int sum = 200;
chr += 1;
sum += chr;

后，sum的值是（）

备注：同时考虑c/c++和Java的情况的话

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

A、72
B、99
C、328
D、327

java中只有byte, boolean是一个字节, char是两个字节, 所以对于java来说127不会发生溢出, 输出328

但是对于c/c++语言来说, char是一个字节, 会发生溢出, 对127加一发生溢出, 0111 1111 --> 1000 0000, 1000 0000为补码-128, 所以结果为200-128=72

九、Hashtable 和 HashMap 的区别是：

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

A、Hashtable 是一个哈希表，该类继承了 AbstractMap，实现了 Map 接口
B、HashMap 是内部基于哈希表实现，该类继承AbstractMap，实现Map接口
C、Hashtable 线程安全的，而 HashMap 是线程不安全的
D、Properties 类 继承了 Hashtable 类，而 Hashtable 类则继承Dictionary 类
E、HashMap允许将 null 作为一个 entry 的 key 或者 value，而 Hashtable 不允许。

public class Hashtable<K,V> extends Dictionary<K,V>
    implements Map<K,V>, Cloneable, java.io.Serializable

public class HashMap<K,V>extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable

十、下列哪些方法是针对循环优化进行的

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

A、强度削弱
B、删除归纳变量
C、删除多余运算
D、代码外提

循环优化：对循环中的代码段，可以进行代码外提、强度削弱和删除归纳变量等优化。

3月17日

一、下面哪个选项正确创建socket连接？

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

A、Socket s = new Socket(8080);
B、Socket s = new Socket(“192.168.1.1”,8080)
C、SocketServer s = new Socket(8080);
D、Socket s = new SocketServer(“192.168.1.1”,8080)

服务器端：ServerSocket提供的实例 ServerSocket server = new ServerSocket(端口号)

客户端：Socket提供的实例 Socket client = new Socket(IP地址，端口号)

二、以下代码执行的结果显示是多少（）？

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

A、num * count = 505000
B、num * count = 0
C、运行时错误
D、num * count = 5050

count = count++ 原理是 temp = count； count = count+1 ； count = temp；因此count始终是0 这仅限于java 与c是不一样的

三、以下代码的输出结果是？

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();
    }
}

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

A、静态块 构造块 构造块 构造块
B、构造块 静态块 构造块 构造块
C、构造块 构造块 静态块 构造块
D、构造块 构造块 构造块 静态块

并不是静态块最先初始化,而是静态域.

而静态域中包含静态变量、静态块和静态方法,其中需要初始化的是静态变量和静态块.而他们两个的初始化顺序是靠他们俩的位置决定的!

So！

初始化顺序是 t1 t2 静态块

四、A,B,C,D 中哪些是 setvar的重载？

public class methodover
{
    public void setVar(int a, int b, float c) {}
}

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

A、private void setVar(int a， float c， int b){}
B、protected void setVar(int a， int b， float c){}
C、public int setVar(int a， float c， int b){return a;}
D、public int setVar(int a， float c){return a;}

ACD

重载是在同一个类中，有多个方法名相同，参数列表不同(参数个数不同，参数类型不同),与方法的返回值无关，与权限修饰符无关，B中的参数列表和题目的方法完全一样了。

五、下面有关forward和redirect的描述，正确的是() ？

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

A、forward是服务器将控制权转交给另外一个内部服务器对象，由新的对象来全权负责响应用户的请求
B、执行forward时，浏览器不知道服务器发送的内容是从何处来，浏览器地址栏中还是原来的地址
C、执行redirect时，服务器端告诉浏览器重新去请求地址
D、forward是内部重定向，redirect是外部重定向
E、redirect默认将产生301 Permanently moved的HTTP响应

A选项服务器会直接访问目标地址的URL，不会把控制权转交，因此错误！

1.从地址栏显示来说

forward是服务器请求资源,服务器直接访问目标地址的URL,把那个URL的响应内容读取过来,然后把这些内容再发给浏览器.浏览器根本不知道服务器发送的内容从哪里来的,所以它的地址栏还是原来的地址.

redirect是服务端根据逻辑,发送一个状态码,告诉浏览器重新去请求那个地址.所以地址栏显示的是新的URL.

2.从数据共享来说

forward:转发页面和转发到的页面可以共享request里面的数据.

redirect:不能共享数据.

3.从运用地方来说

forward:一般用于用户登陆的时候,根据角色转发到相应的模块.

redirect:一般用于用户注销登陆时返回主页面和跳转到其它的网站等.

4.从效率来说

forward:高.

redirect:低.

六、关于java中的数组，下面的一些描述，哪些描述是准确的：（）

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

A、数组是一个对象，不同类型的数组具有不同的类
B、数组长度是可以动态调整的
C、数组是一个连续的存储结构
D、一个固定长度的数组可类似这样定义：int array[100]
E、两个数组用Object 里equals方法比较时，会逐个遍历其中的元素，对每个元素进行比较
F、java中不存在 int *a这样的东西做数组的形参

数组a.equals(数组b)，调用的equals方法为Object的，比较的是地址，相当于==，Arrays的equals方法是逐个元素比较

七、true、false、null、sizeof、goto、synchronized 哪些是Java关键字？

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

A、true
B、false
C、null
D、sizeof
E、goto
F、synchronized

八、下面关于Applet的说法是正确的是

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

A、Applet可以在带有Java解释器的浏览器中运行
B、Applet类必须继承java.applet.Applet
C、Applet可以访问本地文件
D、Applet是Object类的子类

九、下列那些方法是线程安全的(所调用的方法都存在)

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

A、public class MyServlet implements Servlet {
    public void service (ServletRequest req, ServletResponse resp) {
    BigInteger I = extractFromRequest(req);
    encodeIntoResponse(resp,factors);
    }
    }
    
B、public class MyServlet implements Servlet {
    private long count =0;
    public long getCount() {
    return count;
    }
    public void service (ServletRequest req, ServletResponse resp) {
    BigInteger I = extractFromRequest(req);
    BigInteger[] factors = factor(i);
    count ++;
    encodeIntoResponse(resp,factors);
    }
    }
    
C、public class MyClass {
    private int value;
    public synchronized int get() {
    return value;
    }
    public synchronized void set (int value) {
    this.value = value;
    }
    }
    public class Factorizer implements Servlet {
    private volatile MyCache cache = new MyCache(null,null);

D、public void service(ServletRequest req, ServletResponse resp) {
    BigInteger i = extractFromRequest(req);
    BigInteger[] factors = cache.getFactors(i);
    if (factors == null) {
    factors = factor(i);
    cache = new MyCache(i,factors);
    }
    encodeIntoResponse(resp,factors);
    }

A：没有成员（没有共享资源），线程安全；

B：假设存在线程1和线程2，count初始值为0，当线程1执行count++中count+1（此时未写回最终计算值），这时线程2执行count++中读取count，发生数据错误，导致线程1线程2的结果都为1，而不是线程1的结果为1，线程2的结果为2，线程不安全；

C：成员私有，对成员的set get方法都加重量级锁，线程安全；

D：volatile有两个作用：可见性（volatile变量的改变能使其他线程立即可见，但它不是线程安全的，参考B）和禁止重排序；这里是可见性的应用，类中方法对volatile修饰的变量只有赋值，线程安全；欢迎指正。

十、class A {} class B extends A {} class C extends A {}

class D extends B {}

下面的哪4个语句是正确的？

正确答案: A C D G 你的答案: B D E F G (错误)

A、The type List<A>is assignable to List.
B、The type List<B>is assignable to List<A>.
C、The type List<Object>is assignable to List<?>.
D、The type List<D>is assignable to List<?extends B>.
E、The type List<?extends A>is assignable to List<A>.
F、The type List<Object>is assignable to any List reference.
G、The type List<?extends B>is assignable to List<?extends A>.

1. 只看尖括号里边的！！明确点和范围两个概念*

2. 如果尖括号里的是一个类，那么尖括号里的就是一个点，比如List,List,List

牛客网刷题错题记录(Java)

牛客网刷题错题记录一(Java)

3月7日

3月8日

3月9日

3月10日

3月11日

3月12日

3月13日

3月14日

3月15日

3月16日

3月17日

3月18日

评论