Java开发校招面试考点汇总第三篇：java SE（三）/锁、JDK、反射、JVM、GC、IO和NIO、AIO

97、● 请你简述一下synchronized与java.util.concurrent.locks.Lock的相同之处和不同之处？
98.产生死锁的四个条件
99、● JAVA中如何确保N个线程可以访问N个资源，但同时又不导致死锁？
100、● 请问什么是死锁(deadlock)?
101、● 请说明一下锁和同步的区别。（即synchronized和Lock的区别）
102、可重复锁
103、请说明一下synchronized的可重入怎么实现。
104、● 请讲一下非公平锁和公平锁在reetrantlock里的实现过程是怎样的。
105、● 请问JDK和JRE的区别是什么？
106、● Java中的LongAdder和AtomicLong有什么区别？
107、CAS机制
108、● 请说明一下JAVA中反射的实现过程和作用分别是什么？
109、● 请简单描述一下JVM加载class文件的原理是什么?
110、● 什么是Java虚拟机？为什么Java被称作是“平台无关的编程语言”？
111、JVM内存结构
112、java的内存模型
113、垃圾回收的对象
114、● 请列举一下，在JAVA虚拟机中，哪些对象可作为ROOT对象？
115、● GC中如何判断对象是否需要被回收？
116、● 请说明一下eden区和survial区的含义以及工作原理？
117、垃圾收集算法
118、内存分配与回收策略
119、Minor GC和Full GC的区别
120、● 请简单描述一下类的加载过程（未完）
121、类加载器
122、双亲委派模型
123、垃圾收集器
124、● 请简单描述一下垃圾回收器的基本原理是什么？并且有什么办法可以主动通知虚拟机进行垃圾回收呢？
125、● 请问，在java中会存在内存泄漏吗？请简单描述一下。
126、● 什么原因会导致minor gc运行频繁？同样的，什么原因又会导致minor gc运行很慢？请简要说明一下
127、● 请问运行时异常与受检异常有什么区别？
128、● 请问什么是java序列化？以及如何实现java序列化？
129、● 请问java中有几种类型的流？JDK为每种类型的流提供了一些抽象类以供继承，请说出他们分别是哪些类？
130、● 请问你平时最常见到的runtime exception是什么？
131、● 请问error和exception有什么区别?
132、BIO/NIO/AIO

97、● 请你简述一下synchronized与java.util.concurrent.locks.Lock的相同之处和不同之处？
Lock能完成synchronized所实现的所有功能，都可以实现多线程的同步。
区别：
1、Lock有比synchronized更精确的线程语义和更好的性能。
2、synchronized会自动释放锁，而Lock一定要求程序员手工释放，并且必须在finally从句中释放。

98.产生死锁的四个条件
1、互斥条件：资源是独占的且排他使用，进程互斥使用资源，即任意时刻一个资源只能给一个进程使用，其他进程若申请一个资源，而该资源被另一进程占有时，则申请者等待直到资源被占有者释放。
2、不可剥夺条件：进程所获得的资源在未使用完毕之前，不被其他进程强行剥夺，而只能由获得该资源的进程资源释放。
3、请求和保持条件：进程每次申请它所需要的一部分资源，在申请新的资源的同时，继续占用已分配到的资源。
4、循环等待条件：存在一个进程链，使得每个进程都占有下一个进程所需的至少一种资源。

99、● JAVA中如何确保N个线程可以访问N个资源，但同时又不导致死锁？
使用多线程的时候，一种非常简单的避免死锁的方式就是：指定获取锁的顺序，并强制线程按照指定的顺序获取锁。因此，如果所有的线程都是以同样的顺序加锁和释放锁，就不会出现死锁了。

预防死锁，预先破坏产生死锁的四个条件。互斥不可能破坏，所以有如下三种方法：

1.破坏请求和保持条件，进程必须等所有要请求的资源都空闲时才能申请资源。

2.破坏不可抢占条件，这种方法代价大，实现复杂。

3.破坏循坏等待条件，对各进程请求资源的顺序做一个规定，避免相互等待。这种方法对资源的利用率比前两种都高，但是前期要为设备指定序号，新设备加入会有一个问题，其次对用户编程也有限制。

100、● 请问什么是死锁(deadlock)?
两个线程或两个以上线程都在等待对方执行完毕才能继续往下执行的时候就发生了死锁。结果就是这些线程都陷入了无限的等待中。

101、● 请说明一下锁和同步的区别。（即synchronized和Lock的区别）
以前的问题中有回答。

102、可重复锁
https://www.cnblogs.com/incognitor/p/9894604.html
若一个程序或子程序可以“在任意时刻被中断然后操作系统调度执行另外一段代码，这段代码又调用了该子程序不会出错”，则称其为可重入（reentrant或re-entrant）的。即当该子程序正在运行时，执行线程可以再次进入并执行它，仍然获得符合设计时预期的结果。与多线程并发执行的线程安全不同，可重入强调对单个线程执行时重新进入同一个子程序仍然是安全的。

通俗来说：当线程请求一个由其它线程持有的对象锁时，该线程会阻塞，而当线程请求由自己持有的对象锁时，如果该锁是重入锁，请求就会成功，否则阻塞。

可重入锁的实现原理
重入锁实现可重入性原理或机制是：每一个锁关联一个线程持有者和计数器，当计数器为 0 时表示该锁没有被任何线程持有，那么任何线程都可能获得该锁而调用相应的方法；当某一线程请求成功后，JVM会记下锁的持有线程，并且将计数器置为 1；此时其它线程请求该锁，则必须等待；而该持有锁的线程如果再次请求这个锁，就可以再次拿到这个锁，同时计数器会递增；当线程退出同步代码块时，计数器会递减，如果计数器为 0，则释放该锁。

103、请说明一下synchronized的可重入怎么实现。
synchronized是可重入锁。
每个锁关联一个线程持有者和一个计数器。当计数器为0时表示该锁没有被任何线程持有，那么任何线程都都可能获得该锁而调用相应方法。当一个线程请求成功后，JVM会记下持有锁的线程，并将计数器计为1。此时其他线程请求该锁，则必须等待。而该持有锁的线程如果再次请求这个锁，就可以再次拿到这个锁，同时计数器会递增。当线程退出一个synchronized方法/块时，计数器会递减，如果计数器为0则释放该锁。

104、● 请讲一下非公平锁和公平锁在reetrantlock里的实现过程是怎样的。
公平锁：线程获取锁的顺序是按照线程加锁的顺序来分配的，即先来先得的FIFO先进先出顺序

非公平锁：一种获取锁的抢占机制，是随机获取锁的（谁抢到就是谁的），和公平锁的区别就是先来的不一定先得到锁，导致某些线程可能一直拿不到锁，所以是不公平的

105、● 请问JDK和JRE的区别是什么？
Java运行时环境(JRE)是将要执行Java程序的Java虚拟机。它同时也包含了执行applet需要的浏览器插件。Java开发工具包(JDK)是完整的Java软件开发包，包含了JRE，编译器和其他的工具(比如：JavaDoc，Java调试器)，可以让开发者开发、编译、执行Java应用程序。

106、● Java中的LongAdder和AtomicLong有什么区别？
AtomicLong是作用是对长整形进行原子操作，显而易见，在java1.8中新加入了一个新的原子类LongAdder，该类也可以保证Long类型操作的原子性，相对于AtomicLong，LongAdder有着更高的性能和更好的表现，可以完全替代AtomicLong的来进行原子操作。

107、CAS机制
CAS是英文单词Compare and Swap的缩写，翻译过来就是比较并替换。

CAS机制中使用了3个基本操作数：内存地址V，旧的预期值A，要修改的新值B。

更新一个变量的时候，只有当变量的预期值A和内存地址V当中的实际值相同时，才会将内存地址V对应的值修改为B。
我们看一个例子：

1. 在内存地址V当中，存储着值为10的变量。

2. 此时线程1想把变量的值增加1.对线程1来说，旧的预期值A=10，要修改的新值B=11.

3. 在线程1要提交更新之前，另一个线程2抢先一步，把内存地址V中的变量值率先更新成了11。
   

4. 线程1开始提交更新，首先进行A和地址V的实际值比较，发现A不等于V的实际值，提交失败。
   

5. 线程1 重新获取内存地址V的当前值，并重新计算想要修改的值。此时对线程1来说，A=11，B=12。这个重新尝试的过程被称为自旋。

6. 这一次比较幸运，没有其他线程改变地址V的值。线程1进行比较，发现A和地址V的实际值是相等的。

7. 线程1进行交换，把地址V的值替换为B，也就是12.

从思想上来说，synchronized属于悲观锁，悲观的认为程序中的并发情况严重，所以严防死守，CAS属于乐观锁，乐观地认为程序中的并发情况不那么严重，所以让线程不断去重试更新。

108、● 请说明一下JAVA中反射的实现过程和作用分别是什么？
JAVA语言编译之后会生成一个.class文件，反射就是通过字节码文件找到某一个类、类中的方法以及属性等。反射的实现主要借助以下四个类：Class：类的对象，Constructor：类的构造方法，Field：类中的属性对象，Method：类中的方法对象。

作用：反射机制指的是程序在运行时能够获取自身的信息。在JAVA中，只要给定类的名字，那么就可以通过反射机制来获取类的所有信息。

109、● 请简单描述一下JVM加载class文件的原理是什么?
Java中的所有类，都需要由类加载器装载到JVM中才能运行。JVM中类的装载是由ClassLoader和它的子类来实现的，

类装载方式，有两种
（1）隐式装载，程序在运行过程中当碰到通过new 等方式生成对象时，隐式调用类装载器加载对应的类到jvm中。
（2）显式装载，通过class.forname()等方法，显式加载需要的类 。class.forname()是运用反射的原理创建对象。
隐式加载与显式加载的区别：两者本质是一样的。

Java类的加载是动态的，它并不会一次性将所有类全部加载后再运行，而是保证程序运行的基础类(像是基类)完全加载到jvm中，至于其他类，则在需要的时候才加载。这当然就是为了节省内存开销。

110、● 什么是Java虚拟机？为什么Java被称作是“平台无关的编程语言”？
Java虚拟机是一个可以执行Java字节码的虚拟机进程。Java源文件被编译成能被Java虚拟机执行的字节码文件。
Java被设计成允许应用程序可以运行在任意的平台，而不需要程序员为每一个平台单独重写或者是重新编译。Java虚拟机让这个变为可能，因为它知道底层硬件平台的指令长度和其他特性。

111、JVM内存结构
本方虚堆城（本、虚、城是线程私有的）

一、程序计数器
程序计数器是一块很小的内存空间，它是线程私有的，可以看做是当前线程所执行的字节码的行号指示器。
作用：
1、字节码解释器通过此读取指令
2、在多线程情况下，程序计算器用来记录当前线程执行的位置。

这块内存区域是虚拟机规范中唯一没有OutOfMemoryError的区域。

二、java虚拟机栈
同计数器也为线程私有，生命周期与线程相同。栈描述的是Java方法执行的内存模型。

每个方法被执行的时候都会创建一个栈帧用于存储局部变量表，操作栈，动态链接，方法出口等信息。每一个方法被调用的过程就对应一个栈帧在虚拟机栈中从入栈到出栈的过程。
局部变量表里面存储的是各种基本数据类型、对象引用等

三、本地方法栈
线程私有的，本地方法栈是与虚拟机栈发挥的作用十分相似,区别是虚拟机栈执行的是Java方法(也就是字节码)服务，而本地方法栈则为虚拟机使用到的native方法服务，可能底层调用的c或者c++。

四、堆
堆是线程共享的。
所有对象实例和数组都在堆上分配。
唯一目的就是存放对象实例，几乎所有的对象实例都在这里分配内存。
java堆是垃圾收集器管理的主要区域，因此经常被称为“GC堆”。java堆中可以细分为新生代和老年代。再细致一点还可以分为eden空间、from survivor空间、to survivor空间。
java堆可以处于物理上不连续的内存空间中，只要逻辑上是连续的即可。

五、方法区
是线程共享的
用于存储已被虚拟机加载的类信息、常量、静态变量
JDK1.8后，方法区已经被移出，取而代之的是元空间。

112、java的内存模型
定义了线程和主内存之间的抽象关系：线程之间的共享变量存储在主内存（main memory）中，每个线程都有一个私有的本地内存（local memory），本地内存中存储了该线程以读/写共享变量的副本。

113、垃圾回收的对象
程序计数器、虚拟机栈、本地方法栈三个区域随线程而生，随线程而灭，不需要垃圾回收。
垃圾回收是对于堆和方法区的。

114、● 请列举一下，在JAVA虚拟机中，哪些对象可作为ROOT对象？
虚拟机栈中的引用对象

方法区中类静态属性引用的对象

方法区中常量引用对象

本地方法栈中JNI(即一般说的native方法)引用对象

115、● GC中如何判断对象是否需要被回收？
即使在可达性分析算法中不可达的对象,也并非是“非回收不可”的,这时候它们暂时处于“等待”阶段,要真正宣告一个对象回收,至少要经历两次标记过程:如果对象在进行可达性分析后发现没有与GC Roots相连接的引用链,那它将会被第一次标记并且进行一次筛选,筛选的条件是此对象是否有必要执行finalize()方法。当对象没有覆盖finalize()方法,或者finalize()方法已经被虚拟机调用过,虚拟机将这两种情况都视为“没有必要执行”。(即意味着直接回收)

如果这个对象被判定为有必要执行finalize()方法,则放入一个队列中进行二次标记，如果finalize()方法中没有将此对象与其他root链接起来，则这本对象就会被回收。

116、● 请说明一下eden区和survial区的含义以及工作原理？
目前主流的虚拟机实现都采用了分代收集的思想，把整个堆区划分为新生代和老年代；新生代又被划分成Eden 空间、 From Survivor 和 To Survivor 三块区域。

我们把Eden : From Survivor : To Survivor 空间大小设成 8 : 1 : 1 ，
对象总是在 Eden 区出生， From Survivor 保存当前的幸存对象， To Survivor 为空。一次 gc 发生后会进行以下操作：
1）将Eden 区活着的对象 ＋ From Survivor 存储的对象被复制到 To Survivor ；
2) 清空 Eden 和 From Survivor ；
3) 颠倒 From Survivor 和 To Survivor 的逻辑关系： From 变 To ， To 变 From 。

117、垃圾收集算法在这里插入代码片
一、标记清除算法
首先标记出需要回收的对象，在标记完成后统一回收掉所有的被标记对象。
缺点：效率问题和空间问题（标记清除后会产生大量的不连续内存碎片，内存碎片过多可能会导致程序需要分配较大对象时找不到足够大的连续内存空间而不得不提前触发另一次垃圾回收动作）
二、复制算法（Copying）
将内存划分为大小相等的两块，每次只使用其中的一块。当这块内存用完了，就将还存活的对象复制到另一块内存上，然后把已使用过的内存空间一次清理掉。

优点：每次只对其中一块进行GC,不用考虑内存碎片的问题，并且实现简单，运行高效
缺点：内存缩小了一半

现在的商业虚拟机都采用这种方法

三、标记-整理算法
让所有存活对象都向一端移动，然后直接清理掉端边界以外的所有内存。

四、分代收集算法
根据对象的存活周期的不同将内存划分为几块，一般就分为新生代和老年代，根据各个年代的特点采用不同的收集算法。新生代（少量存活）用复制算法，老年代（对象存活率高）“标记-清理”算法

118、内存分配与回收策略
1.对象优先在Eden分配
在大多数情况下，对象在新生代Eden区中分配。当Eden区没有足够的空间进行分配时，虚拟机将发起一次Minor GC。
2.大对象直接进入老年代
所谓大对象就是需要大量连续空间的Java对象，最典型的大对象就是那种很长的字符串及数组。
3.长期存活的对象将进入老年代
虚拟机给每个对象定义了一个对象年龄计数器。如果对象在Eden出生并经过第一次Minor GC后仍然存活，并且能够被Survivor容纳的话，将被移动到Survivor空间中，并将对象年龄设置为1.对象在Survivor区每熬过一次Minor GC,年龄就增加一岁，当它的年龄增加到一定程度（默认15岁）时，就会被晋升到老年代中。
4.动态对象年龄判定
为了能更好地适应不同程序的内存状况，虚拟机并不总是要求对象的年龄必须达到MaxTenuringThreshold才能晋升老年代，如果在Survivor空间中相同年龄所有对象大小总和大于Survicor空间的一半，年龄大于或等于该年龄的对象就可以直接进入老年代，无须等到MaxTenuringThreshold中要求的年龄。
5.空间分配担保
在发生Minor GC时，虚拟机会检查老年代连续的空闲区域是否大于新生代所有对象的总和，若成立，则说明Minor GC是安全的，否则，虚拟机需要查看HandlePromotionFailure的值，看是否运行担保失败，若允许，则虚拟机继续检查老年代最大可用的连续空间是否大于历次晋升到老年代对象的平均大小，若大于，将尝试进行一次Minor GC；若小于或者HandlePromotionFailure设置不运行冒险，那么此时将改成一次Full GC，以上是JDK Update 24之前的策略，之后的策略改变了，只要老年代的连续空间大于新生代对象总大小或者历次晋升的平均大小就会进行Minor GC，否则将进行Full GC。

冒险是指经过一次Minor GC后有大量对象存活，而新生代的survivor区很小，放不下这些大量存活的对象，所以需要老年代进行分配担保，把survivor区无法容纳的对象直接进入老年代。
119、Minor GC和Full GC的区别
Minor GC:指发生在新生代的垃圾收集动作，非常频繁，速度较快。
首先，把Eden和ServivorFrom区域中存活的对象复制到ServicorTo区域（如果有对象的年龄以及达到了老年的标准，则赋值到老年代区），同时把这些对象的年龄+1（如果ServicorTo不够位置了就放到老年区）；然后，清空Eden和ServicorFrom中的对象；最后，ServicorTo和ServicorFrom互换，原ServicorTo成为下一次GC时的ServicorFrom区。

Major GC:指发生在老年代的GC，出现Major GC，经常会伴随一次Minor GC，同时Minor GC也会引起Major GC，一般在GC日志中统称为GC，不频繁。
在进行MajorGC前一般都先进行了一次MinorGC，使得有新生代的对象晋身入老年代，导致空间不够用时才触发。

Full GC:清理整个空间，包括年轻代和老年代，速度很慢，需要Stop The World。

120、● 请简单描述一下类的加载过程（未完）
JVM类加载机制分为五个部分：加载，验证，准备，解析，初始化。

加载
加载是类加载过程中的一个阶段，这个阶段会在内存中生成一个代表这个类的java.lang.Class对象，作为方法区这个类的各种数据的入口。注意这里不一定非得要从一个Class文件获取，这里既可以从ZIP包中读取（比如从jar包和war包中读取），也可以在运行时计算生成（动态代理），也可以由其它文件生成（比如将JSP文件转换成对应的Class类）。

验证
这一阶段的主要目的是为了确保Class文件的字节流中包含的信息是否符合当前虚拟机的要求，并且不会危害虚拟机自身的安全。

准备
准备阶段是正式为类变量分配内存并设置类变量的初始值阶段，即在方法区中分配这些变量所使用的内存空间。

解析
解析阶段是指虚拟机将常量池中的符号引用替换为直接引用的过程。

初始化
初始化阶段是类加载最后一个阶段，前面的类加载阶段之后，除了在加载阶段可以自定义类加载器以外，其它操作都由JVM主导。到了初始阶段，才开始真正执行类中定义的Java程序代码。

121、类加载器
虚拟机设计团队把加载动作放到JVM外部实现，以便让应用程序决定如何获取所需的类，JVM提供了3种类加载器：
**启动类加载器(**Bootstrap ClassLoader)：负责加载 JAVA_HOME\lib 目录中的，或通过-Xbootclasspath参数指定路径中的，且被虚拟机认可（按文件名识别，如rt.jar）的类。

扩展类加载器(Extension ClassLoader)：负责加载 JAVA_HOME\lib\ext 目录中的，或通过java.ext.dirs系统变量指定路径中的类库。

应用程序类加载器(Application ClassLoader)：负责加载用户路径（classpath）上的类库。

JVM通过双亲委派模型进行类的加载，当然我们也可以通过继承java.lang.ClassLoader实现自定义的类加载器。

122、双亲委派模型

当一个类加载器收到类加载任务，会先交给其父类加载器去完成，因此最终加载任务都会传递到顶层的启动类加载器，只有当父类加载器无法完成加载任务时，才会尝试执行加载任务。采用双亲委派的一个好处是比如加载位于rt.jar包中的类java.lang.Object，不管是哪个加载器加载这个类，最终都是委托给顶层的启动类加载器进行加载，这样就保证了使用不同的类加载器最终得到的都是同样一个Object对象。

因为如果不用双亲委派模型，则不同加载器得到的object是不同的对象（同一个对象的必要条件是由同一个加载器加载的）

123、垃圾收集器

Serial收集器
串行收集器，缺点是当Serial收集器想进行垃圾回收的时候，必须暂停用户的所有进程，即stop the world。到现在为止，它依然是虚拟机运行在client模式下的默认新生代收集器，与其他收集器相比，对于限定在单个CPU的运行环境来说，Serial收集器由于没有线程交互的开销，专心做垃圾回收自然可以获得最高的单线程收集效率。

ParNew收集器
ParNew收集器是Serial收集器新生代的多线程实现，注意在进行垃圾回收的时候依然会stop the world，只是相比较Serial收集器而言它会运行多条进程进行垃圾回收。

Parallel Scavenge收集器
是一个新生代收集器，Parallel是采用复制算法的多线程新生代垃圾回收器，似乎和ParNew收集器有很多的相似的地方。但是Parallel Scanvenge收集器的一个特点是它所关注的目标是吞吐量(Throughput)。所谓吞吐量就是CPU用于运行用户代码的时间与CPU总消耗时间的比值，即吞吐量=运行用户代码时间

Parallel Old收集器
是Parallel Scavenge收集器的老年代版本，采用多线程和”标记－整理”算法。

CMS收集器（重要）

CMS(Concurrent Mark Swep)收集器是一个比较重要的回收器，现在应用非常广泛，我们重点来看一下，CMS一种获取最短回收停顿时间为目标的收集器，这使得它很适合用于和用户交互的业务。从名字(Mark Swep)就可以看出，CMS收集器是基于标记清除算法实现的。它的收集过程分为四个步骤：

初始标记(initial mark)
并发标记(concurrent mark)
重新标记(remark)
并发清除(concurrent sweep)

注意初始标记和重新标记还是会stop the world，但是在耗费时间更长的并发标记和并发清除两个阶段都可以和用户进程同时工作。

优点：并发收集、低停顿

G1收集器（重要）
G1收集器是一款面向服务端应用的垃圾收集器。HotSpot团队赋予它的使命是在未来替换掉JDK1.5中发布的CMS收集器。

特点：
**并行与并发：**G1能更充分的利用CPU，多核环境下的硬件优势来缩短stop the world的停顿时间。

**分代收集：**和其他收集器一样，分代的概念在G1中依然存在，不过G1不需要其他的垃圾回收器的配合就可以独自管理整个GC堆。

**空间整合：**G1收集器使用“标记-整理”算法实现收集器。意味着运行期间不会产生内存碎片

**可预测的非停顿：**这是G1相对于CMS的另一大优势，降低停顿时间是G1和CMS共同的关注点，能让使用者明确指定在一个长度为M毫秒的时间片段内，消耗在垃圾收集上的时间不得超过N毫秒。

124、● 请简单描述一下垃圾回收器的基本原理是什么？并且有什么办法可以主动通知虚拟机进行垃圾回收呢？
对于GC来说，当程序员创建对象时，GC就开始监控这个对象的地址、大小以及使用情况。通常，GC采用有向图的方式记录和管理堆(heap)中的所有对象。通过这种方式确定哪些对象是”可达的”，哪些对象是”不可达的”。当GC确定一些对象为”不可达”时，GC就有责任回收这些内存空间。

程序员可以手动执行System.gc()，通知GC运行，但是Java语言规范并不保证GC一定会执行。

125、● 请问，在java中会存在内存泄漏吗？请简单描述一下。
有两类主要的Java内存泄漏:

• 不再需要的对象引用
• 未释放的系统资源
  比如：静态类的生命周期和线程一样，当不使用静态类时，内存也不会被释放。

126、● 什么原因会导致minor gc运行频繁？同样的，什么原因又会导致minor gc运行很慢？请简要说明一下
运行频繁：
1、 产生了太多朝生夕灭的对象导致需要频繁minor gc
2、 新生代空间设置的比较小
运行很慢：
1、 新生代空间设置过大。
2、 对象引用链较长，进行可达性分析时间较长。
3、 新生代survivor区设置的比较小，清理后剩余的对象不能装进去需要移动到老年代，造成移动开销。
4、 内存分配担保失败，由minor gc转化为full gc
5、 采用的垃圾收集器效率较低，比如新生代使用serial收集器

127、● 请问运行时异常与受检异常有什么区别？

Java标准库内建了一些通用的异常，这些类以Throwable为顶层父类。
Throwable又派生出Error类和Exception类。

Java的异常（Exception和Error）分为检查异常和非检查的异常。
其中根据Exception异常进行分类，可分为运行时异常和非运行时异常。

异常类分为2类：
**非检查异常（unckecked exception）：**Error 和 RuntimeException 以及他们的子类。javac在编译时，不会提示和发现这样的异常，不要求在程序处理这些异常。所以如果愿意，我们可以编写代码处理（使用try…catch…finally）这样的异常，也可以不处理。对于这些异常，我们应该修正代码，而不是去通过异常处理器处理 。这样的异常发生的原因多半是代码写的有问题。如除0错误ArithmeticException，错误的强制类型转换错误ClassCastException，数组索引越界ArrayIndexOutOfBoundsException，使用了空对象NullPointerException等等。

**检查异常（checked exception）：**除了Error 和 RuntimeException的其它异常。javac强制要求程序员为这样的异常做预备处理工作（使用try…catch…finally或者throws）。**在方法中要么用try-catch语句捕获它并处理，要么用throws子句声明抛出它，否则编译不会通过。这样的异常一般是由程序的运行环境导致的。**因为程序可能被运行在各种未知的环境下，而程序员无法干预用户如何使用他编写的程序，于是程序员就应该为这样的异常时刻准备着。如SQLException , IOException,ClassNotFoundException 等。

Exception异常进行分类，可分为运行时异常和非运行时异常：
运行时异常:
都是RuntimeException类及其子类异常，如NullPointerException(空指针异常)、IndexOutOfBoundsException(下标越界异常)等，这些异常是非检查异常，程序中可以选择捕获处理，也可以不处理。这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生。

运行时异常的特点是Java编译器不会检查它，也就是说，当程序中可能出现这类异常，即使没有用try-catch语句捕获它，也没有用throws子句声明抛出它，也会编译通过

非运行时异常：
是RuntimeException以外的异常，类型上都属于Exception类及其子类。从程序语法角度讲是必须进行处理的异常，如果不处理，程序就不能编译通过。如IOException、SQLException等以及用户自定义的Exception异常，一般情况下不要自定义检查异常。

128、● 请问什么是java序列化？以及如何实现java序列化？
序列化就是将对象转换成二进制序列的操作。
序列化的实现：将需要被序列化的类实现Serializable接口，该接口没有需要实现的方法，implements Serializable只是为了标注该对象是可被序列化的，然后使用一个输出流(如：FileOutputStream)来构造一个 ObjectOutputStream(对象流)对象，接着，使用ObjectOutputStream对象的writeObject(Object obj)方法就可以将参数为obj的对象写出(即保存其状态)。

反序列化：用FileInputStream构造一个ObjectInputStream对象，然后使用ObjectInputStream的readObject()方法反序列化

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.text.MessageFormat;

/**
 * <p>ClassName: TestObjSerializeAndDeserialize<p>
 * <p>Description: 测试对象的序列化和反序列<p>
 * @author xudp
 * @version 1.0 V
 * @createTime 2014-6-9 下午03:17:25
 */
public class TestObjSerializeAndDeserialize {

    public static void main(String[] args) throws Exception {
        SerializePerson();//序列化Person对象
        Person p = DeserializePerson();//反序列Perons对象
        System.out.println(MessageFormat.format("name={0},age={1},sex={2}",
                                                 p.getName(), p.getAge(), p.getSex()));
    }
    
    /**
     * MethodName: SerializePerson 
     * Description: 序列化Person对象
     * @author xudp
     * @throws FileNotFoundException
     * @throws IOException
     */
    private static void SerializePerson() throws FileNotFoundException,
            IOException {
        Person person = new Person();
        person.setName("gacl");
        person.setAge(25);
        person.setSex("男");
        // ObjectOutputStream 对象输出流，将Person对象存储到E盘的Person.txt文件中，完成对Person对象的序列化操作
        ObjectOutputStream oo = new ObjectOutputStream(new FileOutputStream(
                new File("E:/Person.txt")));
        oo.writeObject(person);
        System.out.println("Person对象序列化成功！");
        oo.close();
    }

    /**
     * MethodName: DeserializePerson 
     * Description: 反序列Perons对象
     * @author xudp
     * @return
     * @throws Exception
     * @throws IOException
     */
    private static Person DeserializePerson() throws Exception, IOException {
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(
                new File("E:/Person.txt")));
        Person person = (Person) ois.readObject();
        System.out.println("Person对象反序列化成功！");
        return person;
    }

}

129、● 请问java中有几种类型的流？JDK为每种类型的流提供了一些抽象类以供继承，请说出他们分别是哪些类？
字节流，字符流。
字节流：InputStream（字节输入流）、OutputStream（字节输出流）；
字符流：Reader（字符输入流）、Writer（字符输出流）；

字节流是最基本的，采用ASCII编码,所有的InputStream和OutputStream的子类都是,主要用在处理二进制数据，它是按字节来处理的
但实际中很多的数据是文本，又提出了字符流的概念，采用Unicode编码.它是按虚拟机的encode来处理，也就是要进行字符集的转化

字节流和字符流的区别：字节流不用缓存，字符流用到了缓存

130、● 请问你平时最常见到的runtime exception是什么？
1， ClassCastException类型强制转换异常
Object x = new Integer(0);
System.out.println((String)x);
当试图将对象强制转换为不是实例的子类时，抛出该异常

2，ArithmeticException算术异常类
int a=5/0;
一个整数“除以零”时，抛出异常

3, NullPointerException空指针异常类
String s=null;
int size=s.size();
当应用程序试图在需要对象的地方使用 null 时，抛出异常

4, StringIndexOutOfBoundsException
“hello”.indexOf(-1);
指示索引或者为负，或者超出字符串的大小，抛出异常

5，NegativeArraySizeException数组负下标异常
数组大小为负值异常。当使用负数大小值创建数组时抛出该异常
String[] ss=new String[-1];
如应用程序试图创建大小为负的数组，则抛出异常

6，IllegalArgumentException参数异常
抛出的异常表明向方法传递了一个不合法或不正确的参数

7，NumberFormatException数字格式异常
当试图将一个String转换为指定的数字类型，而该字符串确不满足数字类型要求的格式时，抛出该异常

8，ArrayIndexOutOfBoundsException数组下标越界异常
当使用的数组下标超出数组允许范围时，抛出该异常

9,ClassNotFoundException找不到类异常
当应用试图根据字符串形式的类名构造类，而在遍历CLASSPAH之后找不到对应名称的class文件时，抛出该异常

10,ArrayStoreException数组存储异常
当向数组中存放非数组声明类型对象时抛出

11，NoSuchMethodException 方法未找到异常

12，FileNotFoundException 文件未找到异常

131、● 请问error和exception有什么区别?
首先，Error类和Exception类都是继承Throwable类
Error（错误）是系统中的错误，程序员是不能改变的和处理的，是在程序编译时出现的错误，只能通过修改程序才能修正。一般是指与虚拟机相关的问题，如系统崩溃，虚拟机错误，内存空间不足，方法调用栈溢等。对于这类错误的导致的应用程序中断，仅靠程序本身无法恢复和和预防，遇到这样的错误，建议让程序终止。

Exception（异常）表示程序可以处理的异常，可以捕获且可能恢复。遇到这类异常，应该尽可能处理异常，使程序恢复运行，而不应该随意终止异常。

132、BIO/NIO/AIO
Java BIO ： 同步并阻塞，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，当然可以通过线程池机制改善。

Java NIO ： 同步非阻塞，服务器实现模式为一个请求一个线程，即客户端发送的连接请求都会注册到多路复用器上，多路复用器轮询到连接有I/O请求时才启动一个线程进行处理。

Java AIO(NIO.2) ： 异步非阻塞，服务器实现模式为一个有效请求一个线程，客户端的I/O请求都是由OS先完成了再通知服务器应用去启动线程进行处理，