面试官： 面向对象(OOP)和面向过程(POP)的区别（高频）

候选人：

• ⾯向过程 ：⾯向过程性能⽐⾯向对象⾼。 ⽐如单⽚机、嵌⼊式开发、Linux/Unix 等⼀般采⽤⾯向过程开发。以函数为中心，强调逻辑流程。

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

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

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

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

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

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

1）数值型：整数类型（byte、short、int、long）和浮点类型（float、double）

2）字符型：char

3）布尔型：boolean

8种基本数据类型的默认值、位数、取值范围，如下表所示：

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

候选人：

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

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

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

• Java Runtime Environment（JRE） 包括Java虚拟机和Java程序所需的核心类库等。核心类库主要是java.lang包。
• Java Development Kit（JDK） 是提供给Java开发人员使用的，其中包含了Java的开发工具，也包括了JRE。所以安装了JDK，就无需再单独安装JRE了。其中的开发工具：编译工具(javac.exe)，打包工具(jar.exe)等。

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

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

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

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

候选人：

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

深度思考：

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

面试官： 什么是序列化?什么是反序列化?

候选人：

如果我们需要持久化 Java 对象比如将 Java 对象保存在文件中，或者在网络传输 Java 对象，这些场景都需要用到序列化。

简单来说：

• 序列化：将数据结构或对象转换成可以存储或传输的形式，通常是二进制字节流，也可以是 JSON, XML 等文本格式
• 反序列化：将在序列化过程中所生成的数据转换为原始数据结构或者对象的过程

下面是序列化和反序列化常见应用场景：

• 对象在进行网络传输（比如远程方法调用 RPC 的时候）之前需要先被序列化，接收到序列化的对象之后需要再进行反序列化；
• 将对象存储到文件之前需要进行序列化，将对象从文件中读取出来需要进行反序列化；
• 将对象存储到 数据库（如 Redis） 之前需要用到序列化，将对象从缓存数据库中读取出来需要反序列化；
• 将对象存储到内存之前需要进行序列化，从内存中读取出来之后需要进行反序列化。

综上：序列化的主要目的是通过网络传输对象或者说是将对象存储到文件系统、数据库、内存中。

面试官： 重载和重写的区别（高频）

候选人：

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

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

面试官：面向对象的特征有哪些方面？（高频）

候选人：

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

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

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

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

多态：多态是指允许不同类的对象对同一消息作出响应。即同一个接口，使用不同的实例而执行不同操作。在Java中有两种形式可以实现多态：继承（多个子类对同一方法的重写）和接口（实现接口并覆盖接口中同一方法）。例如，如果父类 Animal 有一个 makeSound() 方法，子类 Dog 和 Cat 可以分别重写这个方法，当调用 animal.makeSound() 时，具体执行的是 Dog 或 Cat 的实现。

面试官：面向对象的设计原则你知道有哪些吗

候选人： 面向对象编程中的五大原则:

• 单一职责原则(SRP):一个类应该只有一个引起它变化的原因，即一个类应该只负责一项职责。例子:考虑一个员工类，它应该只负责管理员工信息，而不应负责其他无关工作。
• 开放封闭原则(OCP):软件实体应该对扩展开放，对修改封闭。例子:通过制定接口来实现这一原则，比如定义一个图形类，然后让不同类型的图形继承这个类，而不需要修改图形类本身。
• 里氏替换原则(LSP):子类对象应该能够替换掉所有父类对象。例子:一个正方形是一个矩形，但如果修改一个矩形的高度和宽度时，正方形的行为应该如何改变就是一个违反里氏替换原则的例子。
• 接口隔离原则(ISP) :客户端不应该依赖那些它不需要的接口，即接口应该小而专。例子:通过接口抽象层来实现底层和高层模块之间的解耦，比如使用依赖注入。
• 依赖倒置原则(DIP):高层模块不应该依赖低层模块，二者都应该依赖于抽象;抽象不应该依赖于细节，细节应该依赖于抽象。例子:如果一个公司类包含部门类，应该考虑使用合成/聚合关系，而不是将公司类继承自部门类。

面试官： 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 关键字修饰，所以这两种对象都是可变的。

  1 2 3 4 5 6 7 8 9 10 11 12

  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方法把结果返回。举例如下:

1
2

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

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

1
2
3
4

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

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

对于三者使⽤的总结：

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

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

候选人：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

// 定义接口
public interface Flyable {
    void fly();
}

public interface Swimmable {
    void swim();
}

// 定义抽象类
public abstract class Animal {
    protected String name;

    public Animal(String name) {
        this.name = name;
    }

    public abstract void eat(); // 抽象方法
}

// 定义普通类
public class Sparrow extends Animal implements Flyable {
    public Sparrow(String name) {
        super(name);
    }

    @Override
    public void eat() {
        System.out.println(name + " is eating seeds.");
    }

    @Override
    public void fly() {
        System.out.println(name + " is flying.");
    }
}

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

候选人：

面试官： 什么是自动拆箱/装箱？（高频）

候选人：

• 自动装箱是指将基本数据类型（如 int、double、boolean 等）自动转换为对应的包装类对象（如 Integer、Double、Boolean 等）。这个过程由编译器自动完成，当存储一个基本数据类型到需要用到对象的场景中(例如集合)，Java 编译器会检测到基本数据类型需要被转换为包装类对象，编译器会自动调用包装类的 valueOf() 方法来创建对应的包装类对象，生成的对象会被存储到目标位置。

  1 2	int num = 10; Integer integerObj = Integer.valueOf(num);

• 自动拆箱是指将包装类对象（如 Integer、Double、Boolean 等）自动转换为对应的基本数据类型（如 int、double、boolean 等）。同样，这个过程也是由编译器自动完成的。当你从一个需要对象的场景中取出值并赋给基本数据类型时，Java 编译器会检测到目标变量是一个基本数据类型。编译器会自动调用包装类的 xxxValue() 方法，比如 intValue()、doubleValue() 等，来获取基本数据类型的值。返回的基本数据类型值会被赋给目标变量。

  1 2	Integer integerObj = 10; int num = integerObj.intValue();

一共有3点需要注意

第一个是性能问题，频繁的自动装箱和拆箱可能会导致额外的性能开销，因为每次都需要创建或转换对象。

第二个是空指针异常，如果对一个 null 的包装类对象进行自动拆箱操作，会抛出 NullPointerException。

第三个是缓存机制，某些包装类（如 Integer、Boolean 等）会对常用值进行缓存。

面试官： int和Integer的区别（高频）

候选人：

1. 定义上的区别:

   • int 是 Java 的基本数据类型，直接存储数值，占用固定的 4 字节内存空间，范围是从 -2,147,483,648 到 2,147,483,647。

   • 而 Integer 是 int 的包装类，它是一个对象，通过引用指向存储的数值，因此除了存储数值本身外，还需要额外的内存开销。

2. 使用方式上的区别:

   • int 是一种原始类型，可以直接声明和赋值。

   • 而 Integer 必须实例化后才能使用，它提供了更多的功能，比如支持泛型、序列化、缓存以及一些实用方法。

3. 使用场景上的区别:

   • 当需要高效处理整数时，优先使用 int。

   • 当需要将整数作为对象使用时，选择 Integer。

Java 是一门面向对象的语言，很多场景需要将数据封装成对象。例如：泛型（Generics）要求参数必须是对象类型，而不能是基本数据类型。序列化（Serialization）需要对象支持，以便将数据持久化或通过网络传输。缓存机制需要对整数进行复用，以提高性能和节省内存。

因此，Java 设计了 Integer 作为 int 的包装类，解决了这些面向对象的需求。

Integer a=1，Integer b=1，a==b?

Java 使用了 Integer 缓存池，默认缓存范围是 -128 到 127。

• 使用 == 比较时，如果值在 -128 ~ 127 之间，结果为 true。

1
2
3

Integer a = 1;
Integer b = 1;
System.out.println(a == b); // true

• 如果值超出缓存范围，结果为 false。

1
2
3

Integer a = 200;
Integer b = 200;
System.out.println(a == b); // false

• 使用 equals() 方法进行值比较，则无论范围如何，结果都为 true

面试官： == 与 equals（高频）

候选人：

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

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

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

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，因为String内部重写了equals.
            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() 函数。

1

public native int hashCode();

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

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

3）为啥hashcode相同了，这两个对象还有可能不相同呢？

这是由于哈希码值的空间有限（通常是32位整数），而对象的状态空间可能非常大，因此可能会发生“哈希碰撞”，即不同的对象拥有相同的哈希码值。举个例子，考虑一个简单的类 Person，它有两个属性 name 和 age。你可以为这个类重写 hashCode() 和 equals() 方法来确保当两个 Person 对象具有相同的 name 和 age 时，它们的哈希码相同并且 equals() 方法也返回 true。但是，如果你仅仅让 hashCode() 方法基于 name 属性计算哈希码，那么即使 age 不同，两个具有相同名字的 Person 对象也会有相同的哈希码值，尽管它们实际上是不同的对象。

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

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

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

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

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 的副本，副本的内容无论怎么修改，都不会影响到原件本身。

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

    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程序设计语言对对象采用的是引用调用，实际上，这种理解是不对的。由于这种误解具有一定的普遍性，所以下面给出一个反例来详细地阐述一下这个问题。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

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()，回收垃圾。

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

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 语句：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

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。

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

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 语句即可跳出多重循环。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

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 语句，但是却能使用标识符加冒号 (:)的形式定义标签，其目的主要是在多重循环中方便使用 break 和 continue。

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

面试官： 说说你对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）⼀般会选择线程终⽌。

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

候选人：

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

• NIO (Non-blocking I/O): 同步⾮阻塞 的 I/O 模型。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 中经常使用下面的代码来读取文件(此处忽略异常处理):

1 2 3 4 5 6 7

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 在⽹络操作中，也提供了⾮阻塞的⽅法，但它本身仍然是同步的，选择器仍然需要通过轮询主动检查数据请求。而异步 IO （AIO）是基于事件和回调机制实现的，也就是应⽤操作之后会直接返回，不会堵塞在那⾥，当后台处理完成，操作系统会通知相应的线程进⾏后续的操作。查阅⽹上相关资料，我发现就⽬前来说 AIO 的应⽤还不是很⼴泛，Netty 之前也尝试使⽤过 AIO，不过⼜放弃了。

面试官： NIO是如何实现同步非阻塞的？主线程是只有一个嘛？

候选人：

在NIO中，使用了多路复用器Selector来实现同步非阻塞的IO操作。Selector是一个可以监控多个通道（Channel）是否有数据可读或可写的对象，当一个或多个Channel准备好读或写时，Selector会通知程序进行读写操作，而不是像BIO一样阻塞等待IO操作完成。

在NIO中，主线程通常只有一个，但是可以使用Selector来管理多个Channel，实现多个连接的非阻塞读写操作。当有多个Channel需要进行IO操作时，Selector会轮询这些Channel，检查它们的状态是否可读或可写，如果有可读或可写的Channel，就将其加入到一个已选择键集合中，等待程序处理。这样，一个线程就可以同时处理多个Channel，提高了系统的并发处理能力。

面试官： 深拷贝和浅拷贝区别了解吗？什么是引用拷贝？（高频）

• 浅拷贝：浅拷贝会在堆上创建一个新的对象（区别于引用拷贝的一点），不过，如果原对象内部的属性是引用类型的话，浅拷贝会直接复制内部对象的引用地址，也就是说拷贝对象和原对象共用同一个内部对象。浅拷贝实现简单，使用 clone() 即可。

• 深拷贝：深拷贝会完全复制整个对象，包括这个对象所包含的内部对象。增加了一个指针并且申请了一个新的内存，使这个新增的指针指向新的内存。 深拷贝需要递归复制或序列化，实现较复杂。

  联想：在租房的场景中，租客和房东共享房子的使用权，任何改动都会影响对方；而在买房的场景中，买方拥有独立的房子，可以自由改造而不影响他人。通过租房和买房的类比，轻松理解浅拷贝和深拷贝的不同。

  浅拷贝 → 租房（租客和房东共享房子，改动家具会影响房东）。

  深拷贝 → 买房（买房后拥有完全独立的房子，改动家具不会影响房东）。

那什么是引用拷贝呢？ 简单来说，引用拷贝就是两个不同的引用指向同一个对象。

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

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

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

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

1. 通过.class来获取。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

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()来获取。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

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. 通过.getClass()来获取。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

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）因为需要创建对象，所以会执行静态块和普通代码块

面试官： Java创建对象除了new还有别的什么方式?

候选人：

• 通过反射创建对象:通过 Java 的反射机制可以在运行时动态地创建对象。可以使用 Class 类的 newinstance() 方法或者通过 Constructor 类来创建对象。

  1 2 3 4 5 6 7 8 9 10 11

  public class MyClass { public MyClass() { // Constructor } } public class Main { public static void main(String[] args) throws Exception { Class<?> clazz=MyClass.class; MyClass obj=(MyClass)clazz.newInstance(); } }

• 通过反序列化创建对象:通过将对象序列化(保存到文件或网络传输)然后再反序列化(从文件或网络传输中读取对象)的方式来创建对象，对象能被序列化和反序列化的前提是类实现Serializable接口。

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

  import java.io.*; public class MyClass implements Serializable { // Class definition } public class Main { public static void main(String[] args) throws Exception { // Serialize object MyClass obj = new MyClass(); ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("object.ser")); out.writeObject(obj); out.close(); // Deserialize object ObjectInputStream in = new ObjectInputStream(new FileInputStream("object.ser")); MyClass newObj = (MyClass) in.readObject(); in.close(); } }

• 通过clone创建对象:所有 Java 对象都继承自 Object 类，Object 类中有一个 clone()方法，可以用来创建对象的副本，要使用 clone 方法，我们必须先实现 Cloneable 接口并实现其定义的 clone 方法。

  1 2 3 4 5 6 7 8 9 10 11 12 13

  public class MyClass implements Cloneable { @Override public Object clone() throws CloneNotSupportedException { return super.clone(); } } public class Main { public static void main(String[] args) throws CloneNotSupportedException { MyClass obj1 = new MyClass(); MyClass obj2 = (MyClass) obj1.clone(); } }