2021-01-21

                        ***Java30题***

1.Java 语言中，负责并发管理的机制是（ ）

正确答案: D 你的答案: D (正确)
A.垃圾回收
B.虚拟机
C.代码安全
D.多线程
解析：选项A，Java语言中，垃圾回收机制对系统中不使用的内存进行回收，从而使程序员从繁忙的内存管理中解放出来。
选项B，Java编写好的程序首先由编译器转换为标准字节代码，然后由虚拟机执行。虚拟机把字节代码程序与各操作系统和硬件分开，使Java程序独立于平台。
选项C，Java的代码安全检测体现在多个层次上，在编译层、解释层、平台层分别作不同的安全检查。
选项D，多线程是Java程序的并发机制，它能同步共享数、处理不同的事件。

因此，本题的正确答案是D。

2.区分类中重载方法的依据是( )。

正确答案: C 你的答案: B (错误)
A.不同的形参名称
B.不同的返回值类型
C.不同的形参列表
D.不同的访问权限
解析：重载：
编译时的多态
重载发生在同一个类中
函数名相同，参数列表不同(参数的类型，顺序，个数 和参数名没有关系) 和方法的返回值类型无关 (因为编译器 并不知道 调用哪一个函数)
可以抛出不同的异常，可以有不同修饰符

重写：
运行时的多态
重载发生在子类与父类中
遵循两同两小一大
两同：
函数名相同
参数列表相同
两小：
子类被重写方法的返回值类型小于父类被重写方法的返回值
子类被重写方法抛出异常的类型小于父类被重写方法抛出异常的类型
一大：
子类被重写方法的访问权限大于等于父类被重写方法的访问权限
构造方法不能被重写，声明为 final 的方法不能被重写，声明为 static 的方法不能被重写（隐藏），但是能够被再次声明，父类的私有方法，子类可以继承 但是子类不能访问，子类不能重写父类的私有方法。

3.已知 声明并初始化二维数组 int a[ ][ ]={{1,2},{3,4},{5,6}} ，则 a[1][1] 的值为（）
正确答案: C 你的答案: B (错误)
A.1
B.2
C.4
D.5
解析：二维数组: 0 1
0 {1,2}
1 {3,4}
2 {5,6} 所以a[1][1]=4;
a[0][0]=1,a[0][1]=2,a[1][0]=3,a[1][1]=4,a[2][0]=5,a[2][1]=6.

4.如果一个方法或变量是"private"访问级别，那么它的访问范围是:
正确答案: D 你的答案: D (正确)
在当前类，或者子类中
在当前类或者它的父类中
在当前类，或者它所有的父类中
在当前类中
解析：
5.程序Demo.java编译运行后输出的结果是：( )
public class Demo{
int x=1；

int y；
public static void main（String [] args）{

    int z=2;

    Demo t=new Demo();
    System.out.println(t.x+t.y+z);
}

}
正确答案: A 你的答案: B (错误)
A.3
B.12
C.1
D.5
解析：这题考的是默认初始化问题，但是可以引出另外一个问题：局部变量参与运算前是必须要初始化的，比如下面的代码就会编译出错，提示y必须要初始化。

6.Java Application 源程序的主类是指包含有（ ）方法的类。
正确答案: A 你的答案: B (错误)
A.public static void main方法
B.toString方法
C.init方法
D.actionPerfromed方法
解析：一个类的内部可以有多个方法名为main的方法啊，是有定义为 public static void的main方法才是主类。

7.导出类调用基类的构造器必须用到的关键字： ( )

正确答案: C 你的答案: C (正确)
A.this
B.final
C.super
D.static
解析：其实觉得这道题难的，基本上都是不了解什么是基类和导出类。基类就是父类，也叫超类。导出类就是子类，也叫派生类。

8.列表(List)和集合(Set)下面说法正确的是？ ( )

正确答案: A 你的答案: A (正确)
A.Set中至多只能有一个空元素
B.List中至多只能有一个空元素
C.List和Set都可以包含重复元素的有序集合
D.List和Set都是有序集合
解析：Set 不能有重复的元素，且是无序的，要有空值也就只能有一个。因为它不允许重复。

9.下面关于JAVA的垃圾回收机制，正确的是（ ）
正确答案: B 你的答案: A (错误)
A.当调用“System.gc()”来强制回收时，系统会立即回收垃圾
B.垃圾回收不能确定具体的回收时间
C.程序可明确地标识某个局部变量的引用不再被使用
D.程序可以显式地立即释放对象占有的内存
解析：java提供了一个系统级的线程，即垃圾回收器线程。用来对每一个分配出去的内存空间进行跟踪。当JVM空闲时，自动回收每块可能被回收的内存，GC是完全自动的，不能被强制执行。程序员最多只能用System.gc()来建议执行垃圾回收器回收内存，但是具体的回收时间，是不可知的。当对象的引用变量被赋值为null，可能被当成垃圾。

10.下列修饰符中，能够使得某个成员变量可被它所在包访问到和它的子类访问到的是（ ）

正确答案: A 你的答案: B (错误)
A.protected
B.public
C.private
D.应不加修饰符

解析：

题目出的有问题，但是只能选A了
protected：可被同一包以及包外子类访问
private：只能自己访问
default：只能被同一包访问

11.能单独和finally语句一起使用的块是( )

正确答案: A 你的答案: A (正确)
A.try
B.catch
C.throw
D.throws
解析：解析：处理异常常用的两种方式：
1、try…catch(捕获处理机制)；
2、throws(冒泡处理机制).
注意细节：使用try…catch块捕获时可以没有catch块,但当没用catch块的时候必须得有finally块.故选A）

12.如下语句通过算术运算和逻辑运算之后i和 j的结果是（ ）

int i=0;
int j=0;
if((++i>0)||(++j>0))
{
//打印出i和j的值。
}

正确答案: D 你的答案: B (错误)
i=0;j=0
i=1;j=1
i=0;j=1
i=1;j=0
解析：++i先自增再运算，i++先运算在自增，所以i=1。||短路前一部分不正确就不会继续执行，所以j=0.

13.When is the text “Hi there”displayed?

public class StaticTest
{
static
{
System.out.println(“Hi there”);
}

public void print()
{
    System.out.println(“Hello”);
}

public static void main(String args[])
{
    StaticTest st1 = new StaticTest();
    st1.print();
    StaticTest st2 = new StaticTest();
    st2.print();
}

}

正确答案: C 你的答案: C (正确)
A.Never.
B.Each time a new object of type StaticTest is created.
C.Once when the class is loaded into the Java virtual machine.
D.Only when the main() method is executed.

14.以下程序输出（）

public static void main(String[] args) {
int num = 2;
switch (num) {
case 1:
++num;
case 2:
++num;
case 3:
++num;
default:
++num;
break;
}
System.out.println(num);
}
}

正确答案: D 你的答案: B (错误)
A.2
B.3
C.4
D.5
解析：匹配到case 2 num->3 但是其后没有break,所以继续执行case 3 num->4、default num->5而后结束,所以答案为 5
注意细节！

15.下列关于异常处理的描述中，错误的是()。

正确答案: D 你的答案: D (正确)
A.程序运行时异常由Java虚拟机自动进行处理
B.使用try-catch-finally语句捕获异常
C.可使用throw语句抛出异常
D.捕获到的异常只能在当前方法中处理，不能在其他方法中处理
解析：编译时异常必须显示处理，运行时异常交给虚拟机。
运行时异常可以不处理。当出现这样的异常时，总是由虚拟机接管。比如我们从来没有人去处理过Null Pointer Exception异常，它就是运行时异常，并且这种异常还是最常见的异常之一。出现运行时异常后，系统会把异常一直往上层抛，一直遇到处理代码。如果没有处理块，到最上层，如果是多线程就由Thread.run()抛出，如果是单线程就被main()抛出。抛出之后，如果是线程，这个线程也就退出了。如果是主程序抛出的异常，整个程序也就退出了。运行时异常是Exception的子类，也有一般异常的特点，是可以被Catch块处理的。只不过往往不对它处理罢了。也就是说，如果不对运行时异常进行处理，那么出现运行时异常之后，要么是线程中止，要么是主程序终止。

16.下面有关JVM内存，说法错误的是？
正确答案: C 你的答案: B (错误)
A.程序计数器是一个比较小的内存区域，用于指示当前线程所执行的字节码执行到了第几行，是线程隔离的
B.虚拟机栈描述的是Java方法执行的内存模型，用于存储局部变量，操作数栈，动态链接，方法出口等信息，是线程隔离的
C.方法区用于存储JVM加载的类信息、常量、静态变量、以及编译器编译后的代码等数据，是线程隔离的
D.原则上讲，所有的对象都在堆区上分配内存，是线程之间共享的
解析：大多数 JVM 将内存区域划分为 Method Area（Non-Heap）（方法区） ,Heap（堆） , Program Counter Register（程序计数器） , VM Stack（虚拟机栈，也有翻译成JAVA 方法栈的）,Native Method Stack （ 本地方法栈 ），其中Method Area 和 Heap 是线程共享的 ，VM Stack，Native Method Stack 和Program Counter Register 是非线程共享的。为什么分为 线程共享和非线程共享的呢?请继续往下看。

首先我们熟悉一下一个一般性的 Java 程序的工作过程。一个 Java 源程序文件，会被编译为字节码文件（以 class 为扩展名），每个java程序都需要运行在自己的JVM上，然后告知 JVM 程序的运行入口，再被 JVM 通过字节码解释器加载运行。那么程序开始运行后，都是如何涉及到各内存区域的呢？

概括地说来，JVM初始运行的时候都会分配好 Method Area（方法区） 和Heap（堆） ，而JVM 每遇到一个线程，就为其分配一个 Program Counter Register（程序计数器） , VM Stack（虚拟机栈）和Native Method Stack （本地方法栈）， 当线程终止时，三者（虚拟机栈，本地方法栈和程序计数器）所占用的内存空间也会被释放掉。这也是为什么我把内存区域分为线程共享和非线程共享的原因，非线程共享的那三个区域的生命周期与所属线程相同，而线程共享的区域与JAVA程序运行的生命周期相同，所以这也是系统垃圾回收的场所只发生在线程共享的区域（实际上对大部分虚拟机来说知发生在Heap上）的原因。

17.Integer i = 42;
Long l = 42l;
Double d = 42.0;
下面为true的是
正确答案: G 你的答案: G (正确)
A.(i == l)
B.(i == d)
C.(l == d)
D.i.equals(d)
E.d.equals(l)
F.i.equals(l)
G.l.equals(42L)
解析：1、基本型和基本型封装型进行“==”运算符的比较，基本型封装型将会自动拆箱变为基本型后再进行比较，因此Integer(0)会自动拆箱为int类型再进行比较，显然返回true；

     int a = 220;

     Integer b = 220;

    System.out.println(a==b);//true

2、两个Integer类型进行“==”比较， 如果其值在-128至127 ，那么返回true，否则返回false, 这跟Integer.valueOf()的缓冲对象有关，这里不进行赘述。

    Integer c=3;
    Integer h=3;
    Integer e=321;
    Integer f=321;
    System.out.println(c==h);//true
    System.out.println(e==f);//false

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

    Integer a=1;
    Integer b=2;
    Integer c=3;
    System.out.println(c.equals(a+b));//true

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

    int i=1;
    int j = 2;
    Integer c=3;
    System.out.println(c.equals(i+j));//true

18.Java用（）机制实现了进程之间的同步执行
正确答案: A 你的答案: B (错误)
A.监视器
B.虚拟机
C.多个CPU
D.异步调用
解析：A:
The code segments within a program that access the same object from separate, concurrent threads are called “critical sections”。
翻译：在一个程序当中代码段访问了同一个对象从单独的并发的线程当中，那么这个代码段叫”临界区”
怎么解决呢：使用同步的机制对临界区进行保护

同步的两种方式：同步块和同步方法
对于同步来说都是使用synchronized方法
每一个对象都有一个监视器，或者叫做锁。

同步块实例：

package ticket; class Tickets { public static void main(String[] args)
{
sellTickets st = new sellTickets(); //四个线程同时卖这100张票，注意是同一个对象创建四个线程，他们共享同一个变量ticket new Thread(st).start(); new Thread(st).start(); new Thread(st).start(); new Thread(st).start();
}
} class sellTickets implements Runnable { int ticket = 100;
Object o = new Object();
@Override public void run() { while(true)
{ //每一个对象都有一个监视器，或者叫做锁。同步块示例 synchronized (o) { if(ticket > 0)
{ //存在的隐藏的问题当ticket=1，它的时间片到期了进入到if语句中，第二个线程进入到if语句然后时间片到期 try { //线程睡眠,该方法需要写异常 Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
} //第几个线程卖出了第多少张票 System.out.println(Thread.currentThread().getName() + “sell tickets” + ticket);
ticket–;
}
}
}
}
}

19.设m和n都是int类型,那么以下for循环语句的执行情况是( )
for (m = 0, n = -1; n = 0; m++, n++)
n++;

正确答案: D 你的答案: B (错误)
A.循环体一次也不执行 循环体执行一次 是无限循环 有限次循环 循环结束判断条件不合法 运行出错
B.循环体执行一次 是无限循环
C.有限次循环
D.循环结束判断条件不合法
解析:for 循环的结束判定条件 是 boolean型 n = 0 是 int 类型 会有编译异常 。

20.哪个类可用于处理 Unicode?
正确答案: A 你的答案: B (错误)
A.InputStreamReader
B.BufferedReader
C.Writer
D.PipedInputStream
解析：我在这里分别把四个选项的api贴过来，自己看看就知道了。

A、 InputStreanReader的构造函数：
InputStreamReader(InputStream in)
创建一个使用默认字符集的 InputStreamReader。
InputStreamReader(InputStream in, Charset cs)
创建使用给定字符集的 InputStreamReader。
InputStreamReader(InputStream in, CharsetDecoder dec)
创建使用给定字符集解码器的 InputStreamReader。
InputStreamReader(InputStream in, String charsetName)
创建使用指定字符集的 InputStreamReader。
B、BufferedReader的构造函数：
BufferedReader(Reader in)
创建一个使用默认大小输入缓冲区的缓冲字符输入流。
BufferedReader(Reader in, int sz)
创建一个使用指定大小输入缓冲区的缓冲字符输入流。
C、Writer的构造函数：
protected Writer()
创建一个新的字符流 writer，其关键部分将同步 writer 自身。
protected Writer(Object lock)
创建一个新的字符流 writer，其关键部分将同步给定的对象。

D、PipedInputStream的构造函数：
PipedInputStream()
创建尚未连接的PipedInputStream。
PipedInputStream(int pipeSize)
创建一个尚未连接的PipedInputStream，并对管道缓冲区使用指定的管道大小。
PipedInputStream(PipedOutputStream src)
创建PipedInputStream，使其连接到管道输出流src。
PipedInputStream(PipedOutputStream src, int pipeSize)
创建一个PipedInputStream，使其连接到管道输出流src，并对管道缓冲区使用指定的管道大小。

所以，答案是A了。（我参看的api的1.6版本的）

21.列哪一项不属于Swing的顶层容器？（）
正确答案: B 你的答案: D (错误)
A.JApplet
B.JTree
C.JDialog
D.JFrame
解析：顶层容器是指可以不能被其他容器包含 ，是容纳其他容器的容器组件，
顶层容器包含JApplet、JDialog、JFrame和JWindow及其子类.
JFrame中就可以放Jtree（树形组件）
所以B不是

22.下代码执行的结果是多少（）？

    public class Demo {
public static void main(String[] args) {
    Collection<?>[] collections = 

{new HashSet(), new ArrayList(), 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 你的答案: B (错误)
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

23.根（Stub）与以下哪种技术有关

正确答案: B 你的答案: D (错误)
A.交换
B.动态链接
C.动态加载
D.磁盘调度
解析：存根类是一个类，它实现了一个接口，它的作用是：如果一个接口有很多方法，如果要实现这个接口，就要实现所有的方法。但是一个类从业务来说，可能只需要其中一两个方法。如果直接去实现这个接口，除了实现所需的方法，还要实现其他所有的无关方法。而如果通过继承存根类就实现接口，就免去了这种麻烦。
RMI 采用stubs 和 skeletons 来进行远程对象(remote object)的通讯。stub 充当远程对象的客户端***，有着和远程对象相同的远程接口，远程对象的调用实际是通过调用该对象的客户端***对象stub来完成的。
每个远程对象都包含一个***对象stub，当运行在本地Java虚拟机上的程序调用运行在远程Java虚拟机上的对象方法时，它首先在本地创建该对象的***对象stub, 然后调用***对象上匹配的方法。每一个远程对象同时也包含一个skeleton对象，skeleton运行在远程对象所在的虚拟机上，接受来自stub对象的调用。这种方式符合等到程序要运行时将目标文件动态进行链接的思想。

24.单例模式中，两个基本要点是
正确答案: A D 你的答案: A B (错误)
A.构造函数私有
B.静态工厂方法
C.以上都不对
D.唯一实例
解析：设计模式-单例模式
知识点
什么是单例模式？
单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

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

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

特点：

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

1、一个班级只有一个班主任。
2、Windows 是多进程多线程的，在操作一个文件的时候，就不可避免地出现多个进程或线程同时操作一个文件的现象，所以所有文件的处理必须通过唯一的实例来进行。
3、一些设备管理器常常设计为单例模式，比如一个电脑有两台打印机，在输出的时候就要处理不能两台打印机打印同一个文件。
优点：

1、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例）。
2、避免对资源的多重占用（比如写文件操作）。
缺点：没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。

使用场景：

1、要求生产唯一序列号。
2、WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来。
3、创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等。
注意事项：getInstance() 方法中需要使用同步锁 synchronized (Singleton.class) 防止多线程同时进入造成 instance 被多次实例化。

实例
单例模式-饿汉式
代码

//单例模式-饿汉式
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! ——单例模式-饿汉式");
}

}
结果

1
Hello World! ——单例模式-饿汉式
单例模式-懒汉式（线程不安全版）
这种方式是最基本的实现方式，这种实现最大的问题就是不支持多线程。因为没有加锁 synchronized，所以严格意义上它并不算单例模式。
这种方式 lazy loading 很明显，不要求线程安全，在多线程不能正常工作。

代码

//单例模式-懒汉式
public class SingletonDemo2 {
public static void main(String[] args) {
Singleton2 singleton = Singleton2.getInstance();
singleton.hello();

}

}

class Singleton2{
private static Singleton2 instance;
private Singleton2(){}

public static Singleton2 getInstance() {
    if (instance == null){
        instance = new Singleton2();
    }
    return instance;
}

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

}
结果

1
Hello World! ——单例模式-懒汉式
单例模式-懒汉式（线程安全版）
描述：这种方式具备很好的 lazy loading，能够在多线程中很好的工作，但是，效率很低，99% 情况下不需要同步。
优点：第一次调用才初始化，避免内存浪费。
缺点：必须加锁 synchronized 才能保证单例，但加锁会影响效率。
getInstance() 的性能对应用程序不是很关键（该方法使用不太频繁）。

代码

//单例模式-懒汉式
public class SingletonDemo3 {
public static void main(String[] args) {
Singleton3 singleton = Singleton3.getInstance();
singleton.hello();

}

}

class Singleton3{
private static Singleton3 instance;
private Singleton3(){}

public synchronized static Singleton3 getInstance() {
    if (instance == null){
        instance = new Singleton3();
    }
    return instance;
}

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

}
结果

1
Hello World! ——单例模式-懒汉式

25.下面哪些接口直接继承自Collection接口（）
正确答案: A C 你的答案: A B C D (错误)
A.List
B.Map
C.Set
D.Iterator
解析：
26.有以下程序段， 则下面正确的选项是（）

public class MyThead extends Thread{
public static void main(String[] args) {
MyThead t=new MyThead();
MyThead s=new MyThead();
t.start();
System.out.println(“one.”);
s.start();
System.out.println(“two.”);
}
public void run() {
System.out.println(“Thread”);
}
}

正确答案: B C D 你的答案: B C (错误)
A.编译失败
B.程序运行可能结果为：
one.
Thread
two.
Thread
C.程序运行可能结果是：
one.
two.
Thread
Thread
D.程序运行结果不稳定
解析：start()是开启线程，等待获得时间片，一到获得时间片就执行。所以可能一开启就获得了时间片执行，也有可能等到two输出后才获得了时间片。所以BC都可能，所以D也正确。

27.下列那些方法是线程安全的(所调用的方法都存在)
正确答案: A 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;
}
}
D.public class Factorizer implements Servlet {
private volatile MyCache cache = new MyCache(null,null);

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修饰的变量只有赋值，线程安全； 欢迎指正。

28.下面关于面向对象的一些理解哪些是错误的( )
正确答案: C 你的答案: B C (错误)
A.面向对象的最重要的特性是支持继承、封装和多态
B.系统设计应该遵循开闭原则，系统应该稳定不不可修改，但应支持通过继承、组合等方式进行扩展
C.函数式的语言必然是面向对象的语言
D.面向对象设计时，每个类的职责应该单一，不要再一个类中引入过多的接口
E.过程式语言和面向对象的语言各有其优势，过程式语言更加灵活，面向对象语言更加强调抽象和封装
F.Java和C++都是静态类型的面向对象编程语言
解析：动态类型语言是指在运行期间才去做数据类型检查的语言，也就是说，在用动态类型的语言编程时，永远也不用给任何变量指定数据类型，该语言会在你第一次赋值给变量时，在内部将数据类型记录下来。静态类型语言与动态类型语言刚好相反，它的数据类型是在编译其间检查的，也就是说在写程序时要声明所有变量的数据类型，C/C++是静态类型语言的典型代表，其他的静态类型语言还有C#、JAVA等。

29.下列哪些操作会使线程释放锁资源？
正确答案: B C 你的答案: A D (错误)
A.sleep()
B.wait()
C.join()
D.yield()
解析：1.sleep()方法

在指定时间内让当前正在执行的线程暂停执行，但不会释放“锁标志”。不推荐使用。

sleep()使当前线程进入阻塞状态，在指定时间内不会执行。

2.wait()方法

在其他线程调用对象的notify或notifyAll方法前，导致当前线程等待。线程会释放掉它所占有的“锁标志”，从而使别的线程有机会抢占该锁。

当前线程必须拥有当前对象锁。如果当前线程不是此锁的拥有者，会抛出IllegalMonitorStateException异常。

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

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

3.yield方法

暂停当前正在执行的线程对象。

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

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

    4.join方法

join()等待该线程终止。
等待调用join方法的线程结束，再继续执行。如：t.join();//主要用于等待t线程运行结束，若无此句，main则会执行完毕，导致结果不可预测

30.下列哪些方法是针对循环优化进行的
正确答案: A B D 你的答案: A C D (错误)
强度削弱
删除归纳变量
删除多余运算
代码外提
解析：代码优化也可分为局部优化、 循环优化和全局优化：
局部优化指的是在只有一个入口、 一个出口的基本程序块上进行的优化。
循环优化是对循环中的代码进行的优化，在一个程序运行时，相当多的一部分时间会花在循环上，因此，基于循环的优化非常重要。
全局优化是在整个程序范围内进行的优化。

删除多余运算
使生成的目标代码减少而执行速度较快
也叫删除公共子表达式

循环优化：对循环中的代码段，可以进行代码外提、强度削弱和删除归纳变量等优化。
删除多余运算应该不是专门针对循环优化的。