21、描述一下JVM 加载class文件的原理机制?
答：JVM 中类的装载是由类加载器（ClassLoader） 和它的子类来实现的，Java中的类加载器是一个重要的Java 运行时系统组件，它负责在运行时查找和装入类文件中的类。
补充：
1.由于Java的跨平台性，经过编译的Java源程序并不是一个可执行程序，而是一个或多个类文件。当Java程序需要使用某个类时，JVM会确保这个类已经被加载、连接(验证、准备和解析)和初始化。类的加载是指把类的.class文件中的数据读入到内存中，通常是创建一个字节数组读入.class文件，然后产生与所加载类对应的Class对象。加载完成后，Class对象还不完整，所以此时的类还不可用。当类被加载后就进入连接阶段，这一阶段包括验证、准备(为静态变量分配内存并设置默认的初始值)和解析(将符号引用替换为直接引用)三个步骤。最后JVM对类进行初始化，包括：1如果类存在直接的父类并且这个类还没有被初始化，那么就先初始化父类；2如果类中存在初始化语句，就依次执行这些初始化语句。
2.类的加载是由类加载器完成的，类加载器包括：根加载器（BootStrap）、扩展加载器（Extension）、系统加载器（System）和用户自定义类加载器（java.lang.ClassLoader的子类）。从JDK 1.2开始，类加载过程采取了父亲委托机制(PDM)。PDM更好的保证了Java平台的安全性，在该机制中，JVM自带的Bootstrap是根加载器，其他的加载器都有且仅有一个父类加载器。类的加载首先请求父类加载器加载，父类加载器无能为力时才由其子类加载器自行加载。JVM不会向Java程序提供对Bootstrap的引用。下面是关于几个类加载器的说明：
a)Bootstrap：一般用本地代码实现，负责加载JVM基础核心类库（rt.jar）；
b)Extension：从java.ext.dirs系统属性所指定的目录中加载类库，它的父加载器是Bootstrap；
c)System：又叫应用类加载器，其父类是Extension。它是应用最广泛的类加载器。它从环境变量classpath或者系统属性java.class.path所指定的目录中记载类，是用户自定义加载器的默认父加载器。
22、char 型变量中能不能存贮一个中文汉字?为什么?
答：char类型可以存储一个中文汉字，因为Java中使用的编码是Unicode（不选择任何特定的编码，直接使用字符在字符集中的编号，这是统一的唯一方法），一个char类型占2个字节（16bit），所以放一个中文是没问题的。
补充：使用Unicode意味着字符在JVM内部和外部有不同的表现形式，在JVM内部都是Unicode，当这个字符被从JVM内部转移到外部时（例如存入文件系统中），需要进行编码转换。所以Java中有字节流和字符流，以及在字符流和字节流之间进行转换的转换流，如InputStreamReader和OutputStreamReader，这两个类是字节流和字符流之间的适配器类，承担了编码转换的任务；对于C程序员来说，要完成这样的编码转换恐怕要依赖于union（联合体/共用体）共享内存的特征来实现了。
23、抽象类（abstract class）和接口（interface）有什么异同?
答：抽象类和接口都不能够实例化，但可以定义抽象类和接口类型的引用。一个类如果继承了某个抽象类或者实现了某个接口都需要对其中的抽象方法全部进行实现，否则该类仍然需要被声明为抽象类。接口比抽象类更加抽象，因为抽象类中可以定义构造器，可以有抽象方法和具体方法，而接口中不能定义构造器而且其中的方法全部都是抽象方法。抽象类中的成员可以是private、默认、protected、public的，而接口中的成员全都是public的。抽象类中可以定义成员变量，而接口中定义的成员变量实际上都是常量。有抽象方法的类必须被声明为抽象类，而抽象类未必要有抽象方法。
24、静态嵌套类(Static Nested Class)和内部类（Inner Class）的不同？
答：Static Nested Class是被声明为静态（static）的内部类，它可以不依赖于外部类实例被实例化。而通常的内部类需要在外部类实例化后才能实例化，其语法看起来挺诡异的，如下所示。
1 package com.lovo;
2
3 /**
4 * 扑克类（一副扑克）
5 何问起 hovertree.com
6 *
7 */
8 public class Poker {
9 private static String[] suites = {"黑桃", "红桃", "草花", "方块"};
10 private static int[] faces = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13};
11
12 private Card[] cards;
13
14 /**
15 * 构造器
16 *
17 */
18 public Poker() {
19 cards = new Card[52];
20 for(int i = 0; i < suites.length; i++) {
21 for(int j = 0; j < faces.length; j++) {
22 cards[i * 13 + j] = new Card(suites[i], faces[j]);
23 }
24 }
25 }
26
27 /**
28 * 洗牌 （随机乱序）
29 *
30 */
31 public void shuffle() {
32 for(int i = 0, len = cards.length; i < len; i++) {
33 int index = (int) (Math.random() * len);
34 Card temp = cards[index];
35 cards[index] = cards[i];
36 cards[i] = temp;
37 }
38 }
39
40 /**
41 * 发牌
42 * @param index 发牌的位置
43 *
44 */
45 public Card deal(int index) {
46 return cards[index];
47 }
48
49 /**
50 * 卡片类（一张扑克）
51 * [内部类]
52 * @author 骆昊
53 *
54 */
55 public class Card {
56 private String suite; // 花色
57 private int face; // 点数
58
59 public Card(String suite, int face) {
60 this.suite = suite;
61 this.face = face;
62 }
63
64 @Override
65 public String toString() {
66 String faceStr = "";
67 switch(face) {
68 case 1: faceStr = "A"; break;
69 case 11: faceStr = "J"; break;
70 case 12: faceStr = "Q"; break;
71 case 13: faceStr = "K"; break;
72 default: faceStr = String.valueOf(face);
73 }
74 return suite + faceStr;
75 }
76 }
77 }
测试类：
package com.lovo;
class PokerTest {
public static void main(String[] args) {
Poker poker = new Poker();
poker.shuffle(); // 洗牌
Poker.Card c1 = poker.deal(0); // 发第一张牌
// 对于非静态内部类Card
// 只有通过其外部类Poker对象才能创建Card对象
Poker.Card c2 = poker.new Card("红心", 1); // 自己创建一张牌
System.out.println(c1); // 洗牌后的第一张
System.out.println(c2); // 打印: 红心A
}
} //何问起 hovertree.com
25、Java 中会存在内存泄漏吗，请简单描述。
答：理论上Java因为有垃圾回收机制（GC）不会存在内存泄露问题（这也是Java被广泛使用于服务器端编程的一个重要原因）；然而在实际开发中，可能会存在无用但可达的对象，这些对象不能被GC回收也会发生内存泄露。一个例子就是Hibernate的Session（一级缓存）中的对象属于持久态，垃圾回收器是不会回收这些对象的，然而这些对象中可能存在无用的垃圾对象。下面的例子也展示了Java中发生内存泄露的情况：
1 package com.lovo;
2 //何问起 hovertree.com
3 import java.util.Arrays;
4 import java.util.EmptyStackException;
5
6 public class MyStack<T> {
7 private T[] elements;
8 private int size = 0;
9
10 private static final int INIT_CAPACITY = 16;
11
12 public MyStack() {
13 elements = (T[]) new Object[INIT_CAPACITY];
14 }
15
16 public void push(T elem) {
17 ensureCapacity();
18 elements[size++] = elem;
19 }
20
21 public T pop() {
22 if(size == 0)
23 throw new EmptyStackException();
24 return elements[--size];
25 }
26
27 private void ensureCapacity() {
28 if(elements.length == size) {
29 elements = Arrays.copyOf(elements, 2 * size + 1);
30 }
31 }
32 }
上面的代码实现了一个栈（先进后出（FILO））结构，乍看之下似乎没有什么明显的问题，它甚至可以通过你编写的各种单元测试。然而其中的pop方法却存在内存泄露的问题，当我们用pop方法弹出栈中的对象时，该对象不会被当作垃圾回收，即使使用栈的程序不再引用这些对象，因为栈内部维护着对这些对象的过期引用（obsolete reference）。在支持垃圾回收的语言中，内存泄露是很隐蔽的，这种内存泄露其实就是无意识的对象保持。如果一个对象引用被无意识的保留起来了，那么垃圾回收器不会处理这个对象，也不会处理该对象引用的其他对象，即使这样的对象只有少数几个，也可能会导致很多的对象被排除在垃圾回收之外，从而对性能造成重大影响，极端情况下会引发Disk Paging（物理内存与硬盘的虚拟内存交换数据），甚至造成OutOfMemoryError。
26、抽象的（abstract）方法是否可同时是静态的（static）,是否可同时是本地方法（native），是否可同时被synchronized修饰?
答：都不能。抽象方法需要子类重写，而静态的方法是无法被重写的，因此二者是矛盾的。本地方法是由本地代码（如C代码）实现的方法，而抽象方法是没有实现的，也是矛盾的。synchronized和方法的实现细节有关，抽象方法不涉及实现细节，因此也是相互矛盾的。
27、静态变量和实例变量的区别？
答：静态变量是被static修饰符修饰的变量，也称为类变量，它属于类，不属于类的任何一个对象，一个类不管创建多少个对象，静态变量在内存中有且仅有一个拷贝；实例变量必须依存于某一实例，需要先创建对象然后通过对象才能访问到它。静态变量可以实现让多个对象共享内存。在Java开发中，上下文类和工具类中通常会有大量的静态成员。
28、是否可以从一个静态（static）方法内部发出对非静态（non-static）方法的调用？
答：不可以，静态方法只能访问静态成员，因为非静态方法的调用要先创建对象，因此在调用静态方法时可能对象并没有被初始化。
29、如何实现对象克隆？
答：有两种方式：
1.实现Cloneable接口并重写Object类中的clone()方法；
2.实现Serializable接口，通过对象的序列化和反序列化实现克隆，可以实现真正的深度克隆，代码如下。
1 package com.lovo;
2
3 import java.io.ByteArrayInputStream;
4 import java.io.ByteArrayOutputStream;
5 import java.io.ObjectInputStream;
6 import java.io.ObjectOutputStream;
7
8 public class MyUtil {
9
10 private MyUtil() {
11 throw new AssertionError();
12 }
13
14 public static <T> T clone(T obj) throws Exception {
15 ByteArrayOutputStream bout = new ByteArrayOutputStream();
16 ObjectOutputStream oos = new ObjectOutputStream(bout);
17 oos.writeObject(obj);
18
19 ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
20 ObjectInputStream ois = new ObjectInputStream(bin);
21 return (T) ois.readObject();
22
23 // 说明：调用ByteArrayInputStream或ByteArrayOutputStream对象的close方法没有任何意义
24 // 这两个基于内存的流只要垃圾回收器清理对象就能够释放资源
25 }
26 } //何问起 hovertree.com
下面是测试代码：
1 package com.lovo;
2
3 import java.io.Serializable;
4
5 /**
6 * 人类
7 * @author 骆昊
8 *
9 */
10 class Person implements Serializable {
11 private static final long serialVersionUID = -9102017020286042305L;
12
13 private String name; // 姓名
14 private int age; // 年龄
15 private Car car; // 座驾
16
17 public Person(String name, int age, Car car) {
18 this.name = name;
19 this.age = age;
20 this.car = car;
21 }
22
23 public String getName() {
24 return name;
25 }
26
27 public void setName(String name) {
28 this.name = name;
29 }
30
31 public int getAge() {
32 return age;
33 }
34
35 public void setAge(int age) {
36 this.age = age;
37 }
38
39 public Car getCar() {
40 return car;
41 }
42
43 public void setCar(Car car) {
44 this.car = car;
45 }
46
47 @Override
48 public String toString() {
49 return "Person [name=" + name + ", age=" + age + ", car=" + car + "]";
50 }
51
52 }
53
54 /**
55 * 小汽车类
56 * @author 骆昊
57 *
58 */
59 class Car implements Serializable {
60 private static final long serialVersionUID = -5713945027627603702L;
61
62 private String brand; // 品牌
63 private int maxSpeed; // 最高时速
64
65 public Car(String brand, int maxSpeed) {
66 this.brand = brand;
67 this.maxSpeed = maxSpeed;
68 }
69
70 public String getBrand() {
71 return brand;
72 }
73
74 public void setBrand(String brand) {
75 this.brand = brand;
76 }
77
78 public int getMaxSpeed() {
79 return maxSpeed;
80 }
81
82 public void setMaxSpeed(int maxSpeed) {
83 this.maxSpeed = maxSpeed;
84 }
85
86 @Override
87 public String toString() {
88 return "Car [brand=" + brand + ", maxSpeed=" + maxSpeed + "]";
89 }
90
91 }
92 //何问起 hovertree.com
93 class CloneTest {
94
95 public static void main(String[] args) {
96 try {
97 Person p1 = new Person("Hao LUO", 33, new Car("Benz", 300));
98 Person p2 = MyUtil.clone(p1); // 深度克隆
99 p2.getCar().setBrand("BYD");
100 // 修改克隆的Person对象p2关联的汽车对象的品牌属性
101 // 原来的Person对象p1关联的汽车不会受到任何影响
102 // 因为在克隆Person对象时其关联的汽车对象也被克隆了
103 System.out.println(p1);
104 } catch (Exception e) {
105 e.printStackTrace();
106 }
107 }
108 }
注意：基于序列化和反序列化实现的克隆不仅仅是深度克隆，更重要的是通过泛型限定，可以检查出要克隆的对象是否支持序列化，这项检查是编译器完成的，不是在运行时抛出异常，这种是方案明显优于使用Object类的clone方法克隆对象。
30、GC 是什么？为什么要有GC？
答：GC是垃圾收集的意思，内存处理是编程人员容易出现问题的地方，忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃，Java提供的GC功能可以自动监测对象是否超过作用域从而达到自动回收内存的目的，Java语言没有提供释放已分配内存的显示操作方法。Java程序员不用担心内存管理，因为垃圾收集器会自动进行管理。要请求垃圾收集，可以调用下面的方法之一：System.gc() 或Runtime.getRuntime().gc() ，但JVM可以屏蔽掉显示的垃圾回收调用。
垃圾回收可以有效的防止内存泄露，有效的使用可以使用的内存。垃圾回收器通常是作为一个单独的低优先级的线程运行，不可预知的情况下对内存堆中已经死亡的或者长时间没有使用的对象进行清除和回收，程序员不能实时的调用垃圾回收器对某个对象或所有对象进行垃圾回收。在Java诞生初期，垃圾回收是Java最大的亮点之一，因为服务器端的编程需要有效的防止内存泄露问题，然而时过境迁，如今Java的垃圾回收机制已经成为被诟病的东西。移动智能终端用户通常觉得iOS的系统比Android系统有更好的用户体验，其中一个深层次的原因就在于Android系统中垃圾回收的不可预知性。
补充：垃圾回收机制有很多种，包括：分代复制垃圾回收、标记垃圾回收、增量垃圾回收等方式。标准的Java进程既有栈又有堆。栈保存了原始型局部变量，堆保存了要创建的对象。Java平台对堆内存回收和再利用的基本算法被称为标记和清除，但是Java对其进行了改进，采用“分代式垃圾收集”。这种方法会跟Java对象的生命周期将堆内存划分为不同的区域，在垃圾收集过程中，可能会将对象移动到不同区域：
-
伊甸园（Eden）：这是对象最初诞生的区域，并且对大多数对象来说，这里是它们唯一存在过的区域。
-
幸存者乐园（Survivor）：从伊甸园幸存下来的对象会被挪到这里。
-
终身颐养园（Tenured）：这是足够老的幸存对象的归宿。年轻代收集（Minor-GC）过程是不会触及这个地方的。当年轻代收集不能把对象放进终身颐养园时，就会触发一次完全收集（Major-GC），这里可能还会牵扯到压缩，以便为大对象腾出足够的空间。
与垃圾回收相关的JVM参数：
-
-Xms / -Xmx --- 堆的初始大小 / 堆的最大大小
-
-Xmn --- 堆中年轻代的大小
-
-XX:-DisableExplicitGC --- 让System.gc()不产生任何作用
-
-XX:+PrintGCDetail --- 打印GC的细节
-
-XX:+PrintGCDateStamps --- 打印GC操作的时间戳