1.Java语言的特点？

1.一面向对象（封装，继承，多态）；

2.平台无关性（ Java 虚拟机实现平台无关性）；(类是一种定义对象的蓝图或模板)3.支持多线程（ C++ 语言没有内置的多线程机制，因此必须调用操作系统的多线程功能来进行多线程程序设计，而 Java 语言却提供了多线程支持）；

4.可靠性（具备异常处理和自动内存管理机制）

5.安全性（Java 语言本身的设计就提供了多重安全防护机制如访问权限修饰符、限制程序直接访问操作系统资源）；

6.高效性（通过 Just In Time 编译器等技术的优化，Java 语言的运行效率还是非常不错的）；

7.支持网络编程并且很方便；

8.编译与解释并存；

2.什么是类：

(类是一种定义对象的蓝图或模板)

3.Java与C++的区别？

1.Java 不提供指针来直接访问内存，程序内存更加安全。

2.Java 的类是单继承的，C++ 支持多重继承；

3.虽然 Java 的类不可以多继承，但是接口可以多继承。

4.虽然，Java 和 C++ 都是面向对象的语言，都支持封装、继承和多态，但是，它们还是有挺多不相同的地方：Java 有自动内存管理垃圾回收机制(GC)，不需要程序员手动释放无用内存。

5.C ++同时支持方法重载和操作符重载，但是 Java 只支持方法重载（操作符重载增加了复杂性，这与 Java 最初的设计思想不符）。

3.介绍JDK，JRE，JVM，以及java的三个版本

1.Java SE: Java 平台标准版，Java 编程语言的基础，它包含了支持 Java 应用程序开发和运行的核心类库以及虚拟机等核心组件。Java SE 可以用于构建桌面应用程序或简单的服务器应用程序。

2.Java EE：Java 平台企业版，建立在 Java SE 的基础上，包含了支持企业级应用程序开发和部署的标准和规范（比如 Servlet、JSP、EJB、JDBC、JPA、JTA、JavaMail、JMS）。 Java EE 可以用于构建分布式、可移植、健壮、可伸缩和安全的服务端 Java 应用程序，例如 Web 应用程序。（简单来说，Java SE 是 Java 的基础版本，Java EE 是 Java 的高级版本。Java SE 更适合开发桌面应用程序或简单的服务器应用程序，Java EE 更适合开发复杂的企业级应用程序或 Web 应用程序。）

3.Java ME 是 Java 的微型版本，主要用于开发嵌入式消费电子设备的应用程序，例如手机、PDA、机顶盒、冰箱、空调等。Java ME 无需重点关注，知道有这个东西就好了，现在已经用不上了

1.JDK(java开发工具包)，它是功能齐全的 Java SDK，是提供给开发者使用，能够创建和编译 Java 程序的开发套件。它包含了 JRE，同时还包含了编译 java 源码的编译器 javac 以及一些其他工具比如 javadoc（文档注释工具）、jdb（调试器）、jconsole（基于 JMX 的可视化监控⼯具）、javap（反编译工具）等等。

2.JRE 是 Java 运行时环境。它是运行已编译 Java 程序所需的所有内容的集合，主要包括 Java 虚拟机（JVM）、Java 基础类库（Class Library）。

3.Java 虚拟机（JVM）是运行 Java 字节码的虚拟机。JVM 有针对不同系统的特定实现（Windows，Linux，macOS），目的是使用相同的字节码，它们都会给出相同的结果。字节码和不同系统的 JVM 实现是 Java 语言“一次编译，随处可以运行”的关键所在。

4.为什么说Java语言编译与解释并存？

这是因为 Java 语言既具有编译型语言的特征，也具有解释型语言的特征。因为 Java 程序要经过先编译，后解释两个步骤，由 Java 编写的程序需要先经过编译步骤，生成字节码（.class 文件），这种字节码必须由 Java 解释器来解释执行。

高级语言的编译运行方式都是: 编程{编写代码文件}，编译{将代码转化为机器语言的过程}，运行{让机器执行编译后的指令}

我们可以将高级编程语言按照程序的执行方式分为两种：

1.解释型会通过一句一句的将代码解释（interpret）为机器代码后再执行。解释型语言开发效率比较快，执行速度比较慢。常见的解释性语言有 Python、JavaScript、PHP 等等。（{不产生一个新文件}而是读一行解释一行）

2.编译型会通过将源代码一次性翻译成可被该平台执行的机器码。一般情况下，编译语言的执行速度比较快，开发效率比较低。常见的编译性语言有 C、C++、Go、Rust 等等。（一次编译完）

java先整体编译成字节码文件，然后再按行交给设备运行(在虚拟机中运行)

5.什么是字节码？采用字节码的好处是什么？

在 Java 中，JVM 可以理解的代码就叫做字节码（即扩展名为 .class 的文件），它不面向任何特定的处理器，只面向虚拟机。Java 语言通过字节码的方式，在一定程度上解决了传统解释型语言执行效率低的问题，同时又保留了解释型语言可移植的特点。所以， Java 程序运行时相对来说还是高效的（不过，和 C、 C++，Rust，Go 等语言还是有一定差距的），而且，由于字节码并不针对一种特定的机器，因此，Java 程序无须重新编译便可在多种不同操作系统的计算机上运行。

6.Java的几种基本数据类型了解吗？

• Java 中有 8 种基本数据类型，分别为：1 种字符类型：char
• 6 种数字类型：4 种整数型：byte、short、int、long2 种浮点型：float、double
• 1 种布尔型：boolean。

7.比较一下包装类型和基本数据类型？

1.用途：除了定义一些常量和局部变量之外，我们在其他地方比如方法参数、对象属性中很少会使用基本类型来定义变量。并且，包装类型可用于泛型，而基本类型不可以。

2.存储方式：基本数据类型的局部变量存放在 Java 虚拟机栈中的局部变量表中，基本数据类型的成员变量（未被 static 修饰 ）存放在 Java 虚拟机的堆中。包装类型属于对象类型，我们知道几乎所有对象实例都存在于堆中。

解释：

• 局部变量：

• • 基本数据类型的局部变量存储在栈中的局部变量表中。
  • 包装类型的局部变量本质上是一个引用，引用本身存储在栈中，实际对象存储在堆中。

• 成员变量（未被 static 修饰）：

• • 基本数据类型作为成员变量时，存储在堆中，和所属对象存储在一起。
  • 包装类型的成员变量本质上是一个引用，引用存储在堆中，但包装对象本身也存储在堆中。

3.占用空间：相比于包装类型（对象类型）， 基本数据类型占用的空间往往非常小。

4.默认值：成员变量包装类型不赋值就是 null ，而基本类型有默认值且不是 null。

5.比较方式：对于基本数据类型来说，== 比较的是值。对于包装数据类型来说，== 比较的是对象的内存地址。所有整型包装类对象之间值的比较，全部使用 equals() 方法。

8.为什么局部变量在栈中，成员变量（未被 static 修饰）在堆中？

这源于 Java 的内存分配机制以及变量的生命周期管理。

栈和堆的特点

1. 1. 栈（Stack）：

• • 栈是线程私有的内存区域，用于存储方法调用相关的临时数据，包括局部变量、方法调用链等。
  • 栈上的数据生命周期短，随着方法调用的结束，栈帧销毁，局部变量随之销毁。
  • 操作效率高，因为栈是连续内存，遵循“先进后出”规则，分配和释放内存速度很快。

1. 1. 堆（Heap）：

• • 堆是线程共享的内存区域，用于存储所有对象实例和成员变量。
  • 堆上的数据生命周期更长，由 JVM 的垃圾回收机制（GC）管理，通常只有在对象不再被引用时才会被回收。
  • 适合存储需要跨方法或长时间存在的数据，比如对象实例和它们的成员变量。

局部变量存储在栈中的原因

• • 生命周期短：局部变量是方法内部的临时变量，其生命周期等同于方法的生命周期。方法调用结束后，局部变量就不再需要，因此存储在栈中是合理的。
  • 高效存取：栈上的操作效率高，能快速分配和释放内存，适合存储局部变量这种临时数据。

成员变量存储在堆中的原因

• • 生命周期长：成员变量依赖于对象的生命周期，而对象通常需要长时间存在，因此存储在堆中。
  • 对象的整体性：堆中存储了对象的所有成员变量，这使得对象在内存中是完整的。无论对象被传递到哪里，其成员变量始终与它绑定。

一个小例子：

public class Example {int instanceVariable = 10; // 成员变量，存储在堆中static int staticVariable = 20; // 静态变量，存储在方法区中public void testMethod() {int localVariable = 30; // 局部变量，存储在栈中Integer wrappedVariable = 40; // 包装类型变量引用，引用在栈中，对象在堆中}
}

• 当 testMethod 被调用时：

• • localVariable（局部变量）直接存储在栈中。
  • wrappedVariable 的引用存储在栈中，而 Integer 对象实例存储在堆中。

• 当 Example 类的对象被创建时：

• • instanceVariable（成员变量）存储在堆中，和对象一起。
  • staticVariable 存储在方法区中，和类相关，而不是实例。

总结

• 局部变量存储在栈中是因为它们的生命周期与方法的执行时间相同，且栈的操作高效。
• 成员变量存储在堆中是因为它们的生命周期与对象的生命周期一致，且对象实例需要在堆中完整存储。

9.Integer和int的区别，为什么要设计包装数据类型？

主要是考察对面向对象的了解程度：尽量从包装数据类型的特性和功能上去回答

区别比如：

1.int可以直接定义一个变量即可赋值，而Integer是需要使用new创建对象的

2.基本数据类型和Integer类型混合使用的时候，Java会自动通过拆箱和装箱实现类型的转换

3.Integer作为一个对象，封装了很多的方法和属性，可以使用这些方法来操作属性

4.作为一个成员变量Integer的默认值为null，但是int的默认值为0.

回答之所以要设计包装数据类型，是因为Java本身是一门面向对象的语言，对象是Java的基础操作单元，很多时候，在传递数据的时候也需要使用对象类型，比如ArrayList和HashMap这种只能存储对象类型，从这个点来看，封装类型的意义就很大。其次比如封装类型：安全性好，可以避免外部操作，随意修改成员变量的值，保证成员变量和数据传递的安全性，隐藏了实现细节，对使用者更加优化。

10.int 和 Integer 哪个会占用更多的内存？

Integer 对象会占用更多的内存，Integer 是一个对象，需要存储对象的元数据，但是 int 是一个基本数据类型的数据，所以占用的空间更少。

int 本身没有空值，定义出来时候初始值为 0，但是在数据库操作的时候，有可能数据的值是空的，因此封装为 Integer，它允许有 null 值。

11.元数据是什么，有什么用？

1. 元数据的基本概念：元数据（Metadata）是一种描述数据的数据。它提供了有关数据的结构、属性、位置、来源等信息，帮助人们理解数据的具体内容和如何找到这些数据。例如，在图书馆中，一本书的目录可以视为该书的元数据，因为它描述了书的内容结构和各章节的主题。
2. 元数据的类型：根据功能不同，元数据可以分为描述性元数据、管理性元数据和技术性元数据等类型。描述性元数据提供关于信息资源的基本信息，如标题、作者、主题等；管理性元数据则与资源的管理相关，包括版权信息、使用权限等；技术性元数据涉及数据的技术细节，如格式、标准等。
3. 元数据的作用：元数据在信息组织和管理中起着关键作用。它不仅帮助用户快速准确地查找到所需信息，还支持数据的整合、交换和再利用。通过元数据，信息系统能够更高效地处理和维护大量复杂的数据。

12.基本数据类型是否都放在了栈中？

基本数据类型的存储位置取决于它们的作用域和声明方式。如果它们是局部变量，那么它们会存放在栈中；如果它们是成员变量，那么它们会存放在堆中

13.包装类型的缓存机制了解吗？

Java 基本数据类型的包装类型的大部分都用到了缓存机制来提升性能。

Byte,Short,Integer,Long 这 4 种包装类默认创建了数值 [-128，127] 的相应类型的缓存数据，Character 创建了数值在 [0,127] 范围的缓存数据，Boolean 直接返回 True or False。

Integer这些包装类型内部维护了一个IntegerCache（这种机制），它缓存了-128~127的数值对应的Integer类型，一旦程序调用了valueOf（）方法，若数值是在-128到127之间，就会直接从cache里面去获取Integer对象，否则就会去创建一个新的对象，所以在缓存机制内的用的其实是同一个对象实例。

14.介绍一下自动拆箱和装箱？

1. 什么是自动装箱和自动拆箱？

• • • 自动装箱（Autoboxing）：将 基本数据类型 自动转换为其对应的 包装类对象。
    • 例如：将 int 转换为 Integer，double 转换为 Double。
    • 示例：

Integer boxedInt = 10; // 自动装箱，相当于 Integer.valueOf(10)

• • • 自动拆箱（Unboxing）：将 包装类对象 自动转换为其对应的 基本数据类型。
    • 例如：将 Integer 转换为 int，Double 转换为 double。
    • 示例：

int unboxedInt = new Integer(20); // 自动拆箱，相当于 new Integer(20).intValue()

2.自动装箱和拆箱的作用

• • • 包装类的作用：
    • 包装类允许将基本数据类型当作对象来操作，为基本数据类型提供了面向对象的特性。
    • 包装类提供了一些实用方法，例如 Integer.parseInt()、Double.toString()，方便开发。
    • 应用场景：
    • 泛型：Java 泛型只支持对象类型，无法直接使用基本数据类型。例如：

List<Integer> list = new ArrayList<>(); // 自动装箱，存储基本类型的包装对象

• • • 集合框架：集合类（如 List、Set、Map）只能存储对象，使用包装类可以存储基本类型值。
    • 工具类交互：某些工具类方法需要对象类型参数，例如 Object 或 Comparable。

3. 自动装箱和拆箱的优点

• • 代码简化：自动装箱和拆箱使得开发者无需显式调用包装类的方法来进行类型转换。
  • 手动装箱：

Integer num = Integer.valueOf(5);

• • • 自动装箱：

Integer num = 5;

• • 提高代码可读性：自动装箱和拆箱让代码更加清晰直观，减少了繁琐的显式转换调用。

---

4. 自动装箱和拆箱的隐患

1. 1. 性能问题：

• • 自动装箱和拆箱会产生额外的对象开销。例如：

Integer a = 1000; // 装箱，创建对象
int b = a;        // 拆箱

• • • 如果频繁使用，可能会造成性能问题，因为包装类对象的创建是有成本的。

1. 1. 空指针异常（NullPointerException）：

• • 自动拆箱时，如果包装类对象为 null，会抛出空指针异常。例如：

Integer obj = null;
int value = obj; // 抛出 NullPointerException

1. 1. 缓存问题（注意 Integer 缓存范围）：

• • Java 中的包装类（如 Integer、Short、Byte 等）对某些范围内的值进行了缓存（称为常量池）。例如：

• • • Integer 的缓存范围是 -128 到 127。

Integer a = 100;
Integer b = 100;
System.out.println(a == b); // true，因为在缓存范围内Integer c = 200;
Integer d = 200;
System.out.println(c == d); // false，因为超出缓存范围，创建了新对象

• • • 这可能导致在比较包装类对象时产生意想不到的结果。需要注意用 equals() 方法来比较值，而不是 ==。

5. 示例代码

通过一个完整的例子说明装箱和拆箱：

import java.util.ArrayList;
import java.util.List;public class BoxingUnboxingDemo {public static void main(String[] args) {// 自动装箱：基本类型 -> 包装类对象Integer boxedInt = 10;// 自动拆箱：包装类对象 -> 基本类型int unboxedInt = boxedInt;// 在集合中使用包装类List<Integer> numbers = new ArrayList<>();numbers.add(5); // 自动装箱numbers.add(10); // 自动装箱int sum = 0;for (Integer num : numbers) {sum += num; // 自动拆箱}System.out.println("Sum: " + sum); // 输出：15// 注意空指针异常Integer nullValue = null;// int value = nullValue; // 取消注释会抛出 NullPointerException}
}

得分点 包装类的作用,应用场景

1、自动装箱、自动拆箱是JDK1.5提供的功能。

2、自动装箱：把一个基本类型的数据直接赋值给对应的包装类型；

3、自动拆箱是指把一个包装类型的对象直接赋值给对应的基本类型；

4、通过自动装箱、自动拆箱功能,简化基本类型变量和包装类对象之间的转换过程

15.为什么浮点数运算的时候会有精度丢失的风险？

为什么会出现这个问题呢？

这个和计算机保存浮点数的机制有很大关系。我们知道计算机是二进制的，而且计算机在表示一个数字时，宽度是有限的，无限循环的小数存储在计算机时，只能被截断，所以就会导致小数精度发生损失的情况。这也就是解释了为什么浮点数没有办法用二进制精确表示。

16.成员变量与局部变量的区别？

• 语法形式：从语法形式上看，成员变量是属于类的，而局部变量是在代码块或方法中定义的变量或是方法的参数；成员变量可以被 public,private,static 等修饰符所修饰，而局部变量不能被访问控制修饰符及 static 所修饰；但是，成员变量和局部变量都能被 final 所修饰。
   
• 存储方式：从变量在内存中的存储方式来看，如果成员变量是使用 static 修饰的，那么这个成员变量是属于类的，如果没有使用 static 修饰，这个成员变量是属于实例的。而对象存在于堆内存，局部变量则存在于栈内存。
   
• 生存时间：从变量在内存中的生存时间上看，成员变量是对象的一部分，它随着对象的创建而存在，而局部变量随着方法的调用而自动生成，随着方法的调用结束而消亡。
   
• 默认值：从变量是否有默认值来看，成员变量如果没有被赋初始值，则会自动以类型的默认值而赋值（一种情况例外:被 final 修饰的成员变量也必须显式地赋值），而局部变量则不会自动赋值。
   

16：为什么成员变量有默认值？

• 先不考虑变量类型，如果没有默认值会怎样？变量存储的是内存地址对应的任意随机值，程序读取该值运行会出现意外。
   
• 默认值有两种设置方式：手动和自动，根据第一点，没有手动赋值一定要自动赋值。成员变量在运行时可借助反射等方法手动赋值，而局部变量不行。
   
• 对于编译器（javac）来说，局部变量没赋值很好判断，可以直接报错。而成员变量可能是运行时赋值，无法判断，误报“没默认值”又会影响用户体验，所以采用自动赋默认值。
   

17：静态变量有什么作用？

静态变量也就是被 static 关键字修饰的变量。它属于类本身，而不是类的实例（对象），即静态变量是类变量。

• 内存分配：静态变量在类加载时就被分配内存，并且只分配一次，所有对象共享同一份静态变量。
• 静态变量的生命周期与类的生命周期一致，只会在类被卸载时销毁。
• 静态变量在 方法区（JDK 8+ 中是堆的一个逻辑部分） 中分配内存，而不是栈或堆中。

它可以被类的所有实例共享，无论一个类创建了多少个对象，它们都共享同一份静态变量。也就是说，静态变量只会被分配一次内存，即使创建多个对象，这样可以节省内存。
 

静态变量是通过类名来访问的，例如StaticVariableExample.staticVar（如果被 private关键字修饰就无法这样访问了）。

注意事项和潜在问题

1.静态变量的初始化时机：

• • 静态变量在类加载时初始化，初始化顺序按照它们在类中声明的顺序执行。
  • 如果静态变量依赖其他静态变量的值，要注意声明顺序，避免出现意外的结果。

2.线程安全问题：

• • 静态变量是共享的，在多线程环境中，如果多个线程同时修改静态变量，可能导致线程安全问题。
  • 解决方案：可以使用 synchronized 或其他线程安全机制来保护静态变量。

public class ThreadSafeExample {private static int counter = 0;public synchronized static void increment() {counter++;}
}

3.生命周期问题：

• • 静态变量的生命周期很长，可能导致内存泄漏，特别是在引用了大对象时。
  • 要小心使用静态变量，避免其引用对象不被及时释放。

4.不要滥用静态变量：

• • 虽然静态变量方便访问，但如果使用过多，会导致类之间的耦合性增加，降低代码的灵活性和可测试性。

5. 示例代码总结

综合静态变量的特点和用法，可以用以下代码展示：

 

18：字符型常量和字符串常量的区别?
 

• 1.形式 : 字符常量是单引号引起的一个字符，字符串常量是双引号引起的 0 个或若干个字符。
   
• 2.含义 : 字符常量相当于一个整型值( ASCII 值),可以参加表达式运算; 字符串常量代表一个地址值(该字符串在内存中存放位置)。
   
• 3.占内存大小：字符常量只占 2 个字节; 字符串常量占若干个字节。
   
• 4.⚠️ 注意 char 在 Java 中占两个字节。
   

19：静态方法为什么不能调用非静态成员?
 

• 这个需要结合 JVM 的相关知识，主要原因如下：
   
• 静态方法是属于类的，在类加载的时候就会分配内存，可以通过类名直接访问。而非静态成员属于实例对象，只有在对象实例化之后才存在，需要通过类的实例对象去访问。
   
• 在类的非静态成员不存在的时候静态方法就已经存在了，此时调用在内存中还不存在的非静态成员，属于非法操作。
   

20：静态方法和实例方法有何不同？
 

• 1、调用方式
   
• 在外部调用静态方法时，可以使用 类名.方法名 的方式，也可以使用 对象.方法名 的方式，而实例方法只有后面这种方式。也就是说，调用静态方法可以无需创建对象 。
   
• 不过，需要注意的是一般不建议使用 对象.方法名 的方式来调用静态方法。这种方式非常容易造成混淆，静态方法不属于类的某个对象而是属于这个类。
   
• 因此，一般建议使用 类名.方法名 的方式来调用静态方法。
   
• 2、访问类成员是否存在限制
   
• 静态方法在访问本类的成员时，只允许访问静态成员（即静态成员变量和静态方法），不允许访问实例成员（即实例成员变量和实例方法），而实例方法不存在这个限制
   

21：重载和重写有什么区别？

重载就是同样的一个方法能够根据输入数据的不同，做出不同的处理
 

重写就是当子类继承自父类的相同方法，输入数据一样，但要做出有别于父类的响应时，你就要覆盖父类方法
重载
发生在同一个类中（或者父类和子类之间），方法名必须相同，参数类型不同、个数不同、顺序不同，方法返回值和访问修饰符可以不同。
《Java 核心技术》这本书是这样介绍重载的：
如果多个方法(比如 StringBuilder 的构造方法)有相同的名字、不同的参数， 便产生了重载。
编译器必须挑选出具体执行哪个方法，它通过用各个方法给出的参数类型与特定方法调用所使用的值类型进行匹配来挑选出相应的方法。 如果编译器找不到匹配的参数， 就会产生编译时错误， 因为根本不存在匹配， 或者没有一个比其他的更好(这个过程被称为重载解析(overloading resolution))。
Java 允许重载任何方法， 而不只是构造器方法。
综上：重载就是同一个类中多个同名方法根据不同的传参来执行不同的逻辑处理。
重写
重写发生在运行期，是子类对父类的允许访问的方法的实现过程进行重新编写。
方法名、参数列表必须相同，子类方法返回值类型应比父类方法返回值类型更小或相等，抛出的异常范围小于等于父类，访问修饰符范围大于等于父类。

如果父类方法访问修饰符为 private/final/static 则子类就不能重写该方法，但是被 static 修饰的方法能够被再次声明。

构造方法无法被重写
 

关于接口实现类中的重写

接口实现类中的“重写”也属于方法的重写（Overriding）。这是因为接口中的方法在实现类中需要重新定义具体的实现。

注意点：

接口中的方法默认是 public abstract，因此在实现类中必须定义为 public。

• • 如果不加 public，会出现编译错误，因为子类不能缩小父类（或接口）方法的访问权限。
  • 示例：

interface ExampleInterface {void display();
}class ExampleImpl implements ExampleInterface {@Overridepublic void display() {System.out.println("Implementing interface method");}
}

接口中可以有默认方法（default 方法）和静态方法：

• • 默认方法可以被子类重写。
  • 静态方法不能被重写，只能被隐藏。
  • 示例：

interface ExampleInterface {default void defaultMethod() {System.out.println("Default method in interface");}static void staticMethod() {System.out.println("Static method in interface");}
}class ExampleImpl implements ExampleInterface {@Overridepublic void defaultMethod() {System.out.println("Overridden default method");}// static 方法不能重写// 只能隐藏，通过类名调用
}public class InterfaceExample {public static void main(String[] args) {ExampleImpl impl = new ExampleImpl();impl.defaultMethod(); // 输出：Overridden default methodExampleInterface.staticMethod(); // 输出：Static method in interface}
}

1. 接口实现类的“重写” vs 继承父类的重写：

• • 实现接口的方法重写属于接口规范的实现。
  • 重写父类方法是对父类行为的定制化改写。

• 重载（Overloading）是编译期行为，方法名相同但参数列表不同。
• 重写（Overriding）是运行期行为，子类对父类方法进行改写，必须遵循方法签名的一致性。
• 接口实现中的重写是接口规范的一部分，必须遵循接口方法的访问修饰符（public）规则。

总结
综上：重写就是子类对父类方法的重新改造，外部样子不能改变，内部逻辑可以改变。
区别点重载方法重写方法
发生范围 同一个类 子类
参数列表 必须修改 一定不能修改
返回类型 可修改 子类方法返回值类型应比父类方法返回值类型更小或相等
异常 可修改 子类方法声明抛出的异常类应比父类方法声明抛出的异常类更小或相等；
访问修饰符 可修改 一定不能做更严格的限制（可以降低限制）
发生阶段 编译期 运行期
方法的重写要遵循“两同两小一大”（以下内容摘录自《疯狂 Java 讲义》，open in new window ）：
两同”即方法名相同、形参列表相同；
“两小”指的是子类方法返回值类型应比父类方法返回值类型更小或相等，子类方法声明抛出的异常类应比父类方法声明抛出的异常类更小或相等；

“一大”指的是子类方法的访问权限应比父类方法的访问权限更大或相等。
关于 重写的返回值类型 这里需要额外多说明一下，上面的表述不太清晰准确：如果方法的返回类型是 void 和基本数据类型，则返回值重写时不可修改。但是如果方法的返回值是引用类型，重写时是可以返回该引用类型的子类的。
 

22.什么是可变长参数？
 

• 从 Java5 开始，Java 支持定义可变长参数，所谓可变长参数就是允许在调用方法时传入不定长度的参数。就比如下面的这个 printVariable 方法就可以接受 0 个或者多个参数。
• public static void method1(String... args) { //......}
• 另外，可变参数只能作为函数的最后一个参数，但其前面可以有也可以没有任何其他参数。
• public static void method2(String arg1, String... args) { //......}
• 遇到方法重载的情况怎么办呢？会优先匹配固定参数还是可变参数的方法呢？
• 答案是会优先匹配固定参数的方法，因为固定参数的方法匹配度更高。

23.面向对象和面向过程的区别：

两者的主要区别在于解决问题的方式不同：

面向过程把解决问题的过程拆成一个个方法，通过一个个方法的执行解决问题。（性能比面向对象高，可维护性差）

面向对象会先抽象出对象，然后用对象执行方法的方式解决问题。（易维护、易复用、易扩展，性能比面向过程低。）

24.创建一个对象用什么运算符？对象实体与对象引用的不同？

1. 创建对象用什么运算符？

• • new 运算符用于创建对象实例。它会在堆内存中分配空间并调用类的构造方法初始化对象。
  • 示例：

MyClass obj = new MyClass(); // 使用 new 创建对象

• 其他方式创建对象（补充）： 除了使用 new 运算符，还有其他方法可以创建对象：

1. 1. 使用反射（Reflection）：

MyClass obj = (MyClass) Class.forName("MyClass").newInstance();

1. 1. 使用克隆（Clone）：

MyClass obj = originalObj.clone(); // 调用 clone() 方法

1. 1. 通过反序列化（Deserialization）：

ObjectInputStream in = new ObjectInputStream(new FileInputStream("file.ser"));
MyClass obj = (MyClass) in.readObject();

1. 1. 使用工厂方法：

• • • 某些类提供工厂方法来创建实例，例如 Calendar.getInstance() 或 ThreadFactory.newThread()。

Calendar calendar = Calendar.getInstance();

2. 对象实体与对象引用的不同

对象实体和对象引用是 Java 中两个不同的概念：

(1) 对象引用

• • 定义：对象引用是一个变量，存储了堆内存中某个对象实例的内存地址。对象引用本身存储在栈内存中。
  • 作用：对象引用是访问堆中对象实例的入口。
  • 特性：

1. 1. 1. 可以有多个引用指向同一个对象。
      2. 如果引用不再指向对象实例（例如赋值为 null），该对象实例可能会被垃圾回收（GC）。

(2) 对象实体

• • 定义：对象实体是 new 运算符在堆内存中分配的内存块，它包含实际的数据和方法的引用。
  • 作用：对象实体存储类的成员变量值、对象头（包含类型信息、GC 信息）等。
  • 特性：

1. 1. 1. 对象实体总是在堆内存中分配。
      2. 每个对象实例都有唯一的实体，但可以被多个引用指向。

3. 对象引用和对象实体的内存分布

内存结构示例：

MyClass obj = new MyClass();

1. 1. 1. 堆内存：

• • new MyClass() 创建的对象实体存储在堆内存中。
  • 对象的成员变量（实例变量）和对象头信息存储在堆中。

1. 1. 1. 栈内存：

• • 变量 obj 是一个引用，存储对象实体的内存地址。
  • obj 本身存储在栈内存中。

图解：

栈内存                堆内存
---------            -------------------
| obj    |  -------> | MyClass 实体     |
---------            | - 成员变量值      || - 对象头信息      |-------------------

4. 对象引用与对象实体的常见问题

(1) 多个引用指向同一个对象

MyClass obj1 = new MyClass();
MyClass obj2 = obj1; // obj2 引用与 obj1 指向同一个对象
obj2.value = 10;     // 改变 obj2 的值会影响 obj1System.out.println(obj1.value); // 输出 10

(2) 引用的重新赋值

MyClass obj = new MyClass();
obj = null; // 引用 obj 不再指向堆内存中的对象
// 如果没有其他引用指向该对象，它将被垃圾回收

(3) 对象实体的垃圾回收

• • • 如果对象的引用被置为 null，或者引用超出作用域，堆中的对象实体可能会被垃圾回收（由 JVM 的 GC 管理）。

5. 示例代码总结

以下代码展示了对象引用和对象实体的不同，以及它们的内存分布：

class MyClass {int value;public MyClass(int value) {this.value = value;}
}public class Main {public static void main(String[] args) {// 创建对象MyClass obj1 = new MyClass(10); // obj1 是引用，指向堆中的实体MyClass obj2 = obj1; // obj2 也是引用，指向相同的对象实体System.out.println("obj1 value: " + obj1.value); // 输出 10System.out.println("obj2 value: " + obj2.value); // 输出 10// 改变 obj2 的值obj2.value = 20;// obj1 和 obj2 的值都会改变System.out.println("obj1 value after change: " + obj1.value); // 输出 20System.out.println("obj2 value after change: " + obj2.value); // 输出 20// 引用置为 nullobj1 = null;// obj2 仍然指向对象实体System.out.println("obj2 value after obj1 null: " + obj2.value); // 输出 20}
}

为了让回答更完整，可以归纳以下要点：

1. 对象创建方式：

• • 主要使用 new 运算符，也可以通过反射、克隆、反序列化等方式创建对象。

1. 对象引用与对象实体的区别：

• • 对象引用是指向对象实体的地址，存储在栈内存中。
  • 对象实体是实际的数据，存储在堆内存中。

1. 内存分布：

• • 引用存储在栈，实体存储在堆。

1. 常见问题：

• • 多个引用指向同一个对象时的影响。
  • 垃圾回收机制如何处理无用对象。

25：Java 创建对象有哪几种方式？

使用 new 关键字调用对象的构造器创建对象。

使用 Java 反射的 newInstance() 方法。

使用 Object 类的 clone() 方法。

使用对象流 ObjectInputStream 的 readObject() 方法读取序列化对象

package testInterview;
class MyClass {String name;public MyClass() {this.name = "Reflection";}public void display() {System.out.println("Name: " + name);}
}public class Reflect {public static void main(String[] args) {try {// 使用反射创建对象MyClass obj = (MyClass) Class.forName("testInterview.MyClass").newInstance();obj.display(); // 输出：Name: Reflection} catch (ClassNotFoundException | InstantiationException | IllegalAccessException e) {e.printStackTrace();}}
}

package testInterview;
import java.io.*;
class MyClass1 implements Serializable {String name;public MyClass1(String name) {this.name = name;}public void display() {System.out.println("Name: " + name);}
}
public class SerializationExample {public static void main(String[] args) {String fileName = "object.ser";// 序列化对象到文件try (ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(fileName))) {MyClass1 obj = new MyClass1("Serialized");out.writeObject(obj);} catch (IOException e) {e.printStackTrace();}// 反序列化对象try (ObjectInputStream in = new ObjectInputStream(new FileInputStream(fileName))) {MyClass1 deserializedObj = (MyClass1) in.readObject();deserializedObj.display(); // 输出：Name: Serialized} catch (IOException | ClassNotFoundException e) {e.printStackTrace();}}
}

package testInterview;
class MyClass2 implements Cloneable {String name;public MyClass2(String name) {this.name = name;}@Overrideprotected Object clone() throws CloneNotSupportedException {return super.clone();}public void display() {System.out.println("Name: " + name);}
}
public class CloneExample {public static void main(String[] args) {try {// 原始对象MyClass2 original = new MyClass2("Original");// 使用 clone() 创建新对象MyClass2 cloned = (MyClass2) original.clone();// 修改克隆对象的值（测试克隆效果）cloned.name = "Cloned";original.display(); // 输出：Name: Originalcloned.display();   // 输出：Name: Cloned} catch (CloneNotSupportedException e) {e.printStackTrace();}}
}

26.对象相等和引用相等有什么区别：

引用相等一般比较的是他们指向的内存地址是否相等。

对象的相等一般比较的是内存中存放的内容是否相等。

27.如果一个类没有声明构造方法，改程序还能正确执行吗？

如果一个类没有声明构造方法，也可以执行！因为一个类即使没有声明构造方法也会有默认的不带参数的构造方法。如果我们自己添加了类的构造方法（无论是否有参），Java 就不会添加默认的无参数的构造方法了。（构造方法是一种特殊的方法，主要作用是完成对象的初始化工作）

28.构造方法有哪些特点，可否被override？

构造方法特点如下：1.名字与类名相同。2.没有返回值，但不能用 void 声明构造函数。3.生成类的对象时自动执行，无需调用。

构造方法不能被 override（重写）,但是可以 overload（重载）,所以你可以看到一个类中有多个构造函数的情况。

29.说说你对面向对象的理解？（封装、继承、多态。）

封装：封装是指将对象的状态信息隐藏在对象内部,不允许外部程序直接访问对象内部信息,让外部程序通过该类提供的方法来实现对内部信息的操作和访问,这种做法有助于规范使用者的行为,让使用者只能通过事先预定的方法访问数据,提高了代码的可维护性；

继承：其中,继承是面向对象实现代码复用的重要手段,Java通过extends作为关键字实现类的继承,实现继承的类被称为子类,被继承的类称为父类（继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类。通过使用继承，可以快速地创建新的类，可以提高代码的重用，程序的可维护性）

多态：多态的实现离不开继承,在设计程序时,我们可以将参数的类型定义为父类型。在调用程序时,则可以根据实际情况,传入该父类型的某个子类型的实例,这样就实现了多态。

// 父类：Animal
class Animal {// 通用方法public void makeSound() {System.out.println("Some generic animal sound");}
}
// 子类：Dog
class Dog extends Animal {@Overridepublic void makeSound() {System.out.println("Woof! Woof!");}
}
// 子类：Cat
class Cat extends Animal {@Overridepublic void makeSound() {System.out.println("Meow! Meow!");}
}
// 子类：Cow
class Cow extends Animal {@Overridepublic void makeSound() {System.out.println("Moo! Moo!");}
}
// 测试类
public class PolymorphismExample {public static void main(String[] args) {// 使用父类类型引用不同的子类对象Animal myAnimal;// Dog 对象myAnimal = new Dog();myAnimal.makeSound(); // 输出：Woof! Woof!// Cat 对象myAnimal = new Cat();myAnimal.makeSound(); // 输出：Meow! Meow!// Cow 对象myAnimal = new Cow();myAnimal.makeSound(); // 输出：Moo! Moo!}
}

30：继承特点有哪些：

子类拥有父类对象所有的属性和方法（包括私有属性和私有方法），但是父类中的私有属性和方法子类是无法访问，只是拥有。

子类可以拥有自己属性和方法，即子类可以对父类进行扩展。

子类可以用自己的方式实现父类的方法。

子类继承父类的所有属性和方法

• 包含私有属性和方法：

• • 子类虽然无法直接访问父类的私有属性和方法，但它们仍然是子类对象的一部分，间接可以通过父类的公共方法（如 getter 和 setter 方法）来访问。
  • 示例：

class Parent {private String privateField = "private";public String getPrivateField() {return privateField;}
}class Child extends Parent {public void display() {// System.out.println(privateField); // 编译错误，无法直接访问System.out.println(getPrivateField()); // 间接访问父类的私有属性}
}

(2) 子类可以扩展自己的属性和方法

• 子类不仅继承了父类的属性和方法，还可以定义自己的属性和方法。
• 示例：

class Parent {public void parentMethod() {System.out.println("Parent Method");}
}class Child extends Parent {public void childMethod() {System.out.println("Child Method");}
}public class Main {public static void main(String[] args) {Child child = new Child();child.parentMethod(); // 调用父类方法child.childMethod();  // 调用子类方法}
}

(3) 子类可以用自己的方式实现父类的方法（重写）

• 子类通过方法重写（@Override）的方式重新定义父类的方法，实现不同的功能。
• 特点：

• • 方法名、参数列表必须与父类方法一致。
  • 返回值类型必须是父类方法返回值类型的相同类型或子类型（协变返回类型）。
  • 子类方法的访问修饰符不能比父类更严格。
  • 被 final 修饰的方法不能被重写。

• 示例：

class Parent {public void show() {System.out.println("Parent Show");}
}class Child extends Parent {@Overridepublic void show() {System.out.println("Child Show");}
}public class Main {public static void main(String[] args) {Parent parent = new Child();parent.show(); // 输出：Child Show（多态特性）}
}

2. Java 继承的规则与限制

(1) 单继承

• Java 中的类只允许单继承，即一个子类只能有一个直接父类。
• 目的：避免因为多继承导致的菱形继承问题（多个父类有同名方法或属性时的冲突）。

(2) 子类构造方法的特点

• 子类的构造方法默认会调用父类的无参构造方法（隐式调用 super()）。
• 如果父类没有无参构造方法，子类的构造方法必须通过 super(parameters) 显式调用父类的有参构造方法。
• 示例：

class Parent {public Parent(String message) {System.out.println("Parent Constructor: " + message);}
}class Child extends Parent {public Child(String message) {super(message); // 显式调用父类构造方法}
}public class Main {public static void main(String[] args) {Child child = new Child("Hello Parent");// 输出：Parent Constructor: Hello Parent}
}

(3) 子类不能继承父类的构造方法

• 构造方法不继承，因为子类的构造方法是为了初始化子类对象，不适合直接沿用父类构造方法。

---

3. 继承的优点

1. 代码复用性：

• • 父类的属性和方法可以被多个子类复用，避免重复编写代码。

1. 扩展性：

• • 子类可以扩展父类的功能，通过新增方法或重写父类的方法，满足更多的需求。

1. 多态性：

• • 继承是多态的前提，父类引用可以指向子类对象，从而提高代码的灵活性。

---

4. 继承的局限性和注意事项

(1) 继承破坏封装性

• 如果父类有公共的实现细节暴露给子类，可能会破坏封装性。
• 解决方法：将不希望被直接继承的属性和方法声明为 private，通过 protected 或 public 方法间接访问。

(2) 子类强依赖于父类

• 子类过于依赖父类的实现，如果父类发生修改，可能会影响到子类的行为。

(3) 不能多继承类

• Java 不支持多继承类，可以通过**接口（interface）**实现类似功能。

(4) 需要谨慎使用继承

• 继承表达的是一种**“is-a”**关系（子类是父类的一种），只有在逻辑上确实存在这种关系时才应该使用继承。例如：

• • 狗（Dog）是动物（Animal）的一种，可以用继承。
  • 如果没有“is-a”关系（例如 Car 和 Employee），应该避免继承。

---

5. 示例：综合演示继承的特点

// 父类：Animal
class Animal {protected String name;public Animal(String name) {this.name = name;}public void makeSound() {System.out.println(name + " makes a sound");}
}// 子类：Dog
class Dog extends Animal {public Dog(String name) {super(name); // 调用父类构造方法}@Overridepublic void makeSound() {System.out.println(name + " barks");}public void fetch() {System.out.println(name + " fetches a ball");}
}// 子类：Cat
class Cat extends Animal {public Cat(String name) {super(name);}@Overridepublic void makeSound() {System.out.println(name + " meows");}
}// 测试类
public class InheritanceExample {public static void main(String[] args) {// 父类引用指向子类对象（多态性）Animal myAnimal = new Dog("Buddy");myAnimal.makeSound(); // 输出：Buddy barks// 调用子类特有方法需要强制类型转换if (myAnimal instanceof Dog) {Dog myDog = (Dog) myAnimal;myDog.fetch(); // 输出：Buddy fetches a ball}// 子类独有方法和继承特性Cat myCat = new Cat("Kitty");myCat.makeSound(); // 输出：Kitty meows}
}

---

总结

继承的特点：

1. 子类继承父类的所有属性和方法，但私有属性和方法只能通过公共方法间接访问。
2. 子类可以扩展自己的属性和方法。
3. 子类可以通过重写父类方法实现不同的功能。
4. Java 支持单继承，不支持多继承（通过接口实现）。
5. 子类构造方法必须调用父类构造方法。

优点：

• 提高代码复用性。
• 增强扩展性。
• 支持多态，提高灵活性。

注意事项：

• 需要正确设计父子类之间的关系，避免破坏封装性。
• 继承只适用于“is-a”关系，不能滥用。

31.多态特点有哪些：

对象类型和引用类型之间具有继承（类）/实现（接口）的关系；

引用类型变量发出的方法调用的到底是哪个类中的方法，必须在程序运行期间才能确定；

多态不能调用“只在子类存在但在父类不存在”的方法；

如果子类重写了父类的方法，真正执行的是子类重写的方法，如果子类没有重写父类的方法，执行的是父类的方法。

32.获取一个类对象的几种方式？

通过类对象的 getClass() 方法获取，即 A.getClass().

通过类的静态成员表示，每个类都有隐含的静态成员 class，即 A.class.

通过 Class 类的静态方法 forName() 方法获取，即 Class.forName().

通过类加载器 xxxClassLoader.loadClass() 传入类路径获取

package testInterview.getObject;
class MyClass {// 一个简单类
}
public class GetClassExample {public static void main(String[] args) {MyClass myObject = new MyClass(); // 创建对象Class<?> clazz = myObject.getClass(); // 通过 getClass() 获取类对象System.out.println("Class name: " + clazz.getName()); // 输出类名Class<?> clazz1 = MyClass.class; // 通过类名.class 获取类对象System.out.println("Class name: " + clazz1.getName()); // 输出类名try {// 通过 Class.forName 获取类对象Class<?> clazz2 = Class.forName("MyClass"); // 类名必须是全限定名（包名 + 类名）System.out.println("Class name: " + clazz2.getName()); // 输出类名} catch (ClassNotFoundException e) {e.printStackTrace();}try {// 获取当前线程的上下文类加载器ClassLoader classLoader = Thread.currentThread().getContextClassLoader();// 使用类加载器加载类Class<?> clazz3 = classLoader.loadClass("MyClass"); // 类名必须是全限定名System.out.println("Class name: " + clazz3.getName()); // 输出类名} catch (ClassNotFoundException e) {e.printStackTrace();}}
}

33.接口和抽象类有什么区别？

共同点：

都不能被实例化。

都可以包含抽象方法。

都可以有默认实现的方法

区别：

接口主要用于对类的行为进行约束，你实现了某个接口就具有了对应的行为。抽象类主要用于代码复用，强调的是所属关系。

一个类只能继承一个类，但是可以实现多个接口。

接口中的成员变量只能是 public static final 类型的，不能被修改且必须有初始值，而抽象类的成员变量默认 default，可在子类中被重新定义，也可被重新赋值。

34.什么是浅拷贝与深拷贝？有什么区别？

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

浅拷贝

定义：

• 浅拷贝会在堆内存中创建一个新的对象。
• 对于基本数据类型的属性，浅拷贝会复制值。
• 对于引用类型的属性，浅拷贝会复制引用地址（即原对象和拷贝对象共享同一个引用类型的内部对象）。

package testInterview.copyObject;
class Address {String city;public Address(String city) {this.city = city;}
}
class Person implements Cloneable {String name;Address address; // 引用类型public Person(String name, Address address) {this.name = name;this.address = address;}@Overrideprotected Object clone() throws CloneNotSupportedException {return super.clone(); // 浅拷贝}
}
public class ShallowCopyExample {public static void main(String[] args) {try {// 原始对象Address address = new Address("New York");Person originalPerson = new Person("John", address);// 浅拷贝对象Person shallowCopyPerson = (Person) originalPerson.clone();// 打印原始对象和拷贝对象的地址信息System.out.println("Original Person Address: " + originalPerson.address.city); // New YorkSystem.out.println("Shallow Copy Person Address: " + shallowCopyPerson.address.city); // New York// 修改浅拷贝对象的地址信息shallowCopyPerson.address.city = "Los Angeles";// 检查原始对象的地址信息System.out.println("Original Person Address after modification: " + originalPerson.address.city); // Los Angeles} catch (CloneNotSupportedException e) {e.printStackTrace();}}
}

输出：

Original Person Address: New York
Shallow Copy Person Address: New York
Original Person Address after modification: Los Angeles

分析：

• • 浅拷贝对象 shallowCopyPerson 的 address 属性只是复制了原始对象 originalPerson 的引用地址。
  • 修改 shallowCopyPerson.address.city 会影响 originalPerson.address.city，因为它们共享同一个引用。

深拷贝：深拷贝会完全复制整个对象，包括这个对象所包含的内部对象。

定义：

• 深拷贝会完全复制整个对象，包括内部的引用类型属性。
• 深拷贝后，原对象和拷贝对象的引用类型属性指向不同的内存地址，即相互独立。

实现深拷贝的方式：

• 手动复制每个引用类型的属性。
• 通过序列化与反序列化实现深拷贝（推荐）。
• 使用第三方库如 Apache Commons Lang 的 SerializationUtils

package testInterview.copyObject;
class Address1 {String city;public Address1(String city) {this.city = city;}// 深拷贝的实现public Address1 deepCopy() {return new Address1(this.city);}
}
class Person1 implements Cloneable {String name;Address1 address;public Person1(String name, Address1 address) {this.name = name;this.address = address;}// 深拷贝方法public Person1 deepCopy() {return new Person1(this.name, this.address.deepCopy());}
}
public class DeepCopyExample {public static void main(String[] args) {// 原始对象Address1 address = new Address1("New York");Person1 originalPerson = new Person1("John", address);// 深拷贝对象Person1 deepCopyPerson = originalPerson.deepCopy();// 打印原始对象和深拷贝对象的地址信息System.out.println("Original Person Address: " + originalPerson.address.city); // New YorkSystem.out.println("Deep Copy Person Address: " + deepCopyPerson.address.city); // New York// 修改深拷贝对象的地址信息deepCopyPerson.address.city = "Los Angeles";// 检查原始对象的地址信息System.out.println("Original Person Address after modification: " + originalPerson.address.city); // New York}
}

顺便一提：引用拷贝，就是指两个不同的引用指向同一个对象。

35.Java 中的自动类型转换

自动类型转换遵循下面的规则：

若参与运算的数据类型不同，则先转换成同一类型，然后进行运算

转换按数据长度增加的方向进行，以保证精度不降低。例如 int 型和 long 型运算时，先把 int 型转成 long 型后再进行运算

所有的浮点运算都是以双精度进行的，即使仅含 float 单精度量运算的表达式，也要先转换成 double 型，再做运算

char 型和 short 型参与运算时，必须先转换成 int 型。

36.==和equals的区别？

1.== 对于基本类型和引用类型的作用效果是不同的：对于基本数据类型来说，== 比较的是值。对于引用数据类型来说，== 比较的是对象的内存地址。

2.equals() 不能用于判断基本数据类型的变量，只能用来判断两个对象是否相等。equals()方法存在于Object类中，而Object类是所有类的直接或间接父类，因此所有的类都有equals()方法因为 Java 只有值传递，所以，对于 == 来说，不管是比较基本数据类型，还是引用数据类型的变量，其本质比较的都是值，只是引用类型变量存的值是对象的地址。

（总的来说，对于引用类型，==比较的是内存地址，equals比较的是值）

(1) == 的作用

• 基本数据类型：== 比较两个变量的值是否相等。
• 引用数据类型：== 比较两个对象的内存地址是否相同，即是否指向同一个对象。

(2) equals 的作用

• 默认行为（Object 类中的实现）：

• • equals 方法默认是从 Object 类继承而来的，它的默认实现是比较两个对象的内存地址，即 equals 的默认行为和 == 是一致的。

• 重写行为：

• • 在大多数类中（如 String、Integer、List 等），equals 方法被重写，用于比较两个对象的内容是否相同，而不是内存地址。

2. 底层原理

(1) == 的底层原理

• 对于基本数据类型：

• • 直接比较的是两个变量在栈中存储的值是否相同。
  • 示例：

int a = 10;
int b = 10;
System.out.println(a == b); // true，比较的是值

• 对于引用数据类型：

• • 比较的是两个引用在栈中存储的堆内存地址是否相同。
  • 示例：

String s1 = new String("hello");
String s2 = new String("hello");
System.out.println(s1 == s2); // false，堆内存中两个不同的地址

(2) equals 的底层原理

• equals 是 Object 类中的方法，默认实现如下：

public boolean equals(Object obj) {
return (this == obj); // 默认比较内存地址
}

• 重写后的行为：

• • 当某个类（如 String）重写了 equals 方法时，它会比较对象的内容是否相同。
  • 示例（String 类的重写实现）：

public boolean equals(Object anObject) {
if (this == anObject) { // 如果内存地址相同，直接返回 truereturn true;
}
if (anObject instanceof String) { // 判断类型是否相同String anotherString = (String) anObject;int n = value.length;if (n == anotherString.value.length) {char v1[] = value;char v2[] = anotherString.value;int i = 0;while (n-- != 0) {if (v1[i] != v2[i])return false; // 如果内容不同，返回 falsei++;}return true; // 如果内容相同，返回 true}
}
return false;
}

---

37. 为什么 == 比较的是地址，equals 比较的是值？

(1) == 是运算符，本质上直接作用于内存地址

• 对于引用类型，== 的实现是直接比较两个变量在栈中存储的堆内存地址，因此它只能判断是否指向同一个对象。
• 原因：

• • == 是语言级别的运算符，它没有抽象层，直接比较内存地址。

(2) equals 是方法，可以被重写

• equals 方法存在于 Object 类中，其默认实现是比较地址，符合最基础的对象比较需求。
• 当对象的语义需要更复杂的比较时（如内容相同），我们可以在子类中重写 equals 方法。
• 示例：

• • String、Integer 等类的 equals 方法被重写，用于比较内容而不是地址。
  • 设计理念：这样可以让不同类根据自身需求，定义不同的“相等”逻辑。

38.引用类型与包装类型的关系？

引用类型不仅限于包装类型。

引用类型是Java中的一种数据类型，它包括了所有的对象类型，如数组、类实例、接口实例等。包装类型只是引用类型的一个子集，它们为Java的八种基本数据类型提供了对应的对象表示，使得基本数据类型可以拥有对象的特性，如能够被赋值给变量、作为方法参数传递、存储在对象集合中等。

39.java中的引用类型包括哪些？

具体来说，Java中的引用类型包括：

数组：无论是基本数据类型的数组还是对象的数组，都是引用类型。

类实例：通过new关键字创建的对象，如自定义类的实例或内置类（如String）的实例。

接口实例：实现了某个接口的类的实例。

包装类型：与基本数据类型对应的包装类，如Integer、Double等。

需要注意的是，引用类型在参数传递时是按引用传递的，这意味着当传递一个对象作为方法参数时，方法内部对这个对象的修改会影响到原始对象。这与基本数据类型的按值传递形成对比，基本数据类型的按值传递意味着方法内部对参数的修改不会影响原始值。

40.equals() 方法存在两种使用情况

类没有重写 equals()方法：通过equals()比较该类的两个对象时，等价于通过“==”比较这两个对象，使用的默认是 Object类equals()方法。

类重写了 equals()方法：一般我们都重写 equals()方法来比较两个对象中的属性是否相等；若它们的属性相等，则返回 true(即，认为这两个对象相等)。

41.HashCode的作用？

hashCode() 的作用是获取哈希码（int 整数），也称为散列码。这个哈希码的作用是确定该对象在哈希表中的索引位置。

hashCode() 定义在 JDK 的 Object 类中，这就意味着 Java 中的任何类都包含有 hashCode() 函数。另外需要注意的是：Object 的 hashCode() 方法是本地方法，也就是用 C 语言或 C++ 实现的。

42.为什么要有HashCode？

这个问题以Hash Set为例，

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

43：hashCode() 和 equals()都是用于比较两个对象是否相等。那为什么 JDK 还要同时提供这两个方法呢？

这是因为在一些容器（比如 HashMap、HashSet）中，有了 hashCode() 之后，判断元素是否在对应容器中的效率会更高，

前面也提到了添加元素进HashSet的过程，如果 HashSet 在对比的时候，同样的 hashCode 有多个对象，它会继续使用 equals() 来判断是否真的相同。也就是说 hashCode 帮助我们大大缩小了查找成本。

44：那为什么不只提供 hashCode() 方法呢？

这是因为两个对象的hashCode 值相等并不代表两个对象就相等。

45：那为什么两个对象有相同的 hashCode 值，它们也不一定是相等的？

因为 hashCode() 所使用的哈希算法也许刚好会让多个对象传回相同的哈希值。越糟糕的哈希算法越容易碰撞，但这也与数据值域分布的特性有关（所谓哈希碰撞也就是指的是不同的对象得到相同的 hashCode )。

总的来说就是：

如果两个对象的hashCode 值相等，那这两个对象不一定相等（哈希碰撞）。

如果两个对象的hashCode 值相等并且equals()方法也返回 true，我们才认为这两个对象相等。

如果两个对象的hashCode 值不相等，我们就可以直接认为这两个对象不相等

46.为什么重写equals就必须重写hashCode方法？

因为两个相等的对象的 hashCode 值必须是相等。也就是说如果 equals 方法判断两个对象是相等的，那这两个对象的 hashCode 值也要相等。

如果重写 equals() 时没有重写 hashCode() 方法的话就可能会导致 equals 方法判断是相等的两个对象，hashCode 值却不相等。（这也就将导致两个相同的对象同时出现在HashSet中的情况）

思考：重写 equals() 时没有重写 hashCode() 方法的话，使用 HashMap 可能会出现什么问题。总结：equals 方法判断两个对象是相等的，那这两个对象的 hashCode 值也要相等。两个对象有相同的 hashCode 值，他们也不一定是相等的（哈希碰撞）。

47.String、StringBuffer 和 StringBuilder 区别及使用场景？

1.可变性：

String 是不可变的（String 类底层使用 final 关键字修饰的字符数组来保存字符串，private final char value[]，所以 String 对象是不可变的。）。

StringBuilder 与 StringBuffer 都继承自 AbstractStringBuilder 类，在 AbstractStringBuilder 中也是使用字符数组保存字符串，不过没有使用 final 和 private 关键字修饰，最关键的是这个 AbstractStringBuilder 类还提供了很多修改字符串的方法比如 append 方法

2.线程安全性

String 中的对象是不可变的，也就可以理解为常量，线程安全。

AbstractStringBuilder 是 StringBuilder 与 StringBuffer 的公共父类，定义了一些字符串的基本操作，如 expandCapacity、append、insert、indexOf 等公共方法。

StringBuffer 对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的。StringBuilder 并没有对方法进行加同步锁，所以是非线程安全的。

3.性能

每次对 String 类型进行改变的时候，都会生成一个新的 String 对象，然后将指针指向新的 String 对象。

StringBuffer 每次都会对 StringBuffer 对象本身进行操作，而不是生成新的对象并改变对象引用。相同情况下使用 StringBuilder 相比使用 StringBuffer 仅能获得 10%~15% 左右的性能提升，但却要冒多线程不安全的风险。

操作少量的数据:

适用 String对于三者使用的总结：

单线程操作字符串缓冲区下操作大量数据: 适用 StringBuilder

多线程操作字符串缓冲区下操作大量数据: 适用 StringBuffer

想要效率就优先使用 StringBuilder，多线程使用共享变量时使用 StringBuffer.

48.String为什么是不可变的？

我们知道被 final 关键字修饰的类不能被继承，修饰的方法不能被重写，修饰的变量是基本数据类型则值不能改变，修饰的变量是引用类型则不能再指向其他对象。因此，final 关键字修饰的数组保存字符串并不是 String 不可变的根本原因，因为这个数组保存的字符串是可变的（final 修饰引用类型变量的情况）。

String 真正不可变有下面几点原因：

保存字符串的数组被 final 修饰且为私有的，并且String 类没有提供/暴露修改这个字符串的方法。String 类被 final 修饰导致其不能被继承，进而避免了子类破坏 String 不可变。

之所以要把 String 类设计为不可变类，主要是出于安全和性能的考虑，可归纳为如下三点：

字符串通常会用来存储敏感信息（如账号，密码等），保证字符串 String 类的安全性就尤为重要了，如果字符串是可变的，容易被篡改，那我们就无法保证使用字符串进行操作时，它是安全的，很有可能出现 SQL 注入，访问危险文件等操作。

在多线程中，只有不变的对象和值是线程安全的，可以在多个线程中共享数据。由于 String 天然的不可变，当一个线程”修改“了字符串的值，只会产生一个新的字符串对象，不会对其他线程的访问产生副作用，访问的都是同样的字符串数据，不需要任何同步操作。

当字符串不可变时，字符串常量池才有意义。字符串常量池的出现，可以减少创建相同字面量的字符串，让不同的引用指向池中同一个字符串，为运行时节约很多的堆内存。若字符串可变，字符串常量池失去意义，基于常量池的 String.intern() 方法也失效，每次创建新的字符串将在堆内开辟出新的空间，占据更多的内存。

49.String的equals和Object的equals的区别？

String 中的 equals 方法是被重写过的，比较的是 String 字符串的值是否相等。 Object 的 equals 方法是比较的对象的内存地址。

50.字符串常量池的作用了解吗？

字符串常量池 是 JVM 为了提升性能和减少内存消耗针对字符串（String 类）专门开辟的一块区域，主要目的是为了避免字符串的重复创建。

51.String str = new String(“abc”) 创建了几个对象？

会创建 1 或 2 个字符串对象。

1、如果字符串常量池中不存在字符串对象“abc”的引用，那么它会在堆上创建两个字符串对象，其中一个字符串对象的引用会被保存在字符串常量池中。

ldc 命令用于判断字符串常量池中是否保存了对应的字符串对象的引用，如果保存了的话直接返回，如果没有保存的话，会在堆中创建对应的字符串对象并将该字符串对象的引用保存到字符串常量池中。

2、如果字符串常量池中已存在字符串对象“abc”的引用，则只会在堆中创建 1 个字符串对象“abc”。

52.String 的intern方法有什么作用？

String.intern() 是一个 native（本地）方法，其作用是将指定的字符串对象的引用保存在字符串常量池中，可以简单分为两种情况：

1.如果字符串常量池中保存了对应的字符串对象的引用，就直接返回该引用。

2.如果字符串常量池中没有保存了对应的字符串对象的引用，那就在常量池中创建一个指向该字符串对象的引用并返回。

53.拼接使用”+“还是StringBuilder？

Java 语言本身并不支持运算符重载，“+”和“+=”是专门为 String 类重载过的运算符，也是 Java 中仅有的两个重载过的运算符。

字符串对象通过“+”的字符串拼接方式，实际上是通过 StringBuilder 调用 append() 方法实现的，拼接完成之后调用 toString() 得到一个 String 对象 。

不过，在循环内使用“+”进行字符串的拼接的话，存在比较明显的缺陷：编译器不会创建单个 StringBuilder 以复用，会导致创建过多的 StringBuilder 对象。

StringBuilder 对象是在循环内部被创建的，这意味着每循环一次就会创建一个 StringBuilder 对象。（也可以说是多了String对象）

如果直接使用 StringBuilder 对象进行字符串拼接的话，就不会存在这个问题了。

String 类型的变量和常量做“+”运算时发生了什么？
 

• • 先来看字符串不加 final 关键字拼接的情况（JDK1.8）：
     
  • String str1 = "str";String str2 = "ing";String str3 = "str" + "ing";String str4 = str1 + str2;String str5 = "string";System.out.println(str3 == str4);//falseSystem.out.println(str3 == str5);//trueSystem.out.println(str4 == str5);//false
     
  • 注意：比较 String 字符串的值是否相等，可以使用 equals() 方法。 String 中的 equals 方法是被重写过的。 Object 的 equals 方法是比较的对象的内存地址，而 String 的 equals 方法比较的是字符串的值是否相等。如果你使用 == 比较两个字符串是否相等的话，IDEA 还是提示你使用 equals() 方法替换。
     

54.泛型的介绍：泛型是什么？有什么作用？

Java 泛型（Generics） 是 JDK 5 中引入的一个新特性。使用泛型参数，可以增强代码的可读性以及稳定性。

编译器可以对泛型参数进行检测，并且通过泛型参数可以指定传入的对象类型。比如 ArrayList<Person> persons = new ArrayList<Person>() 这行代码就指明了该 ArrayList 对象只能传入 Person 对象，如果传入其他类型的对象就会报错。

并且，原生 List 返回类型是 Object ，需要手动转换类型才能使用，使用泛型后编译器自动转换

泛型一般有三种使用方式:泛型类、泛型接口、泛型方法

项目中哪些地方用到了泛型？

自定义接口通用返回结果 CommonResult<T> 通过参数 T 可根据具体的返回类型动态指定结果的数据类型

定义 Excel 处理类 ExcelUtil<T> 用于动态指定 Excel 导出的数据类型

构建集合工具类（参考 Collections 中的 sort, binarySearch 方法）。

55.Java 中 ++ 操作符是线程安全的吗？

不是线程安全的操作，它涉及多个指令，如读取变量值，增加，然后存储回内存，这个过程可能出现多线程交错从而导致值的不正确。

56：Serializable 接口为什么需要定义 serialVersionUID 常量？

serialVersionUID 代表序列化的版本，通过定义类的序列化版本，在反序列化时，只要对象中所存的版本和当前类的版本一致，就允许做恢复数据的操作，否则将会抛出序列化版本不一致的错误。

如果不定义序列化版本，在反序列化时可能出现冲突的情况，如：

创建该类的实例，并将这个实例序列化，保存在磁盘上。

升级这个类，例如增加、删除、修改这个类的成员变量；

反序列化该类的实例，即从磁盘上恢复修改之前保存的数据。

在第 3 步恢复数据的时候，当前的类已经和序列化的数据的格式产生了冲突，可能会发生各种意想不到的问题。增加了序列化版本之后，在这种情况下则可以抛出异常，以提示这种矛盾的存在，提高数据的安全性。

57.异常的体系介绍？

异常的体系结构

• 

58.Exception和Error有什么区别？

在 Java 中，所有的异常都有一个共同的祖先 java.lang 包中的 Throwable 类。Throwable 类有两个重要的子类:

Exception :程序本身可以处理的异常，可以通过 catch 来进行捕获。Exception 又可以分为 Checked Exception (受检查异常，必须处理) 和 Unchecked Exception (不受检查异常，可以不处理)。

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

59.Checked Exception 和 Unchecked Exception有什么区别？

Checked Exception 即 受检查异常 ，Java 代码在编译过程中，如果受检查异常没有被 catch或者throws 关键字处理的话，就没办法通过编译。

除了RuntimeException及其子类以外，其他的Exception类及其子类都属于受检查异常 。常见的受检查异常有：IO 相关的异常、ClassNotFoundException、SQLException...。

Unchecked Exception 即 不受检查异常 ，Java 代码在编译过程中 ，我们即使不处理不受检查异常也可以正常通过编译。

RuntimeException 及其子类都统称为非受检查异常，常见的有（建议记下来，日常开发中会经常用到）：

1.NullPointerException(空指针错误)

2.IllegalArgumentException(参数错误比如方法入参类型错误)

3.NumberFormatException（字符串转换为数字格式错误，IllegalArgumentException的子类）4.ArrayIndexOutOfBoundsException（数组越界错误）

5.ClassCastException（类型转换错误）

60.异常的处理方式？

1.抛出异常：遇到异常时不进行具体的处理，直接将异常抛给调用者，让调用者自己根据情况处理。抛出异常的三种形式：throws、throw 和系统自动抛出异常。其中 throws 作用在方法上，用于定义方法可能抛出的异常；throw 作用在方法内，表示明确抛出一个异常。

2.使用 try catch 捕获并处理异常：使用 try catch 捕获异常能够有针对性的处理每种可能出现的异常，并在捕获到异常后根据不同的情况做不同的处理。其使用过程比较简单：用 try catch 语句块将可能出现异常的代码包起来即可。

61.throws 和 throw的区别？

1.throws 出现在方法头，throw 出现在方法体。

2.throws 表示出现异常的一种可能性，并不一定会发生异常；throw 则是抛出了异常，执行throw 则一定抛出了某种异常。

3.两者都是消极的异常处理方式，只是抛出或者可能抛出异常，是不会由函数处理，真正的处理异常由它的上层调用处理。

62.try-catch-finally如何使用？

1.try块：用于捕获异常。其后可接零个或多个 catch 块，如果没有 catch 块，则必须跟一个 finally 块。

2.catch块：用于处理 try 捕获到的异常。

3.finally 块：无论是否捕获或处理异常，finally 块里的语句都会被执行。当在 try 块或 catch 块中遇到 return 语句时，finally 语句块将在方法返回之前被执行

4.注意：不要在 finally 语句块中使用 return! 当 try 语句和 finally 语句中都有 return 语句时，try 语句块中的 return 语句会被忽略。这是因为 try 语句中的 return 返回值会先被暂存在一个本地变量中，当执行到 finally 语句中的 return 之后，这个本地变量的值就变为了 finally 语句中的 return 返回值。

63.finally中的代码一定会被执行吗？

不一定的！在某些情况下，finally 中的代码不会被执行。就比如说 finally 之前虚拟机被终止运行的话，finally 中的代码就不会被执行。

另外，在以下 几 种特殊情况下，finally 块的代码也不会被执行：

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

2.关闭 CPU。

3.程序还没有进入到try语句块就因为异常导致程序终止，这个问题主要是开发人员在编写代码的时候，异常的捕获范围不够。

4.在try或者catch语句块中，执行了System.exit(0)语句，导致JVM直接退出.

64.异常的使用有哪些需要注意的地方吗？

不要把异常定义为静态变量，因为这样会导致异常栈信息错乱。每次手动抛出异常，我们都需要手动 new 一个异常对象抛出。

抛出的异常信息一定要有意义。

建议抛出更加具体的异常比如字符串转换为数字格式错误的时候应该抛出NumberFormatException而不是其父类IllegalArgumentException。

避免重复记录日志：如果在捕获异常的地方已经记录了足够的信息（包括异常类型、错误信息和堆栈跟踪等），那么在业务代码中再次抛出这个异常时，就不应该再次记录相同的错误信息。重复记录日志会使得日志文件膨胀，并且可能会掩盖问题的实际原因，使得问题更难以追踪和解决。

65.什么是反射？

如果说大家研究过框架的底层原理或者咱们自己写过框架的话，一定对反射这个概念不陌生。反射之所以被称为框架的灵魂，主要是因为它赋予了我们在运行时分析类以及执行类中方法的能力。通过反射你可以获取任意一个类的所有属性和方法，你还可以调用这些方法和属性。

66.反射的优缺点？

反射可以让我们的代码更加灵活、为各种框架提供开箱即用的功能提供了便利。

不过，反射让我们在运行时有了分析操作类的能力的同时，也增加了安全问题，比如可以无视泛型参数的安全检查（泛型参数的安全检查发生在编译时）。另外，反射的性能也要稍差点，不过，对于框架来说实际是影响不大的。

67.反射的应用场景？

像咱们平时大部分时候都是在写业务代码，很少会接触到直接使用反射机制的场景。但是！这并不代表反射没有用。相反，正是因为反射，你才能这么轻松地使用各种框架。像 Spring/Spring Boot、MyBatis 等等框架中都大量使用了反射机制。

这些框架中也大量使用了动态代理，而动态代理的实现也依赖反射。

为什么你使用 Spring 的时候 ，一个@Component注解就声明了一个类为 Spring Bean 呢？为什么你通过一个 @Value注解就读取到配置文件中的值呢？究竟是怎么起作用的呢？

这些都是因为你可以基于反射分析类，然后获取到类/属性/方法/方法的参数上的注解。你获取到注解之后，就可以做进一步的处理

68.什么是注解？

Annotation （注解） 是 Java5 开始引入的新特性，可以看作是一种特殊的注释，主要用于修饰类、方法或者变量，提供某些信息供程序在编译或者运行时使用。

注解本质是一个继承了Annotation 的特殊接口：

69.注解的解析方法有几种？

注解只有被解析之后才会生效，常见的解析方法有两种：

编译期直接扫描：编译器在编译 Java 代码的时候扫描对应的注解并处理，比如某个方法使用@Override 注解，编译器在编译的时候就会检测当前的方法是否重写了父类对应的方法。

运行期通过反射处理：像框架中自带的注解(比如 Spring 框架的 @Value、@Component)都是通过反射来进行处理的。

70.什么是序列化？什么是反序列化？

简单来说：

序列化：将数据结构或对象转换成二进制字节流的过程

反序列化：将在序列化过程中所生成的二进制字节流转换成数据结构或者对象的过程

对于 Java 这种面向对象编程语言来说，我们序列化的都是对象（Object）也就是实例化后的类(Class)，但是在 C++这种半面向对象的语言中，struct(结构体)定义的是数据结构类型，而 class 对应的是对象类型。

具体的，

对象在进行网络传输（比如远程方法调用 RPC 的时候）之前需要先被序列化，接收到序列化的对象之后需要再进行反序列化；

将对象存储到文件之前需要进行序列化，将对象从文件中读取出来需要进行反序列化；

将对象存储到数据库（如 Redis）之前需要用到序列化，将对象从缓存数据库中读取出来需要反序列化；

将对象存储到内存之前需要进行序列化，从内存中读取出来之后需要进行反序列化。

（序列化在计算机科学的数据处理中，是指将数据结构或对象状态转换成可取用格式（例如存成文件，存于缓冲，或经由网络中发送），以留待后续在相同或另一台计算机环境中，能恢复原先状态的过程。依照序列化格式重新获取字节的结果时，可以利用它来产生与原始对象相同语义的副本。对于许多对象，像是使用大量引用的复杂对象，这种序列化重建的过程并不容易。面向对象中的对象序列化，并不概括之前原始对象所关系的函数。这种过程也称为对象编组（marshalling）。从一系列字节提取数据结构的反向操作，是反序列化）

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

71.有些对象不想被序列化怎么办？

对于不想进行序列化的变量，使用 transient 关键字修饰。

transient 关键字的作用是：阻止实例中那些用此关键字修饰的的变量序列化；当对象被反序列化时，被 transient 修饰的变量值不会被持久化和恢复。

关于 transient 还有几点注意：

transient 只能修饰变量，不能修饰类和方法。

transient 修饰的变量，在反序列化后变量值将会被置成类型的默认值。例如，如果是修饰 int 类型，那么反序列后结果就是 0。

static 变量因为不属于任何对象(Object)，所以无论有没有 transient 关键字修饰，均不会被序列化

72.常见的序列化协议有哪些？

JDK 自带的序列化方式一般不会用 ，因为序列化效率低并且存在安全问题。比较常用的序列化协议有 Hessian、Kryo、Protobuf、ProtoStuff，这些都是基于二进制的序列化协议。

像 JSON 和 XML 这种属于文本类序列化方式。虽然可读性比较好，但是性能较差，一般不会选择

73.为什么不推荐使用JDK自带的序列化呢？

不支持跨语言调用 : 如果调用的是其他语言开发的服务的时候就不支持了。

性能差：相比于其他序列化框架性能更低，主要原因是序列化之后的字节数组体积较大，导致传输成本加大。

存在安全问题：序列化和反序列化本身并不存在问题。但当输入的反序列化的数据可被用户控制，那么攻击者即可通过构造恶意输入，让反序列化产生非预期的对象，在此过程中执行构造的任意代码

74.什么是语法糖？java中有哪些常见的语法糖？

语法糖（Syntactic sugar） 代指的是编程语言为了方便程序员开发程序而设计的一种特殊语法，这种语法对编程语言的功能并没有影响。实现相同的功能，基于语法糖写出来的代码往往更简单简洁且更易阅读。

举个例子，Java 中的 for-each 就是一个常用的语法糖，其原理其实就是基于普通的 for 循环和迭代器。

不过，JVM 其实并不能识别语法糖，Java 语法糖要想被正确执行，需要先通过编译器进行解糖，也就是在程序编译阶段将其转换成 JVM 认识的基本语法。这也侧面说明，Java 中真正支持语法糖的是 Java 编译器而不是 JVM。如果你去看com.sun.tools.javac.main.JavaCompiler的源码，你会发现在compile()中有一个步骤就是调用desugar()，这个方法就是负责解语法糖的实现的。

Java 中最常用的语法糖主要有泛型、自动拆装箱、变长参数、枚举、内部类、增强 for 循环、try-with-resources 语法、lambda 表达式等

75.成员变量和局部变量的区别：

成员变量是在类的范围里定义的变量，局部变量是在方法中定义的变量。

成员变量有默认初始值，局部变量没有默认初始值。

未被 static 修饰的成员变量叫实例变量，它存储于对象所在的堆内存中，生命周期与对象相同；被 static 修饰的成员变量叫类变量，它存储于方法区中，生命周期与当前类相同。局部变量存储于栈内存中，作用的范围结束，变量空间会自动的释放

76.Java 对象初始化顺序？

父类静态代码块，父类静态成员变量（同级，按代码顺序执行）

子类静态代码块，子类静态成员变量（同级，按代码顺序执行）

父类普通代码块，父类普通成员变量（同级，按代码顺序执行）

父类构造方法

子类普通代码块，子类普通成员变量（同级，按代码顺序执行）

子类构造方法

注意点：

静态内容只在类加载时执行一次，之后不再执行。

默认调用父类的无参构造方法，可以在子类构造方法中利用 super 指定调用父类的哪个构造方法。

77.为什么使用内部类？

使用内部类最吸引人的原因是：每个内部类都能独立地继承一个接口的实现，所以无论外围类是否已经继承了某个接口的实现，对于内部类都没有影响。

使用内部类最大的优点就在于它能够非常好的解决多重继承的问题，使用内部类还能够为我们带来如下特性:

内部类可以用多个实例，每个实例都有自己的状态信息，并且与其他外围对象的信息相互独立。

在单个外围类中，可以让多个内部类以不同的方式实现同一个接口，或者继承同一个类。

创建内部类对象的时刻并不依赖于外围类对象的创建。

内部类并没有令人迷惑的 “is-a” 关系，它就是一个独立的实体。

内部类提供了更好的封装，除了该外围类，其他类都不能访问。

78.什么是序列化?什么是反序列化?

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

简单来说：

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

对于 Java 这种面向对象编程语言来说，我们序列化的都是对象（Object）也就是实例化后的类(Class)，但是在 C++这种半面向对象的语言中，struct(结构体)定义的是数据结构类型，而 class 对应的是对象类型。

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

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

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

序列化协议对应于 TCP/IP 4 层模型的哪一层？

我们知道网络通信的双方必须要采用和遵守相同的协议。TCP/IP 四层模型是下面这样的，序列化协议属于哪一层呢？

1. 应用层
2. 传输层
3. 网络层
4. 网络接口层

如上图所示，OSI 七层协议模型中，表示层做的事情主要就是对应用层的用户数据进行处理转换为二进制流。反过来的话，就是将二进制流转换成应用层的用户数据。这不就对应的是序列化和反序列化么？

因为，OSI 七层协议模型中的应用层、表示层和会话层对应的都是 TCP/IP 四层模型中的应用层，所以序列化协议属于 TCP/IP 协议应用层的一部分。

---

著作权归JavaGuide(javaguide.cn)所有 基于MIT协议 原文链接：https://javaguide.cn/java/basis/java-basic-questions-03.html

79.如果有些字段不想进行序列化怎么办？

对于不想进行序列化的变量，使用 transient 关键字修饰。

transient 关键字的作用是：阻止实例中那些用此关键字修饰的的变量序列化；当对象被反序列化时，被 transient 修饰的变量值不会被持久化和恢复。

关于 transient 还有几点注意：

• transient 只能修饰变量，不能修饰类和方法。
• transient 修饰的变量，在反序列化后变量值将会被置成类型的默认值。例如，如果是修饰 int 类型，那么反序列后结果就是 0。
• static 变量因为不属于任何对象(Object)，所以无论有没有 transient 关键字修饰，均不会被序列化。

80.常见序列化协议有哪些？

JDK 自带的序列化方式一般不会用 ，因为序列化效率低并且存在安全问题。比较常用的序列化协议有 Hessian、Kryo、Protobuf、ProtoStuff，这些都是基于二进制的序列化协议。

像 JSON 和 XML 这种属于文本类序列化方式。虽然可读性比较好，但是性能较差，一般不会选择。

81.为什么不推荐使用 JDK 自带的序列化？

我们很少或者说几乎不会直接使用 JDK 自带的序列化方式，主要原因有下面这些原因：

• 不支持跨语言调用 : 如果调用的是其他语言开发的服务的时候就不支持了。
• 性能差：相比于其他序列化框架性能更低，主要原因是序列化之后的字节数组体积较大，导致传输成本加大。
• 存在安全问题：序列化和反序列化本身并不存在问题。但当输入的反序列化的数据可被用户控制，那么攻击者即可通过构造恶意输入，让反序列化产生非预期的对象，在此过程中执行构造的任意代码。相关阅读：应用安全：JAVA 反序列化漏洞之殇 。

82.Java IO 流了解吗？

IO 即 Input/Output，输入和输出。数据输入到计算机内存的过程即输入，反之输出到外部存储（比如数据库，文件，远程主机）的过程即输出。数据传输过程类似于水流，因此称为 IO 流。IO 流在 Java 中分为输入流和输出流，而根据数据的处理方式又分为字节流和字符流。

Java IO 流的 40 多个类都是从如下 4 个抽象类基类中派生出来的。

• InputStream/Reader: 所有的输入流的基类，前者是字节输入流，后者是字符输入流。
• OutputStream/Writer: 所有输出流的基类，前者是字节输出流，后者是字符输出流。

83.I/O 流为什么要分为字节流和字符流呢?

问题本质想问：不管是文件读写还是网络发送接收，信息的最小存储单元都是字节，那为什么 I/O 流操作要分为字节流操作和字符流操作呢？

个人认为主要有两点原因：

• 字符流是由 Java 虚拟机将字节转换得到的，这个过程还算是比较耗时；
• 如果我们不知道编码类型的话，使用字节流的过程中很容易出现乱码问题。

84.何为 I/O?

I/O（Input/Output） 即输入／输出 。

我们先从计算机结构的角度来解读一下 I/O。

根据冯.诺依曼结构，计算机结构分为 5 大部分：运算器、控制器、存储器、输入设备、输出设备。

输入设备（比如键盘）和输出设备（比如显示器）都属于外部设备。网卡、硬盘这种既可以属于输入设备，也可以属于输出设备。

输入设备向计算机输入数据，输出设备接收计算机输出的数据。

从计算机结构的视角来看的话， I/O 描述了计算机系统与外部设备之间通信的过程。

我们再先从应用程序的角度来解读一下 I/O。

根据大学里学到的操作系统相关的知识：为了保证操作系统的稳定性和安全性，一个进程的地址空间划分为 用户空间（User space） 和 内核空间（Kernel space ） 。

像我们平常运行的应用程序都是运行在用户空间，只有内核空间才能进行系统态级别的资源有关的操作，比如文件管理、进程通信、内存管理等等。也就是说，我们想要进行 IO 操作，一定是要依赖内核空间的能力。

并且，用户空间的程序不能直接访问内核空间。

当想要执行 IO 操作时，由于没有执行这些操作的权限，只能发起系统调用请求操作系统帮忙完成。

因此，用户进程想要执行 IO 操作的话，必须通过 系统调用 来间接访问内核空间

我们在平常开发过程中接触最多的就是 磁盘 IO（读写文件） 和 网络 IO（网络请求和响应）。

从应用程序的视角来看的话，我们的应用程序对操作系统的内核发起 IO 调用（系统调用），操作系统负责的内核执行具体的 IO 操作。也就是说，我们的应用程序实际上只是发起了 IO 操作的调用而已，具体 IO 的执行是由操作系统的内核来完成的。

当应用程序发起 I/O 调用后，会经历两个步骤：

1. 内核等待 I/O 设备准备好数据
2. 内核将数据从内核空间拷贝到用户空间。

85.有哪些常见的 IO 模型?

UNIX 系统下， IO 模型一共有 5 种：同步阻塞 I/O、同步非阻塞 I/O、I/O 多路复用、信号驱动 I/O 和异步 I/O。

这也是我们经常提到的 5 种 IO 模型

86.Java 中 3 种常见 IO 模型

BIO (Blocking I/O)

BIO 属于同步阻塞 IO 模型 。

同步阻塞 IO 模型中，应用程序发起 read 调用后，会一直阻塞，直到内核把数据拷贝到用户空间

在客户端连接数量不高的情况下，是没问题的。但是，当面对十万甚至百万级连接的时候，传统的 BIO 模型是无能为力的。因此，我们需要一种更高效的 I/O 处理模型来应对更高的并发量

NIO (Non-blocking/New I/O)

Java 中的 NIO 于 Java 1.4 中引入，对应 java.nio 包，提供了 Channel , Selector，Buffer 等抽象。NIO 中的 N 可以理解为 Non-blocking，不单纯是 New。它是支持面向缓冲的，基于通道的 I/O 操作方法。 对于高负载、高并发的（网络）应用，应使用 NIO 。

Java 中的 NIO 可以看作是 I/O 多路复用模型。也有很多人认为，Java 中的 NIO 属于同步非阻塞 IO 模型。

跟着我的思路往下看看，相信你会得到答案！

我们先来看看 同步非阻塞 IO 模型。

同步非阻塞 IO 模型中，应用程序会一直发起 read 调用，等待数据从内核空间拷贝到用户空间的这段时间里，线程依然是阻塞的，直到在内核把数据拷贝到用户空间。

相比于同步阻塞 IO 模型，同步非阻塞 IO 模型确实有了很大改进。通过轮询操作，避免了一直阻塞。

但是，这种 IO 模型同样存在问题：应用程序不断进行 I/O 系统调用轮询数据是否已经准备好的过程是十分消耗 CPU 资源的。

这个时候，I/O 多路复用模型 就上场了。

IO 多路复用模型中，线程首先发起 select 调用，询问内核数据是否准备就绪，等内核把数据准备好了，用户线程再发起 read 调用。read 调用的过程（数据从内核空间 -> 用户空间）还是阻塞的。

目前支持 IO 多路复用的系统调用，有 select，epoll 等等。select 系统调用，目前几乎在所有的操作系统上都有支持。

• select 调用：内核提供的系统调用，它支持一次查询多个系统调用的可用状态。几乎所有的操作系统都支持。
• epoll 调用：linux 2.6 内核，属于 select 调用的增强版本，优化了 IO 的执行效率。

IO 多路复用模型，通过减少无效的系统调用，减少了对 CPU 资源的消耗。

Java 中的 NIO ，有一个非常重要的选择器 ( Selector ) 的概念，也可以被称为 多路复用器。通过它，只需要一个线程便可以管理多个客户端连接。当客户端数据到了之后，才会为其服务。

AIO (Asynchronous I/O)

AIO 也就是 NIO 2。Java 7 中引入了 NIO 的改进版 NIO 2,它是异步 IO 模型。

异步 IO 是基于事件和回调机制实现的，也就是应用操作之后会直接返回，不会堵塞在那里，当后台处理完成，操作系统会通知相应的线程进行后续的操作。

目前来说 AIO 的应用还不是很广泛。Netty 之前也尝试使用过 AIO，不过又放弃了。这是因为，Netty 使用了 AIO 之后，在 Linux 系统上的性能并没有多少提升。

最后，来一张图，简单总结一下 Java 中的 BIO、NIO、AIO。

87.什么是语法糖？

语法糖（Syntactic sugar） 代指的是编程语言为了方便程序员开发程序而设计的一种特殊语法，这种语法对编程语言的功能并没有影响。实现相同的功能，基于语法糖写出来的代码往往更简单简洁且更易阅读。

举个例子，Java 中的 for-each 就是一个常用的语法糖，其原理其实就是基于普通的 for 循环和迭代器。

String[] strs = {"JavaGuide", "公众号：JavaGuide", "博客：https://javaguide.cn/"};
for (String s : strs) {System.out.println(s);
}

不过，JVM 其实并不能识别语法糖，Java 语法糖要想被正确执行，需要先通过编译器进行解糖，也就是在程序编译阶段将其转换成 JVM 认识的基本语法。这也侧面说明，Java 中真正支持语法糖的是 Java 编译器而不是 JVM。如果你去看com.sun.tools.javac.main.JavaCompiler的源码，你会发现在compile()中有一个步骤就是调用desugar()，这个方法就是负责解语法糖的实现的。

java-中有哪些常见的语法糖">88.Java 中有哪些常见的语法糖？

Java 中最常用的语法糖主要有泛型、自动拆装箱、变长参数、枚举、内部类、增强 for 循环、try-with-resources 语法、lambda 表达式等。