写在前面

⭐️在无数次的复习巩固中，我逐渐意识到一个问题：面对同样的面试题目，不同的资料来源往往给出了五花八门的解释，这不仅增加了学习的难度，还容易导致概念上的混淆。特别是当这些信息来自不同博主的文章或是视频教程时，它们之间可能存在的差异性使得原本清晰的概念变得模糊不清。更糟糕的是，许多总结性的面试经验谈要么过于繁复难以记忆，要么就是过于简略，对关键知识点一带而过，常常在提及某项技术时，又引出了更多未经解释的相关术语和实例，例如，在讨论ReentrantLock时，经常会提到这是一个可重入锁，并存在公平与非公平两种实现方式，但对于这两种锁机制背后的原理以及使用场景往往语焉不详。

⭐️正是基于这样的困扰与思考，我决定亲自上阵，撰写一份与众不同的面试指南。这份指南不仅仅是对现有资源的简单汇总，更重要的是，它融入了我的个人理解和解读。我力求回归技术书籍本身，以一种层层递进的方式剖析复杂的技术概念，让那些看似枯燥乏味的知识点变得生动起来，并在我的脑海中构建起一套完整的知识体系。我希望通过这种方式，不仅能帮助自己在未来的技术面试中更加从容不迫，也能为同行们提供一份有价值的参考资料，使大家都能在这个过程中有所收获。

JavaSE相关面试题

面试官： 面向对象和面向过程的区别

候选人：

• ⾯向过程 ：⾯向过程性能⽐⾯向对象⾼。 ⽐如单⽚机、嵌⼊式开发、Linux/Unix 等⼀般采⽤⾯向过程开发。但是，⾯向过程没有⾯向对象易维护、易复⽤、易扩展。

• ⾯向对象 ：⾯向对象易维护、易复⽤、易扩展。 因为⾯向对象有封装、继承、多态性的特性，所以可以设计出低耦合的系统，使系统更加灵活、更加易于维护。但是，⾯向对象性能⽐⾯向过程低。

拓展：为什么⾯向过程性能⽐⾯向对象⾼？

⾯向过程也需要分配内存，计算内存偏移量，Java 性能差的主要原因并不是因为它是⾯向对象语⾔，⽽是 Java 是半编译语⾔，最终的执⾏代码并不是可以直接被 CPU 执⾏的⼆进制机械码。

⽽⾯向过程语⾔⼤多都是直接编译成机械码在电脑上执⾏，并且其它⼀些⾯向过程的脚本语⾔性能也并不⼀定⽐ Java 好。

面试官：Java语⾔有哪些特点?

候选人：

1. 简单易学（Java语言的语法与C语言和C++语言很接近）；

2. ⾯向对象（封装，继承，多态）；

3. 跨平台性（ Java 虚拟机实现平台⽆关性）；

4. 健壮性（Java语言的强类型机制、异常处理、垃圾的自动收集等）；

5. 安全性；

6. ⽀持多线程（ C++ 语⾔没有内置的多线程机制，因此必须调⽤操作系统的多线程功能来进⾏多线程程序设计，⽽ Java 语⾔却提供了多线程⽀持）；

7. ⽀持⽹络编程（ Java 语⾔诞⽣本身就是为简化⽹络编程设计的）；

8. 编译与解释并存

面试官：说说JVM 、 JDK 和 JRE的区别？

候选人：

• Java Virtual Machine（JVM） 是运⾏ Java 字节码的虚拟机，Java程序需要运行在虚拟机上，不同的平台有自己的虚拟机，因此Java语言可以实现跨平台。

拓展：什么是字节码?采⽤字节码的好处是什么?

在 Java 中，JVM 可以理解的代码就叫做 （即扩展名为 .class 的⽂件），它不⾯向任何特定的处理器，只⾯向虚拟机。Java 语⾔通过字节码的⽅式，在⼀定程度上解决了传统解释型语⾔执⾏效率低的问题，同时⼜保留了解释型语⾔可移植的特点。

• Java Runtime Environment（JRE） 包括Java虚拟机和Java程序所需的核心类库等。核心类库主要是java.lang包：包含了运行Java程序必不可少的系统类，如基本数据类型、基本数学函数、字符串处理、线程、异常处理类等。
• Java Development Kit（JDK） 是提供给Java开发人员使用的，其中包含了Java的开发工具，也包括了JRE。所以安装了JDK，就无需再单独安装JRE了。其中的开发工具：编译工具(javac.exe)，打包工具(jar.exe)等。

面试官：Java 程序从源代码到运⾏分为哪几步？

候选人： Java程序从源代码到运⾏⼀般有下⾯3步：

我们需要格外注意的是 .class->机器码 这⼀步。在这⼀步 JVM 类加载器⾸先加载字节码⽂件，然后通过解释器逐⾏解释执⾏，这种⽅式的执⾏速度会相对⽐慢。⽽且，有些⽅法和代码块是经常需要被调⽤的(也就是所谓的热点代码)，所以后⾯引进了 JIT 编译器，⽽ JIT 属于运⾏时编译。当 JIT 编译器完成第⼀次编译后，其会将字节码对应的机器码保存下来，下次可以直接使⽤。⽽我们知道，机器码的运⾏效率肯定是⾼于 Java 解释器的。这也解释了我们为什么经常会说 Java 是编译与解释共存的语⾔。

面试官：什么是跨平台性？原理是什么？

候选人：

所谓跨平台性，是指 java 语言编写的程序，一次编译后，可以在多个系统平台上运行。

实现原理：Java程序是通过java虚拟机在系统平台上运行的，只要该系统可以安装相应的java虚拟机，该系统就可以运行java程序。

面试官：Java和C++的区别

候选人：

• 都是面向对象的语言，都支持封装、继承和多态。
• Java不提供指针来直接访问内存，程序内存更加安全。
• Java的类是单继承的，C++支持多重继承；虽然Java的类不可以多继承，但是接口可以有多个实现类。
• Java有自动内存管理机制，不需要程序员手动释放无用内存。
• 在 C 语⾔中，字符串或字符数组最后都会有⼀个额外的字符‘\0’来表示结束。但是，Java 语⾔中没有结束符这⼀概念。

深度思考：

在C语言中，字符串是以空字符（‘\0’）结尾的字符数组。这种设计的好处是简单直接，但缺点是在访问字符串时每次都需要检查空字符来确定字符串的长度，这可能会导致额外的计算开销。在Java中，字符串是一个类（String），它包含了字符串的值以及其长度信息。这种设计使得字符串的长度可以在创建时确定，并且可以通过内置的方法（如length()）轻松获取。这种方法提高了效率，减少了因字符串处理不当而导致的安全隐患。

面试官： 字符型常量和字符串常量的区别?

候选人：

1. 形式上: 字符型常量是单引号引起的⼀个字符; 字符串常量是双引号引起的若⼲个字符

2. 含义上: 字符型常量相当于⼀个整型值( ASCII 值),可以参加表达式运算; 字符串常量代表⼀个地址值(该字符串在内存中存放位置)

3. 占内存⼤⼩：字符型常量只占 2 个字节; 字符串常量占若⼲个字节 (注意： char 在 Java 中占两个字节)

面试官： 重载和重写的区别

候选人：

重载（编译时多态）是同一个类中方法之间的关系，是水平关系。

重写（运行时多态）是子类和父类之间的关系，是垂直关系。

面试官：面向对象的特征有哪些方面？

候选人：

封装：隐藏对象的属性和实现细节，仅对外提供公共访问方式，将变化隔离，便于使用，提高复用性和安全性。

继承：继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类。通过使用继承可以提高代码复用性。继承是多态的前提。

关于继承如下 3 点请记住：

1. 子类拥有父类非 private 的属性和方法。
2. 子类可以拥有自己属性和方法，即子类可以对父类进行扩展。
3. 子类可以用自己的方式实现父类的方法。

多态：父类或接口定义的引用变量可以指向子类或具体实现类的实例对象。提高了程序的拓展性。

在Java中有两种形式可以实现多态：继承（多个子类对同一方法的重写）和接口（实现接口并覆盖接口中同一方法）。

面试官： String 、StringBuffer 和 StringBuilder 的区别是什么?（重要）

候选人：

可变性：

• String对象是不可变类，也就是说String对象一旦被创建，其值将不能被改变。String 类中使⽤ final 关键字修饰字符数组来保存字符串， private final char[] value ，所以 String 对象是不可变的。

拓展：在 Java 9 之后，String 类的实现改⽤ byte 数组存储字符串

private final byte[] value

• StringBuilder 与 StringBuffer 都继承⾃ AbstractStringBuilder 类，在 AbstractStringBuilder 中

  也是使⽤字符数组保存字符串 char[] value 但是没有⽤ final 关键字修饰，所以这两种对象都是可

  变的。

  java">abstract class AbstractStringBuilder implements Appendable, CharSequence {
   /**
   * The value is used for character storage.
   */
   char[] value;
   /**
   * The count is the number of characters used.
   */
   int count;
   AbstractStringBuilder(int capacity) {
   	value = new char[capacity];
   }
  

线程安全性：

• String 中的对象是不可变的，也就可以理解为常量，线程安全。
• StringBuffer 对AbstractStringBuilder⽅法加了同步锁，所以是线程安全的。StringBuilder 并没有对⽅法加同步锁。

性能：

• 每次对 String 类型进⾏改变的时候，都会⽣成⼀个新的 String 对象，然后将指针指向新的 String对象。

• StringBuffer 每次都会对对象本身进⾏操作，⽽不是⽣成新的对象并改变对象引⽤。

• 相同情况下使⽤ StringBuilder 相⽐使⽤ StringBuffer 仅能获得 10%~15% 左右的性能提升，但却要冒多线程不安全的⻛险。(如下)

实例化/初始化：

《Java程序员面试笔试宝典》第二版 1.18节

当实例化String的时候，可以利用构造方法（String s1 = new String(“world”)）的方式来对其初始化，也可以使用赋值（String s1 = “Hello”）的方式来初始化，而StringBuffer和StringBuilder只能使用构造方法（StringBuffer s = new StringBuffer(“world”)）的方式来初始化。

String 字符串修改实现的原理为:当用 String 类型来对字符串进行修改时，其实现方法是首先创建一个 StringBuilder，然后调用 StingBuilder 的append 方法，最后调用 StingBuilder 的 toString方法把结果返回。举例如下:

java">String s = "Hello";
s += "World";

以上代码等价于下述代码:

java">String s = "Hello";
StringBuilder sb = new StringBuilder(s);
s.append("World");
s = sb.toString();

由此可以看出，上述过程比使用 StingBuilder 多了一些附加的操作，同时也生成了一些临时的对象，导致程序的执行效率降低。

对于三者使⽤的总结：

1. 操作少量的数据: 适⽤ String
2. 单线程操作字符串缓冲区下操作⼤量数据: 适⽤ StringBuilder
3. 多线程操作字符串缓冲区下操作⼤量数据: 适⽤ StringBuffer

面试官：接⼝和抽象类的区别是什么？

候选人：

参数	抽象类（从属关系is-a）	接口（特定功能的实现has-a）
声明	抽象类使用abstract关键字声明	接口使用interface关键字声明
实现	子类使用extends关键字来继承抽象类	子类使用implements关键字来实现接口
构造器	抽象类可以有构造器	接口不能有构造器
访问修饰符	抽象类中的方法可以是任意访问修饰符	接口方法默认修饰符是public。并且不允许定义为private 或者 protected
多继承	一个类最多只能继承一个抽象类	一个类可以实现多个接口
字段声明	抽象类的字段声明可以是任意的	接口的字段默认都是 static 和 final 的

面试官：成员变量与局部变量的区别有哪些？

候选人：

属性	成员变量	局部变量
作用域	针对整个类有效	只在某个范围内有效，通常在方法或语句体内
存储位置	随着对象的创建而存在，存储在堆内存中	在方法被调用或语句被执行的时候存在，存储在栈内存中
生命周期	随着对象的创建而存在，随着对象的消失而消失	当方法调用完，或者语句结束后，就自动释放
初始值	有默认初始值，如数字类型为0，布尔类型为false，引用类型为null	没有默认初始值，使用前必须显式赋值
使用原则	就近原则（首先在局部范围找，有就使用；接着在成员位置找）	就近原则

面试官： == 与 equals(重要)

候选人：

== : 它的作⽤是判断两个对象的地址是不是相等。(基本数据类型 == ⽐的是值，引⽤数据类型 == ⽐的是内存地址)。

equals() : 它的作⽤也是判断两个对象是否相等。但它⼀般有两种使⽤情况：

• 情况 1：类没有覆盖 equals() ⽅法。则通过 equals() ⽐较该类的两个对象时，等价于通过“==”⽐这两个对象地址。

• 情况 2：类覆盖了 equals() ⽅法。⼀般我们都覆盖 equals() ⽅法来⽐两个对象的内容是否相等；若它们的内容相等，则返回 true 。

java">public class test1 {
    public static void main(String[] args) {
        String a = new String("ab"); // a 为一个引用
        String b = new String("ab"); // b为另一个引用,对象的内容一样
        String aa = "ab"; // 放在常量池中
        String bb = "ab"; // 从常量池中查找
        if (aa == bb) // true
            System.out.println("aa==bb");
        if (a == b) // false，非同一对象
            System.out.println("a==b");
        if (a.equals(b)) // true
            System.out.println("aEQb");
        if (42 == 42.0) { // true
            System.out.println("true");
        }
    }
}

面试官：你重写过 hashcode 和 equals 么，为什么重写equals时必须重写hashCode方法？（重要）

候选人：

1）hashCode()介绍:

hashCode() 的作⽤是获取哈希码，也称为散列码；它实际上是返回⼀个 int 整数。这个哈希码的作⽤是确定该对象在哈希表中的索引位置。 hashCode() 定义在 JDK 的 Object 类中，这就意味着 Java 中的任何类都包含有 hashCode() 函数。

java">public native int hashCode();

2）以“HashSet 如何检查重复”为例子来说明为什么要有 hashCode：

当你把对象加入 HashSet 时，HashSet 会先计算对象的 hashcode 值来判断对象加入的位置，同时也会与其他已经加入的对象的 hashcode 值作比较，如果没有相符的hashcode，HashSet会假设对象没有重复出现。但是如果发现有相同 hashcode 值的对象，这时会调用 equals()方法来检查 hashcode 相等的对象是否真的相同。如果两者相同，HashSet 就不会让其加入操作成功。如果不同的话，就会重新散列到其他位置。（摘自《Head first java》第二版）。这样我们就大大减少了 equals 的次数，相应就大大提高了执行速度。

3）为什么重写equals 时必须重写 hashCode ⽅法？

如果两个对象相等，则 hashcode ⼀定也是相同的。两个对象相等,对两个对象分别调⽤ equals⽅法都返回 true。但是，两个对象有相同的 hashcode 值，它们也不⼀定是相等的 。因此，equals ⽅法被覆盖过，则 hashCode ⽅法也必须被覆盖。

面试官：值传递和引用传递有什么区别？（重要）

候选人： Java程序设计语言对对象采用的不是引用调用，实际上，对象引用是按值传递的。（《Java 核⼼技术 卷Ⅰ基础知识》第⼗版 4.5 节）

• 值传递：指的是在方法调用时，传递的参数是按值的拷贝传递，传递的是值的拷贝，也就是说传递后就互不相关了。Java程序设计语言总是采用按值调用。也就是说，方法得到的是所有参数值的一个拷贝，也就是说，方法不能修改传递给它的任何参数变量的内容。

java">public static void main(String[] args) {
    int num1 = 10;
    int num2 = 20;

    swap(num1, num2);

    System.out.println("num1 = " + num1);
    System.out.println("num2 = " + num2);
}

public static void swap(int a, int b) {
    int temp = a;
    a = b;
    b = temp;

    System.out.println("a = " + a);
    System.out.println("b = " + b);
}

// 输出结果
a = 20
b = 10
num1 = 10
num2 = 20

解析：在swap方法中，a、b的值进行交换，并不会影响到 num1、num2。因为，a、b中的值，只是从 num1、num2 的复制过来的。也就是说，a、b相当于num1、num2 的副本，副本的内容无论怎么修改，都不会影响到原件本身。

• 引用传递：指的是在方法调用时，传递的参数是按引用进行传递，其实传递的引用的地址，也就是变量所对应的内存空间的地址。传递的是值的引用，也就是说传递前和传递后都指向同一个引用（也就是同一个内存空间）。

java">    public static void main(String[] args) {
        int[] arr = { 1, 2, 3, 4, 5 };
        System.out.println(arr[0]);
        change(arr);
        System.out.println(arr[0]);
    }

    public static void change(int[] array) {
        // 将数组的第一个元素变为0
        array[0] = 0;
    }

// 输出结果
1
0

解析：array 被初始化 arr 的拷贝也就是一个对象的引用，也就是说 array 和 arr 指向的时同一个数组对象。 因此，外部对引用对象的改变会反映到所对应的对象上。

很多程序设计语言（特别是，C++和Pascal)提供了两种参数传递的方式：值调用和引用调用。有些程序员（甚至本书的作者）认为Java程序设计语言对对象采用的是引用调用，实际上，这种理解是不对的。由于这种误解具有一定的普遍性，所以下面给出一个反例来详细地阐述一下这个问题。

java">public class Test {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Student s1 = new Student("小张");
        Student s2 = new Student("小李");
        Test.swap(s1, s2);
        System.out.println("s1:" + s1.getName());
        System.out.println("s2:" + s2.getName());
    }

    public static void swap(Student x, Student y) {
        Student temp = x;
        x = y;
        y = temp;
        System.out.println("x:" + x.getName());
        System.out.println("y:" + y.getName());
    }
}

// 输出结果
x:小李
y:小张
s1:小张
s2:小李

解析：通过上面两张图可以很清晰的看出： 方法并没有改变存储在变量 s1 和 s2 中的对象引用。swap方法的参数x和y被初始化为两个对象引用的拷贝，这个方法交换的是这两个拷贝。

面试官：final 、finally 、finalize区别

候选人：

• final可以修饰类、变量、方法。修饰类表示该类不能被继承、修饰方法表示该方法不能被重写、修饰变量表
  示该变量是一个常量不能被重新赋值。（如果是基本数据类型的变量，则其数值⼀旦在初始化之后便不能更改；如果是引⽤类型的变量，则在对其初始化之后便不能再让其指向另⼀个对象。）
• finally一般作用在try-catch代码块中，在处理异常的时候，通常我们将一定要执行的代码方法finally代码块
  中，表示不管是否出现异常，该代码块都会执行，一般用来存放一些关闭资源的代码。
• finalize是一个方法，属于Object类的一个方法，而Object类是所有类的父类，该方法一般由垃圾回收器来调
  用，当我们调用System.gc() 方法的时候，由垃圾回收器调用finalize()，回收垃圾。

面试官：this与super的区别

候选人：

• super()和this()类似,区别是，super()在子类中调用父类的构造方法，this()在本类内调用本类的其它构造方法。
• super()和this()均需放在构造方法内第一行。
• 可以用this调用一个构造器，但却不能调用两个。
• this和super不能同时出现在一个构造函数里面，因为this必然会调用其它的构造函数，其它的构造函数必然也会有super语句的存在，所以在同一个构造函数里面有相同的语句，就失去了语句的意义，编译器也不会通过。
• this()和super()都指的是对象，所以，均不可以在static环境中使用。包括：static变量,static方法，static语句块。
• 从本质上讲，this是一个指向本对象的指针, 然而super是一个Java关键字。

面试官：Java程序初始化的顺序可以说下吗？

候选人：（《Java程序员面试笔试宝典》第二版 1.1节）

Java程序的初始化工作可以在许多不同的代码块中来完成(例如:静态代码块、构造函数等)，它们执行的顺序为:父类静态变量→父类静态代码块→子类静态变量→子类静态代码→父类非静态变量→父类非静态代码块→父类构造方法→子类非静态变量→子类非静态代码块→子类构造方法。下面给出一个不同模块初始化时执行顺序的例子。

java">class Base {
    static {
        System.out.println("Base static block");
    }

    {
        System.out.println("Base block");
    }

    public Base() {
        System.out.println("Base constructor");
    }
}

public class Derived extends Base {
    static {
        System.out.println("Derived static block");
    }

    {
        System.out.println("Derived block");
    }

    public Derived() {
        System.out.println("Derived constructor");
    }

    public static void main(String[] args) {
        new Derived();
    }
}

// 输出结果
Base static block
Derived static block
Base block
Base constructor
Derived block
Derived constructor

这里需要注意的是，(静态)非静态成员域在定义时初始化和(静态)非静态块中初始化的优先级是平级的，也就是说按照从上到下初始化，最后一次初始化为最终的值(不包括非静态的成员域在构造器中初始化)。所以在(静态)非静态块中初始化的域甚至能在该域声明的上方，因为分配存储空间在初始化之前就完成了。如下例所示:

java">public class testStatic {
    static {
        a = 2;
    }

    static int a = 1;
    static int b = 3;

    static {
        b = 4;
    }

    public static void main(String[] args) {
        System.out.println(a);
        System.out.println(b);
    }
}

// 输出结果
1
4

面试官：说下构造方法（构造器）吧！

候选人：（《Java程序员面试笔试宝典》第二版 1.2节）

Java 语言中，构造方法具有以下特点:

1）构造方法必须与类的名字相同，并且不能有返回值(返回值也不能为 void)。

2）每个类可以有多个构造方法。

3）构造方法可以有0个、1 个或1个以上的参数。

4）构造方法总是伴随着 new 操作一起调用。

5）构造方法的主要作用是完成对象的初始化工作。

6）构造方法不能被继承，因此就不能被重写(Override)，但是构造方法能够被重载(Overload)。

7）当父类和子类都没有定义构造方法的时候，编译器会为父类生成一个默认的无参数的构造方法，给子类也生成一个默认的无参数的构造方法。

面试官：break、continue以及return的区别

候选人：

• break：跳出总上一层循环，不再执行循环(结束当前的循环体)。所以，当多层循环嵌套，break 语句出现在嵌套循环中的内层循环，它将仅仅只是终止了内层循环的执行，而不影响外层循环的执行。

拓展：由于 break 只能跳出当前的循环，那么如何才能实现跳出多重循环呢?可以在多重循环的外面定义一个标识，然后在循环体里使用带有标识的 break 语句即可跳出多重循环。

java">public class Break {
 public static void main(String[] args) {
     out:
     for (int i = 0; i < 5; i++) {
         for (int j = 0; j < 5; j++) {
             if (j >= 2) break out;
             System.out.println(j);
         }
     }
     System.out.println("break");
 }
}

// 输出结果
0
1
break

在 C/C++中，goto 常被用作跳出多重循环，在 Java 语言中，可以使用 break 和 continue 来达到同样的效果。那么既然 goto 没有在 Java 语言中使用，为什么还要作为保留字呢?其中一个可能的原因就是这个关键字有可能会在将来被使用。这里需要注意的是，在 Java 语言中，虽然没有 goto 语句，但是却能使用标识符加冒号 (:)的形式定义标签，如“mylabel：”，其目的主要是在多重循环中方便使用 break 和 continue。

• continue：跳出本次循环，继续执行下次循环(结束正在执行的循环 进入下一个循环条件)。简单地说，continue 只是中断一次循环的执行而己。
• return：程序返回，不再执行下面的代码(结束当前的方法 直接返回)。

面试官：Java的基本数据类型

候选人： Java 语言一共提供了八种原始的数据类型(byte、short、int、long、float、double、char、boolean)。

(图片源自《Java程序员面试笔试宝典》第二版 1.12节)

以上这些基本类型可以分为如下四种类型：

1)int 长度数据类型:byte(8bits)、short(16bits)、int(32bits)、long(64bits)。

2)float 长度数据类型:单精度(32bits float)、双精度(64bits double)。

3)boolean 类型变量的取值:true、false。对于 boolean 占用空间的大小，从理论上讲，只需要1 bit 就够了，但在设计的时候为了考虑字节对齐等因素，一般会考虑使其占用一个字节。

4)char 数据类型:Unicode 字符，16 位。

面试官： 说说你对Java 中的异常处理的理解？

候选人： 在 Java 中，所有的异常都有⼀个共同的祖先 java.lang 包中的 Throwable 类。 Throwable 类有两个重要的⼦类 Exception （异常）和 Error （错误）。 Exception 能被程序本身处理( trycatch )， Error 是⽆法处理的(只能尽量避免)。Exception 和 Error ⼆者都是 Java 异常处理的重要⼦类，各⾃都包含⼤量⼦类。

• Exception：程序本身可以处理的异常，可以通过 catch 来进⾏捕获。 Exception ⼜可以分为 受检查异常(必须处理) 和 不受检查异常(可以不处理)。

受检查异常：Java 代码在编译过程中，如果受检查异常没有被 catch / throw 处理的话，就没办法通过编译。除了 RuntimeException 及其⼦类以外，其他的 Exception 类及其⼦类都属于检查异常 。常⻅的受检查异常有： IO 相关的异常、 ClassNotFoundException 、 SQLException …。

不受检查异常：Java 代码在编译过程中 ，我们即使不处理不受检查异常也可以正常通过编译。RuntimeException 及其⼦类都统称为⾮受检查异常，例如： NullPointExecrption（空指针异常） 、 NumberFormatException （字符串转换为数字）、 ArrayIndexOutOfBoundsException （数组越界）、 ClassCastException （类型转换错误）等。

• Error：Error 属于程序⽆法处理的错误 ，我们没办法通过 catch 来进⾏捕获 。例如，Java 虚拟机运⾏错误（ Virtual MachineError ）、虚拟机内存不够错误( OutOfMemoryError )、类定义错误（NoClassDefFoundError ）等 。这些异常发⽣时，Java虚拟机（JVM）⼀般会选择线程终⽌。

面试官：finally块中的代码什么时候被执行？

候选人：（《Java程序员面试笔试宝典》第二版 1.19节）
在 Java 语言的异常处理中，finally 语句块的作用就是保证无论出现什么情况，finally 块里的代码一定会被执行。由于当程序执行 return 的时候就意味着结束对当前方法的调用并跳出这个方法体，任何语句要执行都只能在 return 前执行(除非碰到 exit 函数)，因此 fnally 块里的代码也是在return 前执行的。此外，如果 try-finally 或者 catch-finally 中都有 return，则 finally 块中的 retumn 语句将会覆盖别处的 retumn 语句，最终返回到调用者的是 finally 中 return 的值。下面通过两个例子来说明这个问题：

java">public class Test {
    public static int testFinally() {
        try {
            return 1;
        } catch (Exception e) {
            return 0;
        } finally {
            System.out.println("execute finally");
        }
    }
    public static void main(String[] args) {
        int result = testFinally();
        System.out.println(result);
    }
}

// 输出结果
execute finally
1

从上面这个例子中可以看出，在执行 return 前确实执行了 finally 中的代码。紧接着，在 finally块里面放置 return 语句：

java">public class Test {
    public static int testFinally() {
        try {
            return 1;
        } catch (Exception e) {
            return 0;
        } finally {
            System.out.println("execute finally");
            return 3;
        }
    }
    public static void main(String[] args) {
        int result = testFinally();
        System.out.println(result);
    }
}

// 输出结果
execute finally
3

在以下 3 种特殊情况下， finally 块不会被执⾏：

1. 在 try 或 finally 块中⽤了 System.exit(0) 退出程序。

2. 当程序在进入try语句块之前就出现异常的时候（int i = 5/0;）。

3. 程序所在的线程死亡。

4. 关闭 CPU。

面试官： BIO,NIO,AIO 有什么区别?（重要）

候选人：

• BIO (Blocking I/O): 同步阻塞 I/O 模式，数据的读取写⼊必须阻塞在⼀个线程内等待其完成（每个线程只能处理一个连接）。在活动连接数不是特别⾼（⼩于单机 1000）的情况下，这种模型不错的，可以让每⼀个连接专注于⾃⼰的 I/O 并且编程模型简单，也不⽤过多考虑系统的过载、限流等问题。但是，当⾯对⼗万甚⾄百万级连接的时候，这种方式需要创建大量的线程，而系统的资源都是有限的，大量的线程会降低系统的性能。

• NIO (Non-blocking I/O): 同步⾮阻塞的 I/O 模型，在 Java 1.4 中引⼊NIO 框架之前，Java通过传统的Socket来实现基本的网络通信功能的。NIO通过 Channels , Selector，Buffers 来实现非阻塞的IO操作。NIO 中的 N 可以理解为 Non-blocking，不单纯是 New。它⽀持⾯向缓冲的，基于通道的 I/O 操作⽅法。它最主要的特点是，提供了基于Selector的异步网络I/O，使得一个线程可以管理多个连接。（图片源自《Java程序员面试笔试宝典》第二版 2.4节）

扩展：Channel（通道） , Selector（选择器），Buffer（缓冲区）

(1) Channel(通道)
为了更容易地理解什么是 Channel，这里以 InputStream 为例来介绍什么是 Channel。传统的 IO 中经常使用下面的代码来读取文件(此处忽略异常处理):

java">File file = new File("imput.txt");
InputStream is = new FileInputStream(file);
byte[] tempbyte = new byte[1024];
while((tempbyte=is.read())!=-1){
//处理读取到的数据
}
is.close();

InputStream 其实就是一个用来读取文件的通道。只不过 InputStream 是一个单向的通道，只能用来读取数据。而 NIO 中的 Channel 是一个双向的通道，不仅能读取数据，而且还能写入数据。

(2) Buffer(缓冲区)
在上面的示例代码中，InputSteam 把读取到的数据放在了 byte 数组中，如果用 OutputSteam 写数据，那么也可以把 byte 数组中的数据写到文件中。而在 NIO 中，数据只能被写到 Buffer 中，同理读取的数据也只能放在 Buffer 中，由此可见 Bufer 是 Channel 用来读写数据的非常重要的一个工具。

(3) Selector(选择器)
Selector 是 NIO 中最重要的部分，是实现一个线程管理多个连接的关键，它的作用就是轮询所有被注册的Channel，一旦发现 Channel 上被注册的事件发生，就可以对这个事件进行处理。

• AIO (Asynchronous I/O): AIO 也就是 NIO 2。在 Java 7 中引⼊了 NIO 的改进版 NIO 2,它是异步⾮阻塞的 IO 模型。虽然 NIO 在⽹络操作中，也提供了⾮阻塞的⽅法，但它仍需要使用阻塞的方式读取数据，显然这种情况下这个线程就被阻塞了。在高并发环境下，也会有一定的性能问题。造成这个问题的主要原因就是NIO仍然使用了同步的IO。而异步 IO （AIO）是基于事件和回调机制实现的，也就是应⽤操作之后会直接返回，不会堵塞在那⾥，当后台处理完成，操作系统会通知相应的线程进⾏后续的操作。查阅⽹上相关资料，我发现就⽬前来说 AIO 的应⽤还不是很⼴泛，Netty 之前也尝试使⽤过 AIO，不过⼜放弃了。

面试官：深拷⻉ vs 浅拷⻉

候选人：

1. 浅拷⻉：对基本数据类型进⾏值传递，对引⽤数据类型进⾏引⽤传递般的拷⻉，此为浅拷⻉。

2. 深拷⻉：对基本数据类型进⾏值传递，对引⽤数据类型，创建⼀个新的对象，并复制其内容，此为深拷⻉。

面试官： Java反射机制以及获取反射对象的几种方式

候选人：（《Java程序员面试笔试宝典》第二版 1.4节）

在Java语言中，反射机制是指对于运行时类，都能够动态地获取到这个类的所有属性和方法。对于任意的一个对象，都能够调用它的任意一个方法以及访问它的属性；这种动态地获取类或对象的属性以及方法从而完成调用功能被称为Java语言的反射机制。

反射机制中Class是一个非常重要的类，在Java语言中获取Class对象主要有如下几种方法。

1. 通过className.class来获取。

java">class A{
    static {
        System.out.println("static block");
    }
    {
        System.out.println("dynamic block");
    }
}

class Test{
    public static void main(String[] args) {
        Class<?> clazz = A.class;
        System.out.println("className:" + clazz.getName());
    }
}

// 执行结果
className:A

2. 通过Class.forName()来获取。

java">class A {
    static {
        System.out.println("static block");
    }

    {
        System.out.println("dynamic block");
    }
}

class Test {
    public static void main(String[] args) {
        Class<?> clazz = null;
        try {
            clazz = Class.forName("A");
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("className:" + clazz.getName());
    }
}

// 执行结果
static block
className:A

3. 通过Object.getClass()来获取。

java">class A {
    static {
        System.out.println("static block");
    }

    {
        System.out.println("dynamic block");
    }
}

class Test {
    public static void main(String[] args) {
        Class<?> clazz = new A().getClass();
        System.out.println("className:" + clazz.getName());
    }
}

// 执行结果
static block
dynamic block
className:A

从上面的例子可知，虽然这三种方式都可以获得类的Class对象，但是它们还是有区别的，主要区别如下所示：

方法1）不执行静态块和动态构造块

方法2）只执行静态块，而不执行普通代码块

方法3）因为需要创建对象，所以会执行静态块和普通代码块