异常基础 Exception

Java中的异常分为两大类：
　　1.Checked Exception（非Runtime Exception）

2.Unchecked Exception（Runtime Exception）

运行时异常
　　RuntimeException类是Exception类的子类，它叫做运行时异常，Java中的所有运行时异常都会直接或者间接地继承自RuntimeException类。

Java中凡是继承自Exception，而不继承自RuntimeException类的异常都是非运行时异常。

自定义异常
　　所谓自定义异常，通常就是定义一个类，去继承Exception类或者它的子类。因为异常必须直接或者间接地继承自Exception类。

通常情况下，会直接继承自Exception类，一般不会继承某个运行时的异常类。

自定义异常可以用于处理用户登录错误，用户输入错误提示等。

final关键字

1、修饰类：当用final修饰一个类时，表明这个类不能被继承。

2、修饰方法：因此，如果只有在想明确禁止 该方法在子类中被覆盖的情况下才将方法设置为final的

3、修饰变量
对于一个final变量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。
当用final作用于类的成员变量时，成员变量（注意是类的成员变量，局部变量只需要保证在使用之前被初始化赋值即可）必须在定义时或者构造器中进行初始化赋值，而且final变量一旦被初始化赋值之后，就不能再被赋值了。
4、final和static
很多时候会容易把static和final关键字混淆，static作用于成员变量用来表示只保存一份副本，而final的作用是用来保证变量不可变。看下面这个例子：

Interface与abstract类的区别

接口和内部类为我们提供了一种将接口与实现分离的更加结构化的方法。

https://blog.csdn.net/u011860731/article/details/48731217

抽象类

如果一个类没有足够的信息来描述一个具体的对象，而需要其他具体的类来支撑它，那么这样的类我们称它为抽象类。比如new Animal()，我们都知道这个是产生一个动物Animal对象，但是这个Animal具体长成什么样子我们并不知道，它没有一个具体动物的概念，所以他就是一个抽象类，需要一个具体的动物，如狗、猫来对它进行特定的描述，我们才知道它长成啥样。

抽象类提供了继承的概念，它的出发点就是为了继承，否则它没有存在的任何意义。所以说定义的抽象类一定是用来继承的，同时在一个以抽象类为节点的继承关系等级链中，叶子节点一定是具体的实现类。

在使用抽象类时需要注意几点：
1、抽象类不能被实例化，实例化的工作应该交由它的子类来完成，它只需要有一个引用即可。

2、抽象方法必须由子类来进行重写。

3、只要包含一个抽象方法的抽象类，该方法必须要定义成抽象类，不管是否还包含有其他方法。

4、抽象类中可以包含具体的方法，当然也可以不包含抽象方法。

接口

接口是抽象类的延伸，java了保证数据安全是不能多重继承的，也就是说继承只能存在一个父类，但是接口不同，一个类可以同时实现多个接口，不管这些接口之间有没有关系，所以接口弥补了抽象类不能多重继承的缺陷，但是推荐继承和接口共同使用，因为这样既可以保证数据安全性又可以实现多重继承。

1、个Interface的方所有法访问权限自动被声明为public。确切的说只能为public，当然你可以显示的声明为protected、private，但是编译会出错！

2、接口中可以定义“成员变量”，或者说是不可变的常量，因为接口中的“成员变量”会自动变为为public static final。可以通过类命名直接访问：ImplementClass.name。
3、接口中不存在实现的方法。
4、实现接口的非抽象类必须要实现该接口的所有方法。抽象类可以不用实现。

总结

  1、 抽象类在java语言中所表示的是一种继承关系，一个子类只能存在一个父类，但是可以存在多个接口。

  2、 在抽象类中可以拥有自己的成员变量和非抽象类方法，但是接口中只能存在静态的不可变的成员数据（不过一般都不在接口中定义成员数据），而且它的所有方法都是抽象的。

  3、抽象类和接口所反映的设计理念是不同的，抽象类所代表的是“is-a”的关系，而接口所代表的是“like-a”的关系。

NIO和IO

https://blog.csdn.net/yellowatumn/article/details/49738551
服务端和客户端各自维护一个管理通道的对象，我们称之为selector，该对象能检测一个或多个通道 (channel) 上的事件。我们以服务端为例，如果服务端的selector上注册了读事件，某时刻客户端给服务端发送了一些数据，阻塞I/O这时会调用read()方法阻塞地读取数据，而NIO的服务端会在selector中添加一个读事件。服务端的处理线程会轮询地访问selector，如果访问selector时发现有感兴趣的事件到达，则处理这些事件，如果没有感兴趣的事件到达，则处理线程会一直阻塞直到感兴趣的事件到达为止。

反射

https://www.zhihu.com/question/24304289

反射是什么呢？当我们的程序在运行时，需要动态的加载一些类这些类可能之前用不到所以不用加载到jvm，而是在运行时根据需要才加载，这样的好处对于服务器来说不言而喻，举个例子我们的项目底层有时是用mysql，有时用oracle，需要动态地根据实际情况加载驱动类，这个时候反射就有用了，假设 com.java.dbtest.myqlConnection，com.java.dbtest.oracleConnection这两个类我们要用，这时候我们的程序就写得比较动态化，通过Class tc = Class.forName("com.java.dbtest.TestConnection");通过类的全类名让jvm在服务器中找到并加载这个类，而如果是oracle则传入的参数就变成另一个了。这时候就可以看到反射的好处了，这个动态性就体现出java的特性了！举多个例子，大家如果接触过spring，会发现当你配置各种各样的bean时，是以配置文件的形式配置的，你需要用到哪些bean就配哪些，spring容器就会根据你的需求去动态加载，你的程序就能健壮地运行。答案比较粗糙，点到为止!这里提供一篇比较深入的博文地址:深入解析Java反射（1） - 基础

http://www.sczyh30.com/posts/Java/java-reflection-1/#%E4%B8%80%E3%80%81%E5%9B%9E%E9%A1%BE%EF%BC%9A%E4%BB%80%E4%B9%88%E6%98%AF%E5%8F%8D%E5%B0%84%EF%BC%9F

hashcode

在 Java 中，Object 对象的 hashCode() 方法会根据不同的对象生成不同的哈希值，默认情况下为了确保这个哈希值的唯一性，是通过将该对象的内部地址转换成一个整数来实现的。

对象要实现排序,需要实现什么接口

https://blog.csdn.net/u014469254/article/details/50625094
comparable

ArrayList,Vector, LinkedList的存储性能和特性

ArrayList和Vector都是使用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，它们都允许直接按序号索引元素，但是插入元素要涉及数组元素移动等内存操作，所以索引数据快而插入数据慢，Vector由于使用了synchronized方法（线程安全），通常性能上较ArrayList差，而LinkedList使用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快。

HashMap和Hashtable的区别

HashMap是Hashtable的轻量级实现（非线程安全的实现），他们都完成了Map接口，主要区别在于HashMap允许空（null）键值（key）,由于非线程安全，效率上可能高于Hashtable。
HashMap允许将null作为一个entry的key或者value，而Hashtable不允许。
Hashtable继承自Dictionary类，而HashMap是Java1.2引进的Map interface的一个实现。
的不同是，Hashtable的方法是Synchronize的，而HashMap不是，在多个线程访问Hashtable时，不需要自己为它的方法实现同步，而HashMap 必须为之提供外同步。

final, finally, finalize的区别

final 用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。
finally是异常处理语句结构的一部分，表示总是执行。
finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资源回收，例如关闭文件等。

同步和异步有何异同，在什么情况下分别使用他们？举例说明。

如果数据将在线程间共享。例如正在写的数据以后可能被另一个线程读到，或者正在读的数据可能已经被另一个线程写过了，那么这些数据是共享数据，必须进行同步存取。
当应用程序在对象上调用了一个需要花费很长时间来执行的方法，并且不希望让程序等待方法的返回时，应该使用异步编程，在很多情况下采用异步途径往往更有效率。

深入理解 HashMap put 方法

HashMap 不过是 Node 数组加 链表和红黑树。
https://hacpai.com/article/1514726612565

1. 初始化数组

2. 通过 hash 计算下标并检查 hash 是否冲突，也就是对应的下标是否已存在元素。

• 判断数组是否为空，如果是空，则创建默认长度位 16 的数组。
• 通过与运算计算对应 hash 值的下标，如果对应下标的位置没有元素，则直接创建一个。
• 如果有元素，说明 hash 冲突了，则再次进行 3 种判断。
  • 判断两个冲突的 key 是否相等，equals 方法的价值在这里体现了。如果相等，则将已经存在的值赋给变量 e。最后更新 e 的 value，也就是替换操作。
  • 如果 key 不相等，则判断是否是红黑树类型，如果是红黑树，则交给红黑树追加此元素。
  • 如果 key 既不相等，也不是红黑树，则是链表，那么就遍历链表中的每一个 key 和给定的 key 是否相等。如果，链表的长度大于等于 8 了，则将链表改为红黑树，这是 Java8 的一个新的优化。
• 最后，如果这三个判断返回的 e 不为 null，则说明 key 重复，则更新 key 对应的 value 的值。
• 对维护着迭代器的 modCount 变量加一。
• 最后判断，如果当前数组的长度已经大于阀值了。则重新 hash。

第一个问题,HashMap 是使用下面的算法来计算元素的存放位置的。

https://blog.csdn.net/linsongbin1/article/details/54667453
int hash = hash(key);
int i = indexFor(hash, table.length);
首先先hash,之后结合数组的长度进行一个&操作得到得到数组的下标。

第二个问题 则利用Entry类的next变量来实现链表,把最新的元素放到链表头,旧的数据则被最新的元素的next变量引用着

get操作：

这个操作的原理就比较简单,只需要根据key的hashcode算出元素在数组中的下标,之后遍历Entry对象链表,直到找到元素为止。

总结

HashMap使用了数组+链表的方案,做到了读取快,插入快的目的,但是HashMap还是一些使用上的问题的:
1、线程不安全
2、当容量不够时,会进行rehash的流程,非常耗资源

HashMap

https://www.cnblogs.com/rogerluo1986/p/5851300.html
HashMap基于哈希表的 Map 接口的实现。
HashMap采取数组加链表的存储方式来实现。亦即数组（散列桶）中的每一个元素都是链表

image.png

当哈希表中的条目数超出了加载因子与当前容量的乘积时，则要对该哈希表进行 rehash 操作（即重建内部数据结构），从而哈希表将具有大约两倍的桶数。
这意味着当HashMap中条目的数量达到了条目数量75%时，HashMap将进行resize操作以增加桶的数量。

2.1.7 put方法
2.1.8 addEntry方法
2.1.9 resize方法

一致性Hash算法

最关键的区别就是，对节点和数据，都做一次哈希运算，然后比较节点和数据的哈希值，数据取和节点最相近的节点做为存放节点，相当于整个哈希值就是一个环。这样就保证当节点增加或者减少的时候，影响的数据最少。

ArrayList原理

https://blog.csdn.net/guoweimelon/article/details/50800349
ArrayList的实现原理总结如下：
①数据存储是基于数组实现的，默认初始容量为10；

②添加数据时，首先需要检查元素个数是否超过数组容量，如果超过了则需要对数组进行扩容；插入数据时，需要将插入点k开始到数组末尾的数据全部向后移动一位。

③数组的扩容是新建一个大容量（原始数组大小+扩充容量）的数组，然后将原始数组数据拷贝到新数组，然后将新数组作为扩容之后的数组。数组扩容的操作代价很高，我们应该尽量减少这种操作。

④删除数据时，需要将删除点+1位置开始到数组末尾的数据全部向前移动一位。

⑤获取数据很快，根据数组下表可以直接获取。

jvm字节码的加载与卸载

虚拟机把描述类的数据从class文件加载到内存，并对数据进行校验，转换分析和初始化，最终形成可以被虚拟节直接使用的JAVA类型，这就是虚拟机的类加载机制。

类从被加载到虚拟机内存到卸载出内存的生命周期包括：加载->连接(验证->准备->解析)->初始化->使用->卸载

1.使用new关键字实例化对象时，读取或设置一个类的静态字段，除被final修饰经编译结果放在常量池的静态字段，调用类的静态方法时。 2.使用java.lang.reflect包方法对类进行反射调用时。（Class.forName()）

加载器链接到委托链中：AppClassLoader -> ExtClassLoader -> BootstrapLoader。

GC

引用计数：每个对象有一个引用计数属性，新增一个引用时计数加1，引用释放时计数减1，计数为0时可以回收。此方法简单，无法解决对象相互循环引用的问题。

可达性分析（Reachability Analysis）：从GC Roots开始向下搜索，搜索所走过的路径称为引用链。当一个对象到GC Roots没有任何引用链相连时，则证明此对象是不可用的。不可达对象。

垃圾收集算法

https://www.cnblogs.com/ityouknow/p/5614961.html

1. 标记 -清除算法
   “标记-清除”（Mark-Sweep）算法，如它的名字一样，算法分为“标记”和“清除”两个阶段：首先标记出所有需要回收的对象，在标记完成后统一回收掉所有被标记的对象。之所以说它是最基础的收集算法，是因为后续的收集算法都是基于这种思路并对其缺点进行改进而得到的。

它的主要缺点有两个：一个是效率问题，标记和清除过程的效率都不高；另外一个是空间问题，标记清除之后会产生大量不连续的内存碎片，空间碎片太多可能会导致，当程序在以后的运行过程中需要分配较大对象时无法找到足够的连续内存而不得不提前触发另一次垃圾收集动作。

image.png

2. 复制算法
   “复制”（Copying）的收集算法，它将可用内存按容量划分为大小相等的两块，每次只使用其中的一块。当这一块的内存用完了，就将还存活着的对象复制到另外一块上面，然后再把已使用过的内存空间一次清理掉。

   这样使得每次都是对其中的一块进行内存回收，内存分配时也就不用考虑内存碎片等复杂情况，只要移动堆顶指针，按顺序分配内存即可，实现简单，运行高效。只是这种算法的代价是将内存缩小为原来的一半，持续复制长生存期的对象则导致效率降低

   
   
   image.png

3. 标记-压缩算法
   复制收集算法在对象存活率较高时就要执行较多的复制操作，效率将会变低。更关键的是，如果不想浪费50%的空间，就需要有额外的空间进行分配担保，以应对被使用的内存中所有对象都100%存活的极端情况，所以在老年代一般不能直接选用这种算法.

   根据老年代的特点，有人提出了另外一种“标记-整理”（Mark-Compact）算法，标记过程仍然与“标记-清除”算法一样，但后续步骤不是直接对可回收对象进行清理，而是让所有存活的对象都向一端移动，然后直接清理掉端边界以外的内存

   
   
   image.png

4. 分代收集算法
   GC分代的基本假设：绝大部分对象的生命周期都非常短暂，存活时间短。

   “分代收集”（Generational Collection）算法，把Java堆分为新生代和老年代，这样就可以根据各个年代的特点采用最适当的收集算法。在新生代中，每次垃圾收集时都发现有大批对象死去，只有少量存活，那就选用复制算法，只需要付出少量存活对象的复制成本就可以完成收集。而老年代中因为对象存活率高、没有额外空间对它进行分配担保，就必须使用“标记-清理”或“标记-整理”算法来进行回收。

垃圾收集器

1. Serial收集器
   串行收集器是最古老，最稳定以及效率高的收集器，可能会产生较长的停顿，只使用一个线程去回收。新生代、老年代使用串行回收；新生代复制算法、老年代标记-压缩；垃圾收集的过程中会Stop The World（服务暂停）

   参数控制：-XX:+UseSerialGC 串行收集器

2. ParNew收集器
   ParNew收集器其实就是Serial收集器的多线程版本。新生代并行，老年代串行；新生代复制算法、老年代标记-压缩

   参数控制：-XX:+UseParNewGC ParNew收集器

   -XX:ParallelGCThreads 限制线程数量

3. Parallel收集器
   Parallel Scavenge收集器类似ParNew收集器，Parallel收集器更关注系统的吞吐量。可以通过参数来打开自适应调节策略，虚拟机会根据当前系统的运行情况收集性能监控信息，动态调整这些参数以提供最合适的停顿时间或最大的吞吐量；也可以通过参数控制GC的时间不大于多少毫秒或者比例；新生代复制算法、老年代标记-压缩

   参数控制：-XX:+UseParallelGC 使用Parallel收集器+ 老年代串行

4. CMS收集器
   CMS（Concurrent Mark Sweep）收集器是一种以获取最短回收停顿时间为目标的收集器。目前很大一部分的Java应用都集中在互联网站或B/S系统的服务端上，这类应用尤其重视服务的响应速度，希望系统停顿时间最短，以给用户带来较好的体验。

   从名字（包含“Mark Sweep”）上就可以看出CMS收集器是基于“标记-清除”算法实现的

   优点:并发收集、低停顿

   缺点：产生大量空间碎片、并发阶段会降低吞吐量

5. G1收集器
   G1是目前技术发展的最前沿成果之一，HotSpot开发团队赋予它的使命是未来可以替换掉JDK1.5中发布的CMS收集器。与CMS收集器相比G1收集器有以下特点：

   1. 空间整合，G1收集器采用标记整理算法，不会产生内存空间碎片。分配大对象时不会因为无法找到连续空间而提前触发下一次GC。

   2. 可预测停顿，这是G1的另一大优势，降低停顿时间是G1和CMS的共同关注点，但G1除了追求低停顿外，还能建立可预测的停顿时间模型，能让使用者明确指定在一个长度为N毫秒的时间片段内，消耗在垃圾收集上的时间不得超过N毫秒，这几乎已经是实时Java（RTSJ）的垃圾收集器的特征了

Major GC和Full GC的区别

https://blog.csdn.net/skiof007/article/details/51839271

http://www.importnew.com/15820.html
从年轻代空间（包括 Eden 和 Survivor 区域）回收内存被称为 Minor GC。
Minor GC 清理年轻带内存应该被设计得简单：

Major GC 是清理老年代。
Full GC 是清理整个堆空间—包括年轻代和老年代。

最简单的分代式GC策略，按HotSpot VM的serial GC的实现来看，触发条件是：young GC：当young gen中的eden区分配满的时候触发。注意young GC中有部分存活对象会晋升到old gen，所以young GC后old gen的占用量通常会有所升高。full GC：当准备要触发一次young GC时，如果发现统计数据说之前young GC的平均晋升大小比目前old gen剩余的空间大，则不会触发young GC而是转为触发full GC

除直接调用System.gc外，触发Full GC执行的情况有如下四种。

1. 旧生代空间不足
   旧生代空间只有在新生代对象转入及创建为大对象、大数组时才会出现不足的现象，当执行Full GC后空间仍然不足，则抛出如下错误：
   java.lang.OutOfMemoryError: Java heap space
   为避免以上两种状况引起的FullGC，调优时应尽量做到让对象在Minor GC阶段被回收、让对象在新生代多存活一段时间及不要创建过大的对象及数组。
2. Permanet Generation空间满
3. 统计得到的Minor GC晋升到旧生代的平均大小大于旧生代的剩余空间

CopyOnWriteArrayList的原理和使用方法

https://blog.csdn.net/hua631150873/article/details/51306021
https://www.cnblogs.com/dolphin0520/p/3938914.html
这是一个ArrayList的线程安全的变体
所以目前最大的问题，在同一时间多个线程无法对同一个List进行读取和增删，否则就会抛出并发异常。

final ReentrantLock lock = this.lock;

lock.lock();

首先使用上面的两行代码加上了锁，保证同一时间只能有一个线程在添加元素。
然后使用Arrays.copyOf(...)方法复制出另一个新的数组，而且新的数组的长度比原来数组的长度+1，副本复制完毕，新添加的元素也赋值添加完毕，最后又把新的副本数组赋值给了旧的数组，最后在finally语句块中将锁释放

CopyOnWrite容器即写时复制的容器。通俗的理解是当我们往一个容器添加元素的时候，不直接往当前容器添加，而是先将当前容器进行Copy，复制出一个新的容器，然后新的容器里添加元素，添加完元素之后，再将原容器的引用指向新的容器。这样做的好处是我们可以对CopyOnWrite容器进行并发的读，而不需要加锁，因为当前容器不会添加任何元素。所以CopyOnWrite容器也是一种读写分离的思想，读和写不同的容器。

java浅克隆与深克隆

所谓浅克隆是指复制一个对象的实例，但是这个对象中包含的其它的对象还是共用的。

所谓深克隆是指复制一个对象的实例，而且这个对象中包含的其它的对象也要复制一份。
方法：

1. Object 类提供有一个clone方法
2. 这种方法实际上就是“先使对象实现Serializable接口，然后把对象（实际上只是对象的一个拷贝）写到一个流中，再从流中读出来，便可以重建对象。”

Java的三种代理模式

https://www.cnblogs.com/cenyu/p/6289209.html
代理(Proxy)是一种设计模式,提供了对目标对象另外的访问方式;即通过代理对象访问目标对象.这样做的好处是:可以在目标对象实现的基础上,增强额外的功能操作,即扩展目标对象的功能.

1.1.静态代理
静态代理在使用时,需要定义接口或者父类,被代理对象与代理对象一起实现相同的接口或者是继承相同父类.

代码示例:

接口:IUserDao.java

/**
 * 接口
 */
public interface IUserDao {

    void save();
}
目标对象:UserDao.java

/**
 * 接口实现
 * 目标对象
 */
public class UserDao implements IUserDao {
    public void save() {
        System.out.println("----已经保存数据!----");
    }
}
代理对象:UserDaoProxy.java

/**
 * 代理对象,静态代理
 */
public class UserDaoProxy implements IUserDao{
    //接收保存目标对象
    private IUserDao target;
    public UserDaoProxy(IUserDao target){
        this.target=target;
    }

    public void save() {
        System.out.println("开始事务...");
        target.save();//执行目标对象的方法
        System.out.println("提交事务...");
    }
}
测试类:App.java

/**
 * 测试类
 */
public class App {
    public static void main(String[] args) {
        //目标对象
        UserDao target = new UserDao();

        //代理对象,把目标对象传给代理对象,建立代理关系
        UserDaoProxy proxy = new UserDaoProxy(target);

        proxy.save();//执行的是代理的方法
    }
}

1.2.动态代理
总结:
代理对象不需要实现接口,但是目标对象一定要实现接口,否则不能用动态代理

代理工厂类:ProxyFactory.java


/**
 * 创建动态代理对象
 * 动态代理不需要实现接口,但是需要指定接口类型
 */
public class ProxyFactory{

    //维护一个目标对象
    private Object target;
    public ProxyFactory(Object target){
        this.target=target;
    }

   //给目标对象生成代理对象
    public Object getProxyInstance(){
        return Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("开始事务2");
                        //执行目标对象方法
                        Object returnValue = method.invoke(target, args);
                        System.out.println("提交事务2");
                        return returnValue;
                    }
                }
        );
    }

}
测试类:App.java


/**
 * 测试类
 */
public class App {
    public static void main(String[] args) {
        // 目标对象
        IUserDao target = new UserDao();
        // 【原始的类型 class cn.itcast.b_dynamic.UserDao】
        System.out.println(target.getClass());

        // 给目标对象，创建代理对象
        IUserDao proxy = (IUserDao) new ProxyFactory(target).getProxyInstance();
        // class $Proxy0   内存中动态生成的代理对象
        System.out.println(proxy.getClass());

        // 执行方法   【代理对象】
        proxy.save();
    }
}

1.3.Cglib代理
上面的静态代理和动态代理模式都是要求目标对象是实现一个接口的目标对象,但是有时候目标对象只是一个单独的对象,并没有实现任何的接口,这个时候就可以使用以目标对象子类的方式类实现代理,这种方法就叫做:Cglib代理