Java面试常见知识点总结(一)

1.sleep()和wait()：

Java中的多线程是一种抢占式的机制，而不是分时机制。抢占式的机制是有多个线程处于可运行状态，但是只有一个线程在运行。
  ● 共同点：
   (1) 他们都是在多线程的环境下，都可以在程序的调用处阻塞指定的毫秒数，并返回。
   (2) wait()和sleep()都可以通过interrupt()方法 打断线程的暂停状态 ，从而使线程立刻抛出InterruptedException。
       如果线程A希望立即结束线程B，则可以对线程B对应的Thread实例调用interrupt方法。如果此刻线程B正在wait/sleep/join，则线程B会立刻抛出InterruptedException，在catch() {} 中直接return即可安全地结束线程。
      需要注意的是，InterruptedException是线程自己从内部抛出的，并不是interrupt()方法抛出的。对某一线程调用 interrupt()时，如果该线程正在执行普通的代码，那么该线程根本就不会抛出InterruptedException。但是，一旦该线程进入到 wait()/sleep()/join()后，就会立刻抛出InterruptedException 。
   ● 不同点：
   (1) 每个对象都有一个锁来控制同步访问。Synchronized关键字可以和对象的锁交互，来实现线程的同步。
      sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。
   (2) wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用
   (3) sleep必须捕获异常，而wait，notify和notifyAll不需要捕获异常
   (4) sleep是线程类（Thread）的方法，导致此线程暂停执行指定时间，给执行机会给其他线程，但是监控状态依然保持，到时后会自动恢复。调用sleep不会释放对象锁。
   (5) wait是Object类的方法，对此对象调用wait方法导致本线程放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象发出notify方法（或notifyAll）后本线程才进入对象锁定池准备获得对象锁进入运行状态。

2.截止JDK1.8版本，java并发框架支持锁包括:

1) 自旋锁, 自旋，jvm默认是10次吧，有jvm自己控制。for去争取锁.
  2) 阻塞锁 被阻塞的线程，不会争夺锁.
  3) 可重入锁 多次进入改锁的域.
  4) 读写锁.
  5) 互斥锁 锁本身就是互斥的.
  6) 悲观锁 不相信，这里会是安全的，必须全部上锁.
  7) 乐观锁 相信，这里是安全的.
  8) 公平锁 有优先级的锁.
  9) 非公平锁 无优先级的锁.
  10) 偏向锁 无竞争不锁，有竞争挂起，转为轻量锁.
  11) 对象锁 锁住对象.
  12) 线程锁.
  13) 锁粗化 多锁变成一个，自己处理.
  14) 轻量级锁 CAS实现.
  15) 锁消除 偏向锁就是锁消除的一种.
  16) 锁膨胀 jvm实现，锁粗化.
  17) 信号量 使用阻塞锁 实现的一种策略.
  18) 排它锁：X锁，若事务T对数据对象A加上X锁，则只允许T读取和修改A，其他任何事务都不能再对A加任何类型的锁，直到T释放A上的锁。这就保证了其他事务在T释放A上的锁之前不能再读取和修改A。

3.结构型模式:

结构型模式是描述如何将类对象结合在一起，形成一个更大的结构，结构模式描述两种不同的东西：类与类的实例。故可以分为类结构模式和对象结构模式。
   在GoF设计模式中，结构型模式有：
  1) 适配器模式 Adapter
  适配器模式是将一个类的接口转换成客户希望的另外一个接口。适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。
  两个成熟的类需要通信，但是接口不同，由于开闭原则，我们不能去修改这两个类的接口，所以就需要一个适配器来完成衔接过程。
  2) 桥接模式 Bridge
  桥接模式将抽象部分与它的实现部分分离，是它们都可以独立地变化。它很好的支持了开闭原则和组合锯和复用原则。实现系统可能有多角度分类，每一种分类都有可能变化，那么就把这些多角度分离出来让他们独立变化，减少他们之间的耦合。
  3) 组合模式 Composite
  组合模式将对象组合成树形结构以表示部分-整体的层次结构，组合模式使得用户对单个对象和组合对象的使用具有一致性。
  4) 装饰模式 Decorator
   装饰模式动态地给一个对象添加一些额外的职责，就增加功能来说，它比生成子类更灵活。也可以这样说，装饰模式把复杂类中的核心职责和装饰功能区分开了，这样既简化了复杂类，有去除了相关类中重复的装饰逻辑。 装饰模式没有通过继承原有类来扩展功能，但却达到了一样的目的，而且比继承更加灵活，所以可以说装饰模式是继承关系的一种替代方案。
  5) 外观模式 Facade
  外观模式为子系统中的一组接口提供了同意的界面，外观模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。
  外观模式中，客户对各个具体的子系统是不了解的，所以对这些子系统进行了封装，对外只提供了用户所明白的单一而简单的接口，用户直接使用这个接口就可以完成操作，而不用去理睬具体的过程，而且子系统的变化不会影响到用户，这样就做到了信息隐蔽。
  6) 享元模式 Flyweight
  享元模式为运用共享技术有效的支持大量细粒度的对象。因为它可以通过共享大幅度地减少单个实例的数目，避免了大量非常相似类的开销。
  享元模式是一个类别的多个对象共享这个类别的一个对象，而不是各自再实例化各自的对象。这样就达到了节省内存的目的。
  7) 代理模式 Proxy
  为其他对象提供一种代理，并由代理对象控制对原对象的引用，以间接控制对原对象的访问。

4.Statement、PreparedStatement和CallableStatement的异同:

1) Statement继承自Wrapper、PreparedStatement继承自Statement、CallableStatement继承自PreparedStatement。

2) Statement接口提供了执行语句和获取结果的基本方法；
        PreparedStatement接口添加了处理 IN 参数的方法；
        CallableStatement接口添加了处理 OUT 参数的方法。
    3) a.Statement: 普通的不带参的查询SQL; 支持批量更新, 批量删除;
        b.PreparedStatement: 可变参数的SQL, 编译一次, 执行多次, 效率高;
           安全性好，有效防止Sql注入等问题;
           支持批量更新, 批量删除;
        c.CallableStatement: 继承自PreparedStatement, 支持带参数的SQL操作;
           支持调用存储过程, 提供了对输出和输入/输出参数(INOUT)的支持;
         Statement每次执行sql语句，数据库都要执行sql语句的编译， 最好用于仅执行一次查询并返回结果的情形，效率高于PreparedStatement。
    4) PreparedStatement是预编译的，使用PreparedStatement有几个好处::

(1) 在执行可变参数的一条SQL时，PreparedStatement比Statement的效率高，因为DBMS预编译一条SQL当然会比多次编译一条SQL的效率要高。
      (2) 安全性好，有效防止Sql注入等问题。
      (3) 对于多次重复执行的语句，使用PreparedStament效率会更高一点，并且在这种情况下也比较适合使用batch；
      (4) 代码的可读性和可维护性。

5.对于JVM内存配置参数：

-Xmx10240m -Xms10240m -Xmn5120m -XXSurvivorRatio=3

其最小内存值和Survivor区总大小分别是（10240m，2048m）.

-Xmx：最大堆大小.
   -Xms：初始堆大小.
   -Xmn : 年轻代大小.
   -XXSurvivorRatio：年轻代中Eden区与Survivor区的大小比值.
   -Xms初始堆大小即最小内存值, 为10240m.
    XXSurvivorRatio=3，即Eden：FromSurvivor：ToSurvivor=3:1:1;所以Survivor一共是2048m.

6.类加载过程:

类从被加载到虚拟机内存中开始，到卸载出内存为止，它的整个生命周期包括：加载（Loading）、验证（Verification）、准备(Preparation)、解析(Resolution)、初始化(Initialization)、使用(Using)和卸载(Unloading)7个阶段。其中准备、验证、解析3个部分统称为连接（Linking）。如图所示:

这里写图片描述:

加载、验证、准备、初始化和卸载这5个阶段的顺序是确定的，类的加载过程必须按照这种顺序按部就班地开始，而解析阶段则不一定：它在某些情况下可以在初始化阶段之后再开始，这是为了支持Java语言的运行时绑定（也称为动态绑定或晚期绑定）。以下陈述的内容都已HotSpot为基准。

● 加载

在加载阶段（可以参考java.lang.ClassLoader的loadClass()方法），虚拟机需要完成以下3件事情：

1) 通过一个类的全限定名来获取定义此类的二进制字节流（并没有指明要从一个Class文件中获取，可以从其他渠道，譬如：网络、动态生成、数据库等）；
   2) 将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构；
   3) 在内存中生成一个代表这个类的java.lang.Class对象，作为方法区这个类的各种数据的访问入口；
   加载阶段和连接阶段（Linking）的部分内容（如一部分字节码文件格式验证动作）是交叉进行的，加载阶段尚未完成，连接阶段可能已经开始，但这些夹在加载阶段之中进行的动作，仍然属于连接阶段的内容，这两个阶段的开始时间仍然保持着固定的先后顺序。

● 验证

验证是连接阶段的第一步，这一阶段的目的是为了确保Class文件的字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身的安全。
    验证阶段大致会完成4个阶段的检验动作：

1) 文件格式验证：验证字节流是否符合Class文件格式的规范；例如：是否以魔术0xCAFEBABE开头、主次版本号是否在当前虚拟机的处理范围之内、常量池中的常量是否有不被支持的类型。
     2) 元数据验证：对字节码描述的信息进行语义分析（注意：对比javac编译阶段的语义分析），以保证其描述的信息符合Java语言规范的要求；例如：这个类是否有父类，除了java.lang.Object之外。
     3) 字节码验证：通过数据流和控制流分析，确定程序语义是合法的、符合逻辑的。
     4) 符号引用验证：确保解析动作能正确执行。
    验证阶段是非常重要的，但不是必须的，它对程序运行期没有影响，如果所引用的类经过反复验证，那么可以考虑采用-Xverifynone参数来关闭大部分的类验证措施，以缩短虚拟机类加载的时间。

● 准备

准备阶段是正式为类变量分配内存并设置类变量初始值的阶段，这些变量所使用的内存都将在方法区中进行分配。这时候进行内存分配的仅包括类变量（被static修饰的变量），而不包括实例变量，实例变量将会在对象实例化时随着对象一起分配在堆中。其次，这里所说的初始值“通常情况”下是数据类型的零值，假设一个类变量的定义为：

public static int value=123;

那变量value在准备阶段过后的初始值为0而不是123. 因为这时候尚未开始执行任何java方法，而把value赋值为123的putstatic指令是程序被编译后，存放于类构造器()方法之中，所以把value赋值为123的动作将在初始化阶段才会执行。
    至于“特殊情况”是指：public static final int value=123，即当类字段的字段属性是ConstantValue时，会在准备阶段初始化为指定的值，所以标注为final之后，value的值在准备阶段初始化为123而非0.

● 解析

解析阶段是虚拟机将常量池内的符号引用替换为直接引用的过程。解析动作主要针对类或接口、字段、类方法、接口方法、方法类型、方法句柄和调用点限定符7类符号引用进行。

● 初始化

类初始化阶段是类加载过程的最后一步，到了初始化阶段，才真正开始执行类中定义的java程序代码。在准备极端，变量已经付过一次系统要求的初始值，而在初始化阶段，则根据程序猿通过程序制定的主管计划去初始化类变量和其他资源，或者说：初始化阶段是执行类构造器<clinit>()方法的过程.
   <clinit>()方法是由编译器自动收集类中的所有类变量的赋值动作和静态语句块static{}中的语句合并产生的，编译器收集的顺序是由语句在源文件中出现的顺序所决定的，静态语句块只能访问到定义在静态语句块之前的变量，定义在它之后的变量，在前面的静态语句块可以赋值，但是不能访问。如下：

public class Test
{
    static
    {
        i=0;
        System.out.println(i);//这句编译器会报错：Cannot reference a field before it is defined（非法向前应用）
    }
    static int i=1;
}

更多介绍，请移步：http://blog.csdn.net/u013256816/article/details/50829596

7.JVM内存:

大多数 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上）的原因。

方法区在JVM中也是一个非常重要的区域，它与堆一样，是被线程共享的区域。 在方法区中，存储了每个类的信息（包括类的名称、方法信息、字段信息）、静态变量、常量以及编译器编译后的代码等。

程序计数器是Java虚拟机中唯一一个没有规定任何内存溢出OutOfMemoryError的内存区域，Java虚拟机中的程序计数器指向正在执行的字节码地址，而不是下一条。

8.Java垃圾回收算法：

   两个最基本的Java垃圾回收算法：复制算法和标记清理算法。

复制算法：两个区域A和B，初始对象在A，继续存活的对象被转移到B。此为新生代最常用的算法。
   标记清理：一块区域，标记要回收的对象，然后回收，一定会出现碎片，那么引出：标记-整理算法：多了碎片整理，整理出更大的内存放更大的对象。
   两个概念：新生代和年老代。
      新生代：初始对象，生命周期短的。
      永久代：长时间存在的对象。
   整个java的垃圾回收是新生代和年老代的协作，这种叫做分代回收。
   P.S：Serial New收集器是针对新生代的收集器，采用的是复制算法。
           Parallel New（并行）收集器，新生代采用复制算法，老年代采用标记整理。
           Parallel Scavenge（并行）收集器，针对新生代，采用复制收集算法。
           Serial Old（串行）收集器，新生代采用复制，老年代采用标记清理。
           Parallel Old（并行）收集器，针对老年代，标记整理。
           CMS收集器，基于标记清理。
           G1收集器：整体上是基于标记清理，局部采用复制。
   综上：新生代基本采用复制算法，老年代采用标记整理算法。cms采用标记清理。

9.重写（Overriding）和重载（Overloading）:

重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。

如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被“屏蔽”了。

如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。

Overloaded的方法是可以改变返回值的类型。

10.优化Hibernate所鼓励的7大措施:

1) 尽量使用many-to-one，避免使用单项one-to-many;
   2) 灵活使用单向one-to-many;
   3) 不用一对一，使用多对一代替一对一;
   4) 配置对象缓存，不使用集合缓存;
   5) 一对多使用Bag 多对一使用Set;
   6) 继承使用显示多态 HQL:from object polymorphism="exlicit" 避免查出所有对象;
   7) 消除大表，使用二级缓存。