Java面试题基础部分(5)

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）的内部类，它可以不依赖于外部类实例被实例化。而通常的内部类需要在外部类实例化后才能实例化，其语法看起来挺诡异的，如下所示。

[java] view plain copy

1. package com.lovo;

3. /**

4. * 扑克类（一副扑克）

5. * @author 骆昊

6. *

7. */

8. publicclass Poker {

9. privatestatic String[] suites = {"黑桃", "红桃", "草花", "方块"};

10. privatestaticint[] faces = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13};

12. private Card[] cards;

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. }

27. /**

28. * 洗牌 （随机乱序）

29. *

30. */

31. publicvoid 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. }

40. /**

41. * 发牌

42. * @param index 发牌的位置

43. *

44. */

45. public Card deal(int index) {

46. return cards[index];

47. }

49. /**

50. * 卡片类（一张扑克）

51. * [内部类]

52. * @author 骆昊

53. *

54. */

55. publicclass Card {

56. private String suite; // 花色

57. privateint face; // 点数

59. public Card(String suite, int face) {

60. this.suite = suite;

61. this.face = face;

62. }

64. @Override

65. public String toString() {

66. String faceStr = "";

67. switch(face) {

68. case1: faceStr = "A"; break;

69. case11: faceStr = "J"; break;

70. case12: faceStr = "Q"; break;

71. case13: faceStr = "K"; break;

72. default: faceStr = String.valueOf(face);

73. }

74. return suite + faceStr;

75. }

76. }

77. }

测试类：

[java] view plain copy

1. package com.lovo;

3. class PokerTest {

5. publicstaticvoid main(String[] args) {

6. Poker poker = new Poker();

7. poker.shuffle(); // 洗牌

8. Poker.Card c1 = poker.deal(0); // 发第一张牌

9. // 对于非静态内部类Card

10. // 只有通过其外部类Poker对象才能创建Card对象

11. Poker.Card c2 = poker.new Card("红心", 1); // 自己创建一张牌

13. System.out.println(c1); // 洗牌后的第一张

14. System.out.println(c2); // 打印: 红心A

15. }

16. }

25、Java 中会存在内存泄漏吗，请简单描述。

答：理论上Java因为有垃圾回收机制（GC）不会存在内存泄露问题（这也是Java被广泛使用于服务器端编程的一个重要原因）；然而在实际开发中，可能会存在无用但可达的对象，这些对象不能被GC回收也会发生内存泄露。一个例子就是Hibernate的Session（一级缓存）中的对象属于持久态，垃圾回收器是不会回收这些对象的，然而这些对象中可能存在无用的垃圾对象。下面的例子也展示了Java中发生内存泄露的情况：

[java] view plain copy

1. package com.lovo;

3. import java.util.Arrays;

4. import java.util.EmptyStackException;

6. publicclass MyStack<T> {

7. private T[] elements;

8. privateint size = 0;

10. privatestaticfinalint INIT_CAPACITY = 16;

12. public MyStack() {

13. elements = (T[]) new Object[INIT_CAPACITY];

14. }

16. publicvoid push(T elem) {

17. ensureCapacity();

18. elements[size++] = elem;

19. }

21. public T pop() {

22. if(size == 0)

23. thrownew EmptyStackException();

24. return elements[--size];

25. }

27. privatevoid 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。