1.Java特性
1.1 Java 8新特性
1）Lambda表达式 - 允许把函数作为另一个函数的参数；
优缺点：
I.优点，代表了未来编程的趋势
①简洁；
②非常容易并行计算；
II.缺点
①没学过的看不懂，不易调试；
②不使用并行计算的情况下，一般没有传统的for循环速度快；
2）方法引用——直接引用java已有类或对象的方法或构造器，配合Lambda使用；
3）默认方法——接口里多一个默认的实现方法；
4）新工具——编译器：Nashorn引擎-JJS用于运行JS程序，也可以在Java程序中嵌入Nashorn引擎，运行特定的JS应用；类依赖解析器-JDEPS；
5）Stream API——java.util.stream 把真正的函数式编程风格引入java；
6）Date Time API——加强对日期、时间的处理
7）Optional——成为java8类库的一部分，解决空指针异常；
1.2 Java 语言特性
1）封装、继承、多态。
2）什么是多态？举个例子。
在面向对象语言中，接口的多种不同的实现方式即为多态。
简单的说：允许将子类类型的指针赋值给父类类型的指针。
多态允许不同类的对象对同一消息作出不同的响应。如方法的重载，根据参数的不同执行不同的行为。
2.Java支持的基本数据类型+自动拆装箱（Java5引入）
1）八种基本数据类型（原始类型、内置类型）：
byte、short、int、long、float、double、boolean、char
| 数据类型 | 大小 | 表示范围 | 默认值 |
|---|---|---|---|
| byte | 1个字节(8位) | -128（-27）~127（27-1） | 0 |
| short | 2个字节(16位) | -32768（-215）~32767（215-1） | 0 |
| int | 4个字节(32位) | -2,147,483,648（-231）~2,147,483,647（231-1） | 0 |
| long | 8个字节(64位) | -9,223,372,036,854,775,808（-263）~9,223,372,036,854,775,807（263-1） | 0L |
| float | 4个字节(32位) | -3.4028235E38 ~ +3.4028235E38 【1.4E-45】 | 0.0f |
| double | 8个字节(64位) | -1.7976931348623157E308~1.7976931348623157E308【4.9E-324】 | 0.0d |
| boolean | 1位 | 0-1 | false |
| char | 2个字节(16位) | \u0000(0)~\uffff(65535) | 空格(\u0000) |
2）对应的对象包装类（引用类型）：
Byte、Short、Integer、Long、Float、Double、Boolean、Character
3）自动拆装箱：
自动装箱就是Java编译器自动把基本数据类型转化成对应的对象包装类；
自动拆箱就是Java编译器自动把对象包装类转化成对应的基本数据类型。
4）基本数据类型是原始数据类型，对象包装类是java为其提供的封装。它们行为不同、语义不同、特征和用法不同:
①基本类型不能为null，而包装类型可以；
②基本类型不能用于泛型，而包装类型可以；
③基本类型的默认值与类型有关，包装类型默认值为null；
④基本类型更加高效；
5）int类型和Integer类型的区别：
答：
①int是基本数据类型，存储的是数值；Integer是引用类型，是一个对象，存储的是引用对象的地址。
②Integer需要存储对象的元数据，占用内存更大；
③如果new生成两个Integer对象，则它们==返回false，其内存地址不同；
④一个new生成，一个非new生成（直接赋值常数）。
Integer a = new Integer(5) 和 Integer b = 5;
前者指向堆中新建的对象，后者指向常量池中的对象，两者在内存中的地址不同；
⑤两个都是非new生成，当值[-128, 127]时相等（-128 到 127 之间的数会从 IntegerCache 中取，常量池），否则不相等；
⑥Integer变量和int变量只要值相等，它们就相等（自动拆箱）；
3.类的变量和方法存储位置
栈内存中存放局部变量（基本数据类型和对象引用)
堆内存用于存放对象（实体）
1）静态变量和方法：方法区；
2）实例变量：作为对象的一部分，和对象一起放在堆中；
3）局部变量（临时变量）：栈，栈随线程的创建而被分配给线程；
4）对于字符串而言，如果是编译期已经创建好(直接用双引号定义的)的就存储在常量池中；如果是运行期（通过构造方法或成员方法new出来的）才能确定的就存储在堆中；对于equals相等的字符串，在常量池中永远只有一份，在堆中可以有多份。
4.String是基本的数据类型吗
1）基本数据类型只有如2所述八大，String不是基本类型；
2）对于八大基本数据类型和String，它们是作为常量在方法区中的常量池里面以HashSet策略存储起来的。
在常量池中，同一个常量只会对应一个地址，所有值等于它的变量都是它的引用，指向同一块地址。
这也是为什么基本数据类型和String可以直接通过==来比较。
3）java.lang.String是final类型的，不能被继承、修改。
如下所示的方式都不是修改，而是创建了一个新的String;
String str = "hello";
System.out.println(str.hashCode()); // 99162322
str = str.replace("h","a");
System.out.println(str.hashCode()); // 92697675
System.out.println(str); // aello
4）String为啥不可变？
答：
①什么叫做不可变：不可变对象指的是一个对象在被创建之后其状态就不在变化。包括不改变对象内的成员变量（基本数据类型的值不能变，引用类型变量不能再指向其他对象，引用类型指向对象的状态也不能改变）
②String不可变的原因：
a.String在JDK中被声明为一个final类，其内部的value字节数组也是final的。
b.只有当字符串不可变时才能实现字符串池，从而在运行时节省很多heap空间（因为不能的字符串变量只要值相同，它们就指向池中同一个字符串）
c.字符串可变会引起很多安全问题，如：数据库的用户名和密码都是以字符串的形式传入以获得数据库的连接；或者soket编程中主机名和端口号都是以字符串的形式传入。这样黑客们改变字符串指向对象的值就能造成安全漏洞。
d.字符串不可变，所以是多线程安全的，同一个字符串可以被多个线程共享，因为字符串是不可变的，所以不用因为线程安全问题而使用同步。
e.字符串是不可变的，因此字符串在创建的时候，其hashcode就被缓存了，字符串的不变性也保证其hashcode唯一性不变性，无需重新计算，因此String适合作为Map的键，String的处理速度要快过其他类型的键对象，因此HashMap中往往都是用String作为键。
5）String能被继承吗？
如上所述，String在JDK中被声明为一个final类，其内部的char vallue字节数组也是final的，因此不能被继承；
6）为了提高效率，节省空间，应该使用StringBuffer类，区别：
两者都可以存储和操作字符串，而String提供了数值不可改变的字符串；
StringBuffer提供对字符串进行修改，当字符数据需要改变，如动态构造字符数据时可以使用StringBuffer。
StringBuffer str = new StringBuffer("hello");
System.out.println(str.hashCode()); // 764977973
str = str.replace(0,1, "a"); // 从0开始替换1个字符
System.out.println(str.hashCode()); // 764977973
System.out.println(str); // aello
7）StringBuffer和StringBuilder有什么区别，底层实现上呢？
答：在底层实现上，StringBuffer比StringBuilder多了一个Synchronized修饰符，因此，StringBuffer是线程安全的，而StringBuilder不是。
8）将某种编码格式的字符串以另一种编码格式输出
public String convert(String str){
String tempStr="";
try{
// 1.首先通过getBytes将原字符串解析成字节流
// 2.在通过new String(字节流, 编码格式)的方法构造新的对应编码的字符串
tempStr = new String(str.getBytes("原编码格式"), "目标编码格式");
tempStr = tempStr.trim();
}catch(Exception e){
System.err.println(e.getMessage());
}
return tempStr;
}
5.泛型
5.1 泛型的概念
1）泛型又称为“参数化类型”，将“类型”由【原来的具体类型】参数化，将类型定义成参数形式（可称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）
2）如ArrayList<>，尖括号中存放类型形参，可以传入类型实参，如ArrayList<String>限定了list集合中只能存放String类型的元素；在取出元素时也不需要进行强制类型转换。
5.2 extends和super泛型限定符
“上界不存，下界不取”
1）定义
上界：<? extends Fruit>表示任何继承Fruit的子类；
下界：<? super Apple>表示所有Apple的父类，包括Object类；
2）上下界的特点
前提：往数据结构中存东西的时候，存进去的元素的类型辈分一定要小于等于数据结构定义时存储的类型，比如ArrayList<Fruit>只能存储Fruit的子类；从数据结构中取出的东西只能赋值给辈分大于等于它的变量比如Fruit f = new ArrayList<Apple>().get(0)
①存储上界的数据结构（如list ArrayList）只能get不能add：上界表示所有继承Fruit的子类，但是不知道具体是哪个子类。假设存放的是子类A，如果要add的元素的辈分大于A就无法放入，因此不能add；但是get的时候，可以使用Fruit类型（最上层的父类-除Object外）接收（就是把所有子类向上转型成Fruit）；
上界可以都是用Fruit类型变量取东西，绝对不会失败；但是存东西是有可能失败的；
②存储上界的数据结构（如list ArrayList）只能get不能add：下界存储Apple所有的父类，但是不知道具体是哪个父类，只能addApple及其子类；
假设用于存储从ArrayList中取出的元素的变量为 A temp，若A的辈分小于ArrayList中存储元素的辈分，就会报错，只能当A为Object类的时候可以取出。
下界可以都是存Apple以及它的子类，绝对不会失败；但是取东西是有可能失败的；
总结：编译器支持向上转型，不支持向下转型；Apple可以赋值给Fruit的引用，但把Fruit对象赋值给Apple的引用就必须用cast；
6.关键字
6.1 static关键字
1）static关键字是什么意思？
答：static关键字表名被修饰的成员变量或成员方法可以直接使用类进行访问，可以在没有【所属类的实例对象】的情况下被访问。
2）Java中是否可以覆盖（Override）一个private或者static修饰的方法？
Java中的static方法是编译时静态绑定的，跟任何对象实例都不相关，而方法重写（覆盖/Override）是基于运行时动态绑定的，因此不能被Override；
编译时静态绑定意思就是这个被static修饰的方法，即使不被调用，就在编译时被静态绑定了；而运行时动态绑定是要在程序运行之后，方法被调用才能够绑定。
3）是否可以在static环境中访问非static变量？
答：static变量是属于类的，在类的所有实例中的值都是一样的；当类被JVM载入的时候，static变量在编译时静态初始化；若不用类的实例访问非static的变量，编译器会报错，因为非static变量只存在于类的实例中，在static环境中，还没有任何一个【类的实例】被创建出来，也就没有非static的变量被创建出来，因此根本不存在非static变量可供访问。
6.2 Synchronized锁（保证了原子性）
1）synchronized修饰静态方法
答：synchronized修饰静态方法以及同步代码块锁住的是类，线程想要执行对应同步代码需要获得类锁；
2）synchronized修饰成员方法
答：线程获取的是当前调用该方法的对象实例的对象锁。
3）与lock的异同
synchronized是java的关键字，是内置的语言实现，保证被修饰的方法或者代码块在同一时刻内最多只被一个线程执行，JDK1.5后加入了自旋锁、锁粗化、轻量级锁，偏向锁来优化关键字的性能；
①lock是一个接口，synchronized是java的关键字，是内置的语言实现。
②synchronized在发生异常时自动释放线程占有的所有所，不会造成死锁现象；但等待锁的线程会一直等待下去，无法响应中断；且无法知道是否成功获取了锁；
③lock在发生异常时，如果没有主动通过unlock()释放锁，可能造成死锁，因此使用lock需要在finally中释放锁；可以让等待锁的线程响应中断，不再等待；可通过lock知道是否成功获取了锁；
6.3 volatile
1）问题引入——数据一致性问题
Java内存模型分为：主内存、工作内存。
如线程A将主内存中的变量i读到了自己的工作内存，执行加1操作后，并没有刷新值到主内存中。
此时线程B也从主内存中读变量i，读到的还是旧值，执行加1。
因此两个线程2次+1操作实际上只对i加了1。
2）两种解决上问题的方法
①在总线加LOCK#锁的方式（针对Intel平台的CPU）—效率低下，代价太大
在早期的CPU当中，通过在总线上加LOCK#锁的形式来解决缓存不一致的问题。因为CPU和其他部件进行通信都是通过总线来进行的，如果对总线加LOCK#锁的话，就阻塞了其他CPU对其他部件访问（如内存），使得只能有一个CPU能使用这个变量的内存。只有等待这段代码完全执行完毕之后，其他CPU才能从变量i所在的内存读取变量，然后进行相应的操作。
②如Intel-MESI协议之类的缓存一致性协议
CPU1 读数 Exclusive 独享
CPU2 读数 Share 共享
CPU1 修改 Exclusive 独享 -> Share 共享
CPU1 修改数值 Share 共享 -> Modified修改 发出通知给Share的线程CPU2
CPU2 Share 共享 -> Invalid销毁，需要重新从内存中读取，然后给CPU1响应，让CPU1先把数据写回主存。
CPU1 等待CPU2响应，进入阻塞状态，收到响应写回主存。
改进：结果先存在一个storebuff里，CPU1继续运行接下来的程序，收到响应后，storebuff写回主存。
3）并发相关三个概念——原子性、可见性、有序性
①原子性：一组操作，要么全部执行，要么全都不执行。
②可见性：当多线程访问同一变量时，一个线程修改该变量的值，其他线程能够立即读取到到修改后的值。
③有序性：执行的顺序按照代码的先后顺序执行。
程序不一定按照代码的书写顺序执行，编译器、CPU都会对代码进行重排序，以减少如【数据相关性】等引起的流水线阻塞，提高执行效率。
4）volatile作用：
// stop没有被volatile修饰，线程2对stop做的改动不会影响线程1的执行，线程1陷入死循环
//线程1
boolean stop = false;
while(!stop){
doSomething();
}
//线程2
stop = true;
①保证数据的可见性：当一个共享变量被volatile修饰时，修改的值会立即被更新到主存，共享该变量的其他线程需要读取时，它会去内存中读取新值。
②保证指令的有序性：禁止进行默认的指令重排序。内存屏障
a.程序执行到volatile变量的读操作或者写操作时，书写在其前面的操作、更改肯定全部已经进行，且结果已经对后面的操作可见；书写在其后面的操作肯定还没有进行；
b.在进行指令优化时，不能改变书写上【对volatile变量进行访问的代码片段 】与【其前后代码】的相对位置。
5）保证有序性的八大happen-before规则
①程序次序规则：一个线程内，按照代码顺序，书写在前面的操作先行发生于书写在后面的操作；
用来保证程序在【单线程】中执行结果的正确性；
程序会进行重排序，但最终执行的结果是与程序顺序执行的结果一致的，只会对不存在数据依赖性的指令进行重排序；
②锁定规则：一个unLock操作先行发生于后面对同一个锁额lock操作；
无论在单线程中还是多线程中，同一个锁如果处于被锁定的状态，那么必须先释放锁，才能继续lock锁；
③volatile变量规则：对一个变量的写操作先行发生于后面对这个变量的读操作；
④传递规则：如果操作A先行发生于操作B，而操作B又先行发生于操作C，则可以得出操作A先行发生于操作C；
⑤线程启动规则：Thread对象的start()方法先行发生于此线程的每个一个动作；
⑥线程中断规则：对线程interrupt()方法的调用先行发生于被中断线程的代码检测到中断事件的发生；
⑦线程终结规则：线程中所有的操作都先行发生于线程的终止检测，我们可以通过Thread.join()方法结束、Thread.isAlive()的返回值手段检测到线程已经终止执行；
⑧对象终结规则：一个对象的初始化完成先行发生于他的finalize()方法的开始；
6.4 final关键字
1）final修饰的类不能被继承，其成员变量可根据需要设置为final，但其成员方法会被默认隐式指定为final方法；
final修饰的【基本数据类型变量】在初始化之后就不能修改值；
final修饰的【引用类型的变量】在初始化之后就不能再指向另一个对象；
2）final类的作用
①锁定成员方法，防止任何继承类修改它的含义；
②效率：早期java将final方法转为内嵌调用；
3）final、finally和finalize的区别
①final用于在声明中修饰属性、方法和类，分别表示属性的不可变、方法的不可覆盖、类的不可继承。
②finally是异常处理语句的一部分，表示不论异常情况如何，都会运行的操作
③finalize是Object类的一个方法，垃圾收集器执行的时候会调用被回收对象的finalize方法。可以重写该方法，以进行垃圾收集时其他资源的回收，如关闭文件等。
7.&和&&的区别
1）&用于：按位与和逻辑与；
2）&&用于：短路与
联系与区别：
联系：二者都需要符号两端表达式都为true才返回true；
区别：短路与在符号左边表达式为false的情况下不进行右边表达式的运算；
8.如何跳出当前的多层嵌套循环
// 带标签的for循环
for_label_name:
for( int i = 0 ; i<3 ;i++ ){
System.out.println("i="+i);
for( int j =0 ; j<5; j++ ){
if( j == 3 )
// continue for_label_name;
break for_label_name;
System.out.println("j="+j);
}
}
java支持带标签的for循环体，通过“continue for_label_name;”的形式可以继续for_label_name指定的for循环层，通过“break for_label_name;”的形式可以跳出for_label_name指定的for循环层。
9.值传递和引用传递
值传递：是对基本型变量而言的，传递的是该变量的一个副本，改变副本不会影响原变量；
引用传递：是对对象型变量而言的，传递的是原对象地址的副本，因此，对引用对象进行操作会影响原对象；
java内的传递都是值传递：对于上述引用传递是将原对象地址的副本作为值进行传递。
9.1 一个对象作为参数被传递
10.关于对象的hashCode()和equals()方法
10.1 Object 类的hashCode()方法
所有对象默认继承Object类，因此下述Object等同于“对象”；
1）Object 的 hashcode() 方法本地方法（C/C++），返回【创建对象时】，JVM虚拟机根据某种策略生成的分配给Object对象的一个int类型的数值，不重写hashCode()的情况下默认是和对象内存地址相关的一个整数，因此，任何不同对象的hashCode()返回值都不相等；
当需要访问对象的时候，JVM根据对象的hashCode从哈希表中取对象，提高效率；
2）当不同的对象根据策略产生了相同的hash值（产生冲突），那么就在这hash值的地方使用链表存储全部产生同样hashcode的对象，jdk1.8上升为使用红黑树存储；
10.2 Object 类的equals()方法
1）Object中的equals方法实际上是对对象的地址进行比较判断，判断两个对象是否是同一个地址：
DemoTest d1 = new DemoTest(); // d1的hashcode：381259350
DemoTest d2 = new DemoTest(); // d2的hashcode：664223387
DemoTest d3 = d1; // d3的hashcode：381259350
DemoTest d4 = new DemoTest(11);// d4的hashcode：824909230
DemoTest d5 = new DemoTest(11);// d5的hashcode：122883338
DemoTest d6 = d4; // d6的hashcode：824909230
System.out.println("d1和d2相等吗："+d1.equals(d2)); // false
System.out.println("d1和d3相等吗："+d1.equals(d3)); // true
System.out.println("d4和d5相等吗："+d4.equals(d5)); // false
System.out.println("d4和d6相等吗："+d4.equals(d6)); // true
2）与“==”符号的区别
“==”对比两个对象基于内存引用，若两个对象的引用完全相同（指向同一个对象）则返回true；如果两边是基本数据类型，则比较值是否相等；
Object类中定义的equals()方法如下所示：
10.3 重写hashCode()方法和equals()方法
1）问题的产生
当往HashMap中存入新的键值对，需要查找HashMap是否已经存在该“键”，如果存在该“键”，则要覆盖原来的值；
诸如此类的情况就需要“判断key是否相等”
“为什么重写hashCode()还要重写equals()
或者
为什么重写equals()还要重写hashCode()”
2） HashMap中的比较key的过程：
①先求出key的hashcode()，比较其值是否相等，不相等则不等；
②若相等再比较equals()，若相等则认为他们是相等的，若equals()不相等则认为他们不相等。
因此：
假设key1和key2在hashCode()和equals()重写之前，两个方法均不相等。
①如果只重写equals()，不重写hashCode()：
key1和key2在重写后的equals()返回虽然是相等的，但是因为没有重写hashCode()，它们hashCode()不相等（因为没有重写hashCode()，则任何对象的hashCode()值都不相等），在这一步已经得出它们不相等，就轮不到equals()方法继续判断。
②如果不重写equals()，只重写hashCode()：
hashCode()重写后，它们能够进入equals()的判断，但因为没有重写equals()，因此，它们最后还是不相等。
11.正则表达式及其用途
1）正则表达式是一种记录文本规则的代码。
2）在编写程序处理字符串时，经常会有【查找符合某些复杂规则的字符串】的需求，正则表达式就是用于描述这些规则。
3）计算机处理的信息更多的时候不是数值，而是字符串。正则表达式是进行字符串匹配和处理最强大的工具，绝大多数语言都提供了对正则表达式的支持；
4）Java是如何支持正则表达式的？
答：
①Java提供了丰富的API进行各种正则表达式操作，可以用Pattern类表示正则表达式对象，可以使用Matcher对象进行正则表达式对象和字符串的匹配。
②String类提供了支持正则表达式的方法，包括：matches()、replaceAll()、replaceFirst()、split()等方法；
③例子：
// 正则表达式
String str = "成都市(成华区)(武侯区)(高新区)";
Pattern p = Pattern.compile(".*?(?=\\()");
Matcher m = p.matcher(str);
if(m.find()){
System.out.println(m.group());
}
12.大O(·)符号，给出不同数据结构的例子
1）O(·)表示一个程序运行所需的渐进时间复杂度上界。
函数表示为：
对函数f(n)和g(n)，若存在常数c使得f(n)<=c*g(n)，则f(n) = O(g(n))
2）当数据结构里的元素增加的时候，O(·)衡量算法在最坏的情况下的规模（时间和空间-内存消耗）或性能；一般使用O(·)基于时间、内存、性能来选择最好的算法；其对算法在大规模数据下的性能能给出很好的说明。
13. 细碎问题
1）十进制数在内存里是怎么存的？
答：补码的形式。
2）为何会出现4.0-3.6 = 0.40000001的现象
答：二进制的小数无法精确的表达十进制的小数，计算需要把十进制的小数转化成二进制的小数，过程中出现了误差。
0.Java vs JS&PHP
0.1 Java vs JS
| Java | JS | |
|---|---|---|
| 背景 | 原SunMicrosystems公司推出的面向对象的程序设计语言，特适合互联网应用程序的开发 | Netscape公司的产品，是为了扩展Netscape浏览器的功能而开发的一种可以嵌入Web页面中运行的基于对象和事件驱动的解释性语言 |
| 前身 | Oak语言 | LiveScript |
| 对象 | Java是一种真正的面向对象的语言，即使开发简单的程序，也必须设计对象 | JS是脚本语言，是基于对象和事件驱动的编程语言，提供了丰富的内部对象供设计人员使用 |
| 编译和解释 | Java源代码在执行前必须经过编译 | JS是解释性编程语言，不需要经过编译，由浏览器解释执行（目前浏览器几乎都是用了JIT即使编译技术来提升JS的运行效率） |
| 变量 | Java采用强类型变量检查，所有变量在编译、使用前都必须做声明，声明变量的类型 | JS采用弱类型变量，变量在使用前可以不作声明，JS解释器在运行时检查推断其数据类型 |
| 代码格式 | 不一样 | 不一样 |
0.2 Java vs PHP
1）PHP暂时不像Java支持JIT运行时编译热点代码；但PHP有opcache机制能够把脚本对应的opcode缓存在内存，php7中还支持配置opcache.file_cache导出opcode到文件；第三方的Facebook HHVM也支持JIT，另外PHP官方基于LLVM围绕opcache机制构建的Zend JIT分支正在开发测试中，数据显示PHP JIT分支速度是PHP5.4的10倍；
2）PHP的库函数用C实现，而Java核心运行时类库（jdk/jre/lib/rt.jar）用Java编写，所以Java应用运行的时候，用户编写的代码以及引用的类库和框架都要在JVM上解释执行。Java的HotSpot机制，知道有方法被执行10000次才会触发JIT编译，再次之前运行在解释模式下，以避免出现JIT编译花费的时间比方法解释执行消耗的时间还要多的情况；
3）PHP内置模板引擎，其本身就是模板语言；而JavaWeb需要使用JSP容器如Tomcat或第三方模板引擎；
4）PHP也可以运行在多线程模式下，比如Apache的event MPM和Facebook的HHVM都是多线程架构。不管是多进程还是多线程的PHP Web运行模式，都不需要PHP开发者关心和控制，即PHP开发者不需要写代码参与进程和线程的管理，都由PHP-FPM/HHVM/Apache实现进程管理和并发，当一个worker进程崩溃，master进程会自动新建一个新的worker进程，不会导致PHP服务崩溃；对于PHP-FPM和Apache MOD_PHP来说，服务进程常驻内存，但一次请求释放一次资源，这种内存释放非常彻底，PHP基于引用计数的GC甚至都还没发挥作用程序就已经结束了。
而Java多线程编程需要开发者参与，而且多线程编程稍有不慎（比如没有捕获异常）就会导致JVM崩溃退出。
207
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
