全面整理了 JavaSE 核心知识点，涵盖 Java 概述、基础语法、面向对象、String 与 Integer 类、Object 类、异常处理、I/O 流、序列化、网络编程、泛型、反射、注解及 JDK 1.8 新特性。内容涉及 JVM 原理、内存模型、多线程、集合框架等面试高频考点，重点解析自动拆箱、深浅拷贝、单例模式、哈希冲突解决等关键问题，适用于技术复习与面试准备。
Java 是一种跨平台、面向对象的编程语言，由 Sun Microsystems（现在是 Oracle 公司）于 1995 年推出。它的设计理念是"一次编写，到处运行"（Write Once, Run Anywhere，WORA），意味着 Java 程序可以在任何支持 Java 虚拟机（JVM）的平台上运行，而不需要重新编译。
JVM（Java Virtual Machine）是 Java 虚拟机，它是 Java 跨平台的核心。JVM 负责将 Java 字节码解释或编译为特定平台的机器码并执行。
JRE（Java Runtime Environment）是 Java 运行时环境，它包含了 JVM 和 Java 类库，以及其他运行 Java 程序所需的组件。用户只需要安装 JRE 就可以运行 Java 程序。
JDK（Java Development Kit）是 Java 开发工具包，它包含了 JRE、Java 编译器（javac）、调试器（jdb）等开发工具。开发者需要安装 JDK 来开发 Java 程序。
简单来说：JDK 包含 JRE，JRE 包含 JVM。
Oracle JDK 是 Oracle 公司提供的 Java 开发工具包，它包含了 Oracle 的商业特性和支持服务。Oracle JDK 在 2019 年开始对商用用户收费，而个人用户可以免费使用。
OpenJDK 是 Java 的开源实现，由 Oracle 和其他社区成员共同维护。OpenJDK 包含了 Java SE 平台的核心功能，与 Oracle JDK 在功能上几乎相同，但不包含 Oracle 的商业特性和支持服务。
Java 之所以能够跨平台，是因为它使用了 Java 虚拟机（JVM）。Java 程序在编译时会被编译成一种中间格式，称为字节码（bytecode），而不是直接编译成特定平台的机器码。然后，不同平台上的 JVM 会将字节码解释或编译成特定平台的机器码并执行。
这样，同一份 Java 字节码可以在任何安装了 JVM 的平台上运行，而不需要重新编译，实现了"一次编写，到处运行"的目标。
Java 的数据类型分为两大类：基本数据类型和引用数据类型。
基本数据类型：也称为内置类型，它们的值直接存储在内存中。Java 有 8 种基本数据类型：
引用数据类型：引用数据类型指向对象的地址，而不是对象本身。主要包括：
自动拆装箱（Autoboxing and Unboxing）是 Java 5 引入的特性，它允许基本数据类型和对应的包装类之间自动转换。
自动装箱：将基本数据类型自动转换为对应的包装类对象。例如：
Integer i = 10; // 自动装箱，相当于 Integer i = Integer.valueOf(10);
自动拆箱：将包装类对象自动转换为对应的基本数据类型。例如：
int j = i; // 自动拆箱，相当于 int j = i.intValue();
原理：
Java 中只有值传递（Pass by Value），没有引用传递。
重载（Overloading）：
重写（Overriding）：
final：
static：
this：
super：
构造器的作用：
注意事项：
static 关键字可以用来修饰变量、方法、代码块和内部类：
final 关键字可以用来修饰类、方法和变量：
什么是字节码？ 所谓的字节码，就是 Java 程序经过编译后产生的.class 文件。 Java 程序从源代码到运行需要经过三步： • 编译：将源代码文件.java 编译成 JVM 可以识别的字节码文件.class • 解释：JVM 执行字节码文件，将字节码翻译成操作系统能识别的机器码 • 执行：操作系统执行二进制的机器码
采用字节码的好处是什么？
编译型语言是指编译器针对特定的操作系统，将源代码一次性翻译成可被该平台执行的机器码。 解释型语言是指解释器对源代码进行逐行解释，解释成特定平台的机器码并执行。
Java 程序的执行过程结合了编译和解释两种方式：
因此，Java 被称为"编译与解释并存"的语言。
当把一个范围较小的数值或变量赋给另外一个范围较大的变量时，会进行自动类型转换；反之，需要强制转换。 自动类型转换方向： char -> byte -> short -> int -> long -> float -> double 这就好像，小杯里的水倒进大杯没问题，但大杯的水倒进小杯就可能会溢出。
①、float f=3.4，对吗？ 不正确。3.4 默认是双精度，将双精度赋值给浮点型属于下转型（down-casting，也称窄化）会造成精度丢失，因此需要强制类型转换 float f =(float)3.4; 或者写成 float f =3.4F
②、short s1 = 1; s1 = s1 + 1; 对吗？short s1 = 1; s1 += 1; 对吗？ short s1 = 1; s1 = s1 + 1; 会编译出错，由于 1 是 int 类型，因此 s1+1 运算结果也是 int 型，需要强制转换类型才能赋值给 short 型。 而 short s1 = 1; s1 += 1; 可以正确编译，因为 s1+= 1; 相当于 s1 = (short)(s1 + 1); 其中有隐含的强制类型转换。
& 是 逻辑与。 && 是短路与运算。逻辑与跟短路与的差别是非常大的，虽然二者都要求运算符左右两端的布尔值都是 true，整个表达式的值才是 true。 && 之所以称为短路运算是因为，如果 && 左边的表达式的值是 false，右边的表达式会直接短路掉，不会进行运算。 例如在验证用户登录时判定用户名不是 null 而且不是空字符串，应当写为 username != null && !username.equals("")，二者的顺序不能交换，更不能用 & 运算符，因为第一个条件如果不成立，根本不能进行字符串的 equals 比较，会抛出 NullPointerException 异常。 注意：逻辑或运算符（|）和短路或运算符（||）的差别也是类似。
Java 5 以前 switch(expr) 中，expr 只能是 byte、short、char、int。 从 Java 5 开始，Java 中引入了枚举类型，expr 也可以是 enum 类型。 从 Java 7 开始，expr 还可以是字符串，但是长整型在目前所有的版本中都是不可以的。
• break 跳出整个循环，不再执行循环 (结束当前的循环体) • continue 跳出本次循环，继续执行下次循环 (结束正在执行的循环 进入下一个循环条件) • return 程序返回，不再执行下面的代码 (结束当前的方法 直接返回)
2 << 3。位运算，数字的二进制位左移三位相当于乘以 2 的三次方。
在写代码的过程中，常见的一种情况是需要某个整数类型变量增加 1 或减少 1，Java 提供了一种特殊的运算符，用于这种表达式，叫做自增运算符（++）和自减运算符（–）。 ++和–运算符可以放在变量之前，也可以放在变量之后。 当运算符放在变量之前时 (前缀)，先自增/减，再赋值；当运算符放在变量之后时 (后缀)，先赋值，再自增/减。 例如，当 b = ++a 时，先自增（自己增加 1），再赋值（赋值给 b）；当 b = a++ 时，先赋值 (赋值给 b)，再自增（自己增加 1）。也就是，++a 输出的是 a+1 的值，a++输出的是 a 值。 用一句口诀就是：'符号在前就先加/减，符号在后就后加/减'。
float 类型的小数在计算机中是通过 IEEE 754 标准的单精度浮点数格式来表示的。 V = (-1)^S * M * 2^E
在金融计算中，保证数据准确性有两种方案，一种使用 BigDecimal，一种将浮点数转换为整数 int 进行计算。 肯定不能使用 float 和 double 类型，它们无法避免浮点数运算中常见的精度问题，因为这些数据类型采用二进制浮点数来表示，无法准确地表示，例如 0.1。
使用 BigDecimal 保证数据准确性：
BigDecimal num1 = new BigDecimal("0.1");
BigDecimal num2 = new BigDecimal("0.2");
BigDecimal sum = num1.add(num2);
System.out.println("Sum of 0.1 and 0.2 using BigDecimal: " + sum); // 输出 0.3, 精确计算
转换为整数计算保证数据准确性： 在处理小额支付或计算时，通过转换为较小的货币单位（如分），这样不仅提高了运算速度，还保证了计算的准确性。
int priceInCents = 199; // 商品价格 199 分
int quantity = 3;
int totalInCents = priceInCents * quantity; // 计算总价
System.out.println("Total price in cents: " + totalInCents); // 输出 597 分
如何创建一个对象？有哪些方式？ Java 有四种创建对象的方式：
序列化机制创建：通过序列化将对象转换为字节流，再通过反序列化从字节流中恢复对象。需要实现 Serializable 接口。
Person person = new Person();
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.txt"));
oos.writeObject(person);
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("person.txt"));
Person person2 = (Person) ois.readObject();
clone 拷贝创建：通过 clone 方法创建对象，需要实现 Cloneable 接口并重写 clone 方法。
Person person = new Person();
Person person2 = (Person) person.clone();
反射机制创建：反射机制允许在运行时创建对象，并且可以访问类的私有成员，在框架和工具类中比较常见。
Class clazz = Class.forName("Person");
Person person = (Person) clazz.newInstance();
new 关键字创建：这是最常见和直接的方式，通过调用类的构造方法来创建对象。
Person person = new Person();
new 关键字创建对象的过程是怎样的？
使用 new 关键字创建对象的过程如下：
new 指令时，首先会检查这个指令的参数是否能在常量池中定位到一个类的符号引用，并检查这个符号引用代表的类是否已被加载、解析和初始化。如果没有，必须先执行相应的类加载过程。new 指令之后会接着执行 <init> 方法，把对象按照程序员的意愿进行初始化，这样一个真正可用的对象才算完全产生出来。使用 Class.newInstance() 和 Constructor.newInstance() 有什么区别？（注意：Class.newInstance() 已被弃用）
Class.newInstance()：只能调用类的无参公共构造器。如果类没有无参构造器或构造器不是 public，会抛出 InstantiationException 或 IllegalAccessException。此方法已被弃用。Constructor.newInstance()：可以调用任何构造器（包括私有构造器），只要通过 getDeclaredConstructor() 获取到对应的 Constructor 对象。它提供了更大的灵活性。对象创建过程中的内存分配流程（堆、栈、对象头等）？
new 关键字创建的对象实例以及数组。堆是被所有线程共享的一块内存区域，在虚拟机启动时创建。对象的实例数据（成员变量）都存储在堆上。补充：JVM 内存模型与对象创建
new 指令执行时，对象的引用（如 person）存储在栈上。new 指令分配的内存和创建的对象实例都位于堆中。new 指令的参数（类的符号引用）在常量池中。封装：如何实现？访问修饰符有哪些？作用范围？
private：仅在本类内部可见。default (包私有)：在本类和同一个包中的其他类可见。protected：在本类、同一个包中的其他类以及所有子类（即使子类在不同包中）可见。public：在所有类中可见。继承：extends 和 super 的使用？方法重写（@Override）规则？
extends：关键字用于一个类继承另一个类。子类会继承父类的非私有成员（属性和方法）。super：关键字用于在子类中调用父类的构造器、属性或方法。super() 必须是子类构造器中的第一条语句。protected，子类不能是 private，但可以是 public）。多态：实现方式？向上转型和向下转型？动态绑定机制？
Animal a = new Dog();。instanceof 检查类型，否则会抛出 ClassCastException。例如：Dog d = (Dog) a;。构造器是否可以重写？是否可以重载？
默认构造器、无参构造器、私有构造器的作用？
private，可以防止外部类直接通过 new 创建该类的实例。常用于单例模式或工具类。构造代码块、静态代码块的执行顺序？ 执行顺序为：静态代码块 -> 构造代码块 -> 构造器。
static {} 定义，用于初始化类的静态成员。它在类被加载时执行，且只执行一次。{} 定义，用于初始化对象的实例成员。它在每次创建对象时执行，且在构造器之前执行。1. Spring 中的构造器注入 Spring 框架推荐使用构造器注入来实现依赖注入（DI），因为它能保证依赖不可变且不为 null。
@Service
public class UserService {
private final UserMapper userMapper;
private final OrderService orderService;
public UserService(UserMapper userMapper, OrderService orderService) {
this.userMapper = userMapper;
this.orderService = orderService;
}
}
final，保证不可变性。new 注入模拟对象。2. 私有构造器的典型用途
将构造器设为 private 是控制实例化的重要手段。
(1) 工具类防止实例化
public class MathUtils {
private MathUtils() {
throw new AssertionError("工具类不能实例化");
}
public static int add(int a, int b) {
return a + b;
}
}
new MathUtils() 创建实例。(2) 单例模式（懒汉式线程安全）
public class Singleton {
private static Singleton instance;
private Singleton() {}
public static synchronized Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
new。(3) 防止继承
public class UtilityClass {
private UtilityClass() {}
public static void doSomething() {
// ...
}
}
super()，因此不能继承此类。(4) Java 标准库示例
java.lang.Math：所有方法静态，无需实例。java.util.Collections：集合工具类。LocalDateTime.of(...)：静态工厂方法创建实例。注意事项：
readResolve() 方法防止。对比总结
| 场景 | 构造器访问 | 是否允许外部 new | 是否依赖 Java 构造器 | 推荐程度 |
|---|---|---|---|---|
| Spring 构造器注入 | public | 是（由容器调用） | 是 | 高 |
| 工具类 / 单例 | private | 否 | 是 | 高 |
浅拷贝 vs 深拷贝的区别？
如何实现浅拷贝？（实现 Cloneable 接口，重写 clone() 方法） 实现浅拷贝需要：
Cloneable 接口（一个标记接口）。Object 类的 clone() 方法，并将其访问权限改为 public。class Person implements Cloneable {
String name;
int age;
Address address;
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
如何实现深拷贝？（序列化、手动复制、第三方工具如 Apache Commons BeanUtils） 实现深拷贝的方法有：
clone() 方法时，对所有引用类型的字段也进行 clone() 操作。clone() 方法属于浅拷贝吗？为什么？
Object 类的 clone() 方法是浅拷贝。因为它只是简单地复制对象的内存，对于引用类型的字段，它复制的是引用地址，而不是创建一个新的引用对象。
this 可以用在哪些场景？调用构造器、成员变量、成员方法？
this.变量名 来指代成员变量。this.方法名()，通常可以省略 this。this(参数)，且必须是构造器中的第一条语句。super 调用父类构造器时必须是第一行吗？
是的，super() 或 super(参数) 必须是子类构造器中的第一条语句。这是为了确保父类在子类之前被正确初始化。
为什么重写 equals() 必须重写 hashCode()？
因为 HashMap、HashSet 等基于哈希的集合依赖于 hashCode() 和 equals() 方法。hashCode() 决定了对象在哈希表中的存储位置，equals() 用于在哈希冲突时比较对象是否相等。如果两个对象 equals() 返回 true，但 hashCode() 返回不同的值，它们会被存储在不同的哈希桶中，导致 HashMap 无法正确识别它们是相等的，从而破坏集合的正常功能。
== 与 equals() 的区别？
==：对于基本数据类型，比较的是值；对于引用类型，比较的是两个引用是否指向内存中的同一个对象。equals()：是 Object 类的一个方法，用于比较两个对象的内容是否相等。默认实现是 return (this == obj);，但通常会被重写以提供更合理的比较逻辑（如 String 类）。equals() 的通用约定（自反性、对称性、传递性、一致性）？
equals() 方法必须满足以下通用约定：
null 的引用值 x，x.equals(x) 应该返回 true。null 的引用值 x 和 y，如果 x.equals(y) 返回 true，那么 y.equals(x) 也应该返回 true。null 的引用值 x、y 和 z，如果 x.equals(y) 返回 true，并且 y.equals(z) 返回 true，那么 x.equals(z) 也应该返回 true。null 的引用值 x 和 y，多次调用 x.equals(y) 始终返回 true 或始终返回 false，前提是对象上 equals 比较中所用的信息没有被修改。null 的引用值 x，x.equals(null) 应该返回 false。什么是 hashCode 方法？ hashCode() 方法的作用是获取哈希码，它会返回一个 int 整数，定义在 Object 类中，是一个本地方法。 public native int hashCode();
为什么要有 hashCode 方法？ hashCode 方法主要用来获取对象的哈希码，哈希码是由对象的内存地址或者对象的属性计算出来的，它是一个 int 类型的整数，通常是不会重复的，因此可以用来作为键值对的键，以提高查询效率。
为什么两个对象有相同的 hashcode 值，它们也不一定相等？ 这主要是由于哈希码（hashCode）的本质和目的所决定的。 哈希码是通过哈希函数将对象中映射成一个整数值，其主要目的是在哈希表中快速定位对象的存储位置。 由于哈希函数将一个较大的输入域映射到一个较小的输出域，不同的输入值（即不同的对象）可能会产生相同的输出值（即相同的哈希码）。 这种情况被称为哈希冲突。当两个不相等的对象发生哈希冲突时，它们会有相同的 hashCode。
hashCode 和 equals 方法的关系？ 如果两个对象通过 equals 相等，它们的 hashCode 必须相等。否则会导致哈希表数据结构（如 HashMap、HashSet）的行为异常。 在哈希表中，如果 equals 相等但 hashCode 不相等，哈希表可能无法正确处理这些对象，导致重复元素或键值冲突等问题。
final 修饰类、方法、变量分别意味着什么？
String 为什么被设计为 final？
String 被设计为 final 主要出于安全和性能考虑：
String 可变，这些参数可能在不经意间被修改，导致安全漏洞。final 保证了 String 类不能被继承，从而防止了子类破坏其不可变性。String 的不可变性使其可以安全地放入字符串常量池中，多个引用可以指向同一个对象，节省内存。String 不可变，其哈希值可以被缓存，提高在 HashMap 等集合中的性能。面向过程是以过程为核心，通过函数完成任务，程序结构是函数 + 步骤组成的顺序流程。 面向对象是以对象为核心，通过对象交互完成任务，程序结构是类和对象组成的模块化结构，代码可以通过继承、组合、多态等方式复用。 在实际开发中，像 VO、DTO 都是业务抽象后的对象实体类，而 Service、Controller 则是业务逻辑的实现，这其实就是面向对象的思想。
面向对象编程有三大特性：封装、继承、多态。
封装是什么？ 封装是指将数据（属性，或者叫字段）和操作数据的方法（行为）捆绑在一起，形成一个独立的对象（类的实例）。 所以，封装是把一个对象的属性私有化，同时提供一些可以被外界访问的方法。
继承是什么？ 继承允许一个类（子类）继承现有类（父类或者基类）的属性和方法。以提高代码的复用性，建立类之间的层次关系。 同时，子类还可以重写或者扩展从父类继承来的属性和方法，从而实现多态。
什么是多态？ 多态允许不同类的对象对同一消息做出响应，但表现出不同的行为（即方法的多样性）。 多态其实是一种能力——同一个行为具有不同的表现形式；换句话说就是，执行一段代码，Java 在运行时能根据对象类型的不同产生不同的结果。 多态的前置条件有三个：
为什么 Java 里面要多组合少继承？ 继承适合描述"is-a"的关系，但继承容易导致类之间的强耦合，一旦父类发生改变，子类也要随之改变，违背了开闭原则（尽量不修改现有代码，而是添加新的代码来实现）。 组合适合描述"has-a"或"can-do"的关系，通过在类中组合其他类，能够更灵活地扩展功能。组合避免了复杂的类继承体系，同时遵循了开闭原则和松耦合的设计原则。
多态指向一个接口或方法在不同的类中有不同的实现，比如说动态绑定，父类引用指向子类对象，方法的具体调用会延迟到运行时决定。 答案是在运行时根据对象的类型进行后期绑定，编译器在编译阶段并不知道对象的类型，但是 Java 的方法调用机制能找到正确的方法体，然后执行，得到正确的结果，这就是多态的作用。
多态的实现原理是什么？ 多态通过动态绑定实现，Java 使用虚方法表存储方法指针，方法调用时根据对象实际类型从虚方法表查找具体实现。
Java 中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。
this 是自身的一个对象，代表对象本身，可以理解为：指向对象本身的一个指针。 this 的用法在 Java 中大体可以分为 3 种：
public Person(String name, int age) {
this.name = name;
this.age = age;
}
一个类只能继承一个抽象类；但一个类可以实现多个接口。所以我们在新建线程类的时候一般推荐使用实现 Runnable 接口的方式，这样线程类还可以继承其他类，而不单单是 Thread 类。 抽象类符合 is-a 的关系，而接口更像是 has-a 的关系，比如说一个类可以序列化的时候，它只需要实现 Serializable 接口就可以了，不需要去继承一个序列化类。 抽象类更多地用来为多个相关的类提供一个共同的基础框架，包括状态的初始化，而接口则是定义一套行为标准，让不同的类可以实现同一接口，提供行为的多样化实现。
抽象类可以定义构造方法吗？ 可以，抽象类可以有构造方法。
接口可以定义构造方法吗？ 不能，接口主要用于定义一组方法规范，没有具体的实现细节。
Java 支持多继承吗？ Java 不支持多继承，一个类只能继承一个类，多继承会引发菱形继承问题。
接口可以多继承吗？ 接口可以多继承，一个接口可以继承多个接口，使用逗号分隔。
继承和抽象的区别？ 继承是一种允许子类继承父类属性和方法的机制。通过继承，子类可以重用父类的代码。 抽象是一种隐藏复杂性和只显示必要部分的技术。在面向对象编程中，抽象可以通过抽象类和接口实现。
抽象类和普通类的区别？ 抽象类使用 abstract 关键字定义，不能被实例化，只能作为其他类的父类。普通类没有 abstract 关键字，可以直接实例化。 抽象类可以包含抽象方法和非抽象方法。抽象方法没有方法体，必须由子类实现。普通类只能包含非抽象方法。
static 关键字可以用来修饰变量、方法、代码块和内部类，以及导入包。
| 修饰对象 | 作用 |
|---|---|
| 变量 | 静态变量，类级别变量，所有实例共享同一份数据。 |
| 方法 | 静态方法，类级别方法，与实例无关。 |
| 代码块 | 在类加载时初始化一些数据，只执行一次。 |
| 内部类 | 与外部类绑定但独立于外部类实例。 |
| 导入 | 可以直接访问静态成员，无需通过类名引用，简化代码书写，但会降低代码可读性。 |
静态变量和实例变量的区别？ 静态变量：是被 static 修饰符修饰的变量，也称为类变量，它属于类，不属于类的任何一个对象，一个类不管创建多少个对象，静态变量在内存中有且仅有一个副本。 实例变量：必须依存于某一实例，需要先创建对象然后通过对象才能访问到它。静态变量可以实现让多个对象共享内存。
静态方法和实例方法有何不同？ 静态方法：static 修饰的方法，也被称为类方法。在外部调用静态方法时，可以使用'类名。方法名'的方式，也可以使用'对象名。方法名'的方式。静态方法里不能访问类的非静态成员变量和方法。 实例方法：依存于类的实例，需要使用'对象名。方法名'的方式调用；可以访问类的所有成员变量和方法。
①、final 是一个修饰符，可以修饰类、方法和变量。当 final 修饰一个类时，表明这个类不能被继承；当 final 修饰一个方法时，表明这个方法不能被重写；当 final 修饰一个变量时，表明这个变量是个常量，一旦赋值后，就不能再被修改了。 ②、finally 是 Java 中异常处理的一部分，用来创建 try 块后面的 finally 块。无论 try 块中的代码是否抛出异常，finally 块中的代码总是会被执行。通常，finally 块被用来释放资源，如关闭文件、数据库连接等。 ③、finalize 是 Object 类的一个方法，用于在垃圾回收器将对象从内存中清除出去之前做一些必要的清理工作。 这个方法在垃圾回收器准备释放对象占用的内存之前被自动调用。我们不能显式地调用 finalize 方法，因为它总是由垃圾回收器在适当的时间自动调用。
在 java 中，== 操作符和 equals() 方法用于比较两个对象： ①、：用于比较两个对象的引用，即它们是否指向同一个对象实例。 如果两个变量引用同一个对象实例，返回 true，否则返回 false。 对于基本数据类型（如 int, double, char 等），== 比较的是值是否相等。 ②、equals() 方法：用于比较两个对象的内容是否相等。默认情况下，equals() 方法的行为与 == 相同，即比较对象引用，如在超类 Object 中。然而，equals() 方法通常被各种类重写。例如，string 类重写了 equals() 方法，以便它可以比较两个字符串的字符内容是否完全一样。
Java 是值传递，不是引用传递。 当一个对象被作为参数传递到方法中时，参数的值就是该对象的引用。引用的值是对象在堆中的地址。 对象是存储在堆中的，所以传递对象的时候，可以理解为把变量存储的对象地址给传递过去。
引用类型的变量有什么特点？ 引用类型的变量存储的是对象的地址，而不是对象本身。因此，引用类型的变量在传递时，传递的是对象的地址，也就是说，传递的是引用的值。
在 Java 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）是两种拷贝对象的方式，它们在拷贝对象的方式上有很大不同。 浅拷贝会创建一个新对象，但这个新对象的属性（字段）和原对象的属性完全相同。如果属性是基本数据类型，拷贝的是基本数据类型的值；如果属性是引用类型，拷贝的是引用地址，因此新旧对象共享同一个引用对象。 浅拷贝的实现方式为：实现 Cloneable 接口并重写 clone() 方法。 深拷贝也会创建一个新对象，但会递归地复制所有的引用对象，确保新对象和原对象完全独立。新对象与原对象的任何更改都不会相互影响。 深拷贝的实现方式有：手动复制所有的引用对象，或者使用序列化与反序列化。
Java 有四种创建对象的方式： ①、new 关键字创建，这是最常见和直接的方式，通过调用类的构造方法来创建对象。 ②、反射机制创建，反射机制允许在运行时创建对象，并且可以访问类的私有成员，在框架和工具类中比较常见。 ③、clone 拷贝创建，通过 clone 方法创建对象，需要实现 Cloneable 接口并重写 clone 方法。 ④、序列化机制创建，通过序列化将对象转换为字节流，再通过反序列化从字节流中恢复对象。需要实现 Serializable 接口。
new 子类的时候，子类和父类静态代码块，构造方法的执行顺序 在 Java 中，当创建一个子类对象时，子类和父类的静态代码块、构造方法的执行顺序遵循一定的规则。这些规则主要包括以下几个步骤：
为什么 String 是不可变的？如何实现？
String 是不可变的，因为：
final 修饰：String 类被声明为 final，不能被继承。final 字符数组：String 内部使用一个 private final char value[] 来存储字符串内容，数组引用是 final 的，不能指向其他数组。String 类没有提供任何可以修改其内部字符数组内容的公共方法。所有看似修改字符串的方法（如 concat, substring）都返回一个新创建的 String 对象。不可变的好处和代价？
hashCode 可以被缓存，提高性能。StringBuilder 和 StringBuffer 的区别？
StringBuilder：非线程安全，但性能更高。适用于单线程环境。StringBuffer：线程安全，因为其方法都使用 synchronized 关键字修饰，但性能较低。适用于多线程环境。字符串常量池（String Pool）是什么？存放在哪里？（JDK 6 vs JDK 7 vs JDK 8）
"abc"）和通过 intern() 方法加入的字符串。OutOfMemoryError。new String('abc') 创建几个对象？
new String("abc") 会创建两个对象：
String 对象。"abc" 字符串对象（如果常量池中还没有 "abc"）。intern() 方法的作用？不同 JDK 版本的行为差异？
intern() 方法会检查字符串常量池中是否已经存在一个与该字符串 equals() 相等的字符串。如果存在，则返回常量池中的字符串引用；如果不存在，则将该字符串放入常量池中，并返回其引用。intern() 会将字符串的拷贝放入永久代的常量池。intern() 可以将字符串的引用直接放入堆中的常量池，避免了不必要的拷贝，性能更好。split()、substring()、replace()、trim()、indexOf() 等方法细节？
split(String regex)：根据正则表达式 regex 分割字符串，返回一个字符串数组。substring(int beginIndex, int endIndex)：返回从 beginIndex 到 endIndex（不包括）的子字符串。replace(char oldChar, char newChar) / replace(CharSequence target, CharSequence replacement)：替换所有匹配的字符或字符序列。trim()：去除字符串两端的空白字符（ASCII 值小于等于 32 的字符）。indexOf(int ch) / indexOf(String str)：返回指定字符或子字符串第一次出现的索引，如果未找到则返回 -1。split('.') 为什么返回空数组？（正则表达式问题）
因为 split() 方法的参数是一个正则表达式。. 在正则表达式中是一个元字符，表示匹配任意单个字符。因此，split(".") 会尝试用'任意字符'作为分隔符，导致字符串被完全分割，返回一个空数组。要按字面量的点号分割，需要转义：split("\\.")。
用 + 拼接字符串的性能问题？编译器优化？
+ 拼接字符串时，每次 + 操作都会创建一个新的 String 对象，导致大量临时对象，影响性能和内存。String s = "a" + "b" + "c";），编译器会将其优化为单个字符串字面量。但对于运行时变量的拼接，编译器会将其转换为 StringBuilder 的 append 操作，但这在循环中仍然不够高效。什么时候用 String、StringBuilder、StringBuffer？
String：字符串内容不经常改变，或作为 HashMap 的 key。StringBuilder：单线程环境下，需要频繁修改字符串。StringBuffer：多线程环境下，需要频繁修改字符串，且需要线程安全。不是，string 是一个类，属于引用数据类型。Java 的基本数据类型包括 8 种：四种整型（byte、short、int、long）、两种浮点型（float、double）、一种字符型（char）和一种布尔型（boolean）。
String 类可以被继承吗？ 不行。String 类使用 final 修饰，是所谓的不可变类，无法被继承。
String 有哪些常用方法？ 我自己常用的有：
JDK 源码里已经对这个方法进行了说明： 意思也很好懂：
Integer a=127, Integer b=127; Integer c=128, Integer d=128; 相等吗？ a 和 b 相等，c 和 d 不相等。 这个问题涉及到 Java 的自动装箱机制以及 Integer 类的缓存机制。
对于第一对： Integer a = 127; Integer b = 127; a 和 b 是相等的。这是因为 Java 在自动装箱过程中，会使用 Integer.valueOf() 方法来创建 Integer 对象。Integer.valueOf() 方法会针对数值在 -128 到 127 之间的 Integer 对象使用缓存。因此，a 和 b 实际上引用了常量池中相同的 Integer 对象。
对于第二对： Integer c = 128; Integer d = 128; c 和 d 不相等。这是因为 128 超出了 Integer 缓存的范围 (-128 到 127)。因此，自动装箱过程会为 c 和 d 创建两个不同的 Integer 对象，它们有不同的引用地址。
可以通过 == 运算符来检查它们是否相等： System.out.println(a == b); // 输出 true System.out.println(c == d); // 输出 false
要比较 Integer 对象的数值是否相等，应该使用 equals 方法，而不是 == 运算符： System.out.println(a.equals(b)); // 输出 true System.out.println(c.equals(d)); // 输出 true 使用 equals 方法时，c 和 d 的比较结果为 true，因为 equals 比较的是对象的数值，而不是引用地址。
什么是 Integer 缓存？ 就拿 Integer 的缓存来说吧。根据实践发现，大部分的数据操作都集中在值比较小的范围，因此 Integer 搞了个缓存池，默认范围是 -128 到 127。 当我们使用自动装箱来创建这个范围内的 Integer 对象时，Java 会直接从缓存中返回一个已存在的对象，而不是每次都创建一个新的对象。这意味着，对于这个值范围内的所有 Integer 对象，它们实际上是引用相同的对象实例。 Integer 缓存的主要目的是优化性能和内存使用。对于小整数的频繁操作，使用缓存可以显著减少对象创建的数量。 可以在运行的时候添加 -Djava.lang.Integer.IntegerCache.high=1000 来调整缓存池的最大值。 引用是 Integer 类型，= 右侧是 int 基本类型时，会进行自动装箱，调用的其实是 Integer.valueOf() 方法，它会调用 IntegerCache。
new Integer(10) == new Integer(10) 相等吗 在 Java 中，使用 new Integer(10) == new Integer(10) 进行比较时，结果是 false。 这是因为 new 关键字会在堆（Heap）上为每个 Integer 对象分配新的内存空间，所以这里创建了两个不同的 Integer 对象，它们有不同的内存地址。 当使用==运算符比较这两个对象时，实际上比较的是它们的内存地址，而不是它们的值，因此即使两个对象代表相同的数值（10），结果也是 false。
String 怎么转成 Integer 的？原理？ String 转成 Integer，主要有两个方法： ● Integer.parseInt(String s) ● Integer.valueOf(String s) 不管哪一种，最终还是会调用 Integer 类内中的 parseInt(String s, int radix) 方法。 抛去一些边界之类的看看核心代码： 去掉枝枝蔓蔓（当然这些枝枝蔓蔓可以去看看，源码 cover 了很多情况），其实剩下的就是一个简单的字符串遍历计算，不过计算方式有点反常规，是用负的值累减。
Object 类的常见方法？ 在 Java 中，经常提到一个词'万物皆对象'，其中的'万物'指的是 Java 中的所有类，而这些类都是 Object 类的子类。 Object 主要提供了 11 个方法，大致可以分为六类：对象比较、对象拷贝、对象转字符串、多线程调度、反射、垃圾回收。
对象比较： ①、public native int hashCode()：native 方法，用于返回对象的哈希码。 public native int hashCode(); 按照约定，相等的对象必须具有相等的哈希码。如果重写了 equals 方法，就应该重写 hashCode 方法。可以使用 Objects.hash() 方法来生成哈希码。 ②、public boolean equals(object obj)：用于比较 2 个对象的内存地址是否相等。 public boolean equals(object obj) { return (this == obj); } 如果比较的是两个对象的值是否相等，就要重写该方法，比如 String 类、Integer 类等都重写了该方法。
对象拷贝： protected native Object clone() throws CloneNotSupportedException：native 方法，返回此对象的一个副本。默认实现只做浅拷贝，且类必须实现 Cloneable 接口。 Object 本身没有实现 Cloneable 接口，所以在不重写 clone 方法的情况下直接直接调用该方法会发生 CloneNotSupportedException 异常。
对象转字符串： public String toString()：返回对象的字符串表示。默认实现返回类名@哈希码的十六进制表示，但通常会被重写以返回更有意义的信息。 public String toString() { return getClass().getName() + "@" + Integer.toHexString(hashCode()); } 数组也是一个对象，所以通常我们打印数组的时候，会看到诸如 [T@1b6d3586] 这样的字符串，这个就是 int 数组的哈希码。
多线程调度： 每个对象都可以调用 Object 的 wait/notify 方法来实现等待/通知机制。 ①、public final void wait() throws InterruptedException：调用该方法会导致当前线程等待，直到另一个线程调用此对象的 notify() 方法或 notifyAll() 方法。 ②、public final native void notify(): 唤醒在此对象监视器上等待的单个线程。如果有多个线程等待，选择一个线程被唤醒。 ③、public final native void notifyAll(): 唤醒在此对象监视器上等待的所有线程。 ④、public final native void wait(long timeout) throws InterruptedException：等待 timeout 毫秒，如果在 timeout 毫秒内没有被唤醒，会自动唤醒。 ⑤、public final void wait(long timeout, int nanos) throws InterruptedException：更加精确了，等待 timeout 毫秒和 nanos 纳秒，如果在 timeout 毫秒和 nanos 纳秒内没有被唤醒，会自动唤醒。
反射： public final native Class<?> getClass()：用于获取对象的类信息，如类名。
垃圾回收： protected void finalize() throws Throwable：当垃圾回收器决定回收对象占用的内存时调用此方法。用于清理资源，但 Java 不推荐使用，因为它不可预测且容易导致问题，Java 9 开始已被弃用。
Error vs Exception vs RuntimeException？
Error：表示严重的系统级错误，如 OutOfMemoryError、StackOverflowError。程序通常无法处理，只能终止。Exception：表示程序可以处理的异常。RuntimeException：是 Exception 的子类，表示运行时异常，如 NullPointerException、ArrayIndexOutOfBoundsException。它们是非检查异常 (unchecked exception)，编译器不要求必须处理。检查异常（checked exception）和非检查异常（unchecked exception）的区别？
Exception 的子类（不包括 RuntimeException）。编译器强制要求必须处理（捕获或声明抛出），否则编译失败。例如 IOException、SQLException。RuntimeException 和 Error。编译器不要求必须处理。finally 一定会执行吗？return 在 try 或 catch 中时，finally 的执行顺序？
finally 块几乎总是会执行，即使在 try 或 catch 块中使用了 return、break 或 continue。try 或 catch 中有 return 时，finally 会在 return 语句执行后、方法返回前执行。如果 finally 中也有 return，它会覆盖 try/catch 中的 return 值。try-with-resources 是如何实现自动关闭的？（实现 AutoCloseable 接口）
try-with-resources 语句要求资源必须实现 AutoCloseable 接口（或其子接口 Closeable）。在 try 语句块执行完毕后（无论是否发生异常），JVM 会自动调用资源的 close() 方法来释放资源，无需手动 finally 块。
抛出异常 vs 声明异常的区别？
throw：用于在方法内部抛出一个具体的异常实例。throws：用于在方法签名中声明该方法可能抛出的异常类型，由调用者来处理。NullPointerException、ArrayIndexOutOfBoundsException、ClassCastException、NumberFormatException、ArithmeticException 等常见原因和解决？
NullPointerException：尝试访问或调用一个 null 对象的成员。解决：在使用前进行 null 检查。ArrayIndexOutOfBoundsException：访问数组时索引超出范围。解决：检查数组长度和索引。ClassCastException：尝试将一个对象强制转换为不兼容的类型。解决：使用 instanceof 检查类型。NumberFormatException：尝试将一个非数字字符串转换为数字。解决：使用 try-catch 或正则表达式验证。ArithmeticException：例如除以零。解决：检查除数是否为零。如何自定义异常？什么时候需要自定义异常？
如何自定义：继承 Exception（检查异常）或 RuntimeException（非检查异常）。
public class MyException extends Exception {
public MyException(String message) {
super(message);
}
}
题目 1
public class TryDemo {
public static void main(String[] args) {
System.out.println(test());
}
public static int test() {
try {
return 1;
} catch (Exception e) {
return 2;
} finally {
System.out.print("3");
}
}
}
在 test() 方法中，首先有一个 try 块，接着是一个 catch 块（用于捕获异常），最后是一个 finally 块（无论是否捕获到异常，finally 块总会执行）。 ①、try 块中包含一条 return 1；语句。正常情况下，如果 try 块中的代码能够顺利执行，那么方法将返回数字 1。在这个例子中，try 块中没有任何可能抛出异常的操作，因此它会正常执行完毕，并准备返回 1。 ②、由于 try 块中没有异常发生，所以 catch 块中的代码不会执行。 ③、无论前面的代码是否发生异常，finally 块总是会执行。在这个例子中，finally 块包含一条 System.out.print("3"); 语句，意味着在方法结束前，会在控制台打印出 3。 当执行 main 方法时，控制台的输出将会是：31 这是因为 finally 块确保了它包含的 System.out.print("3"); 会执行并打印 3，随后 test() 方法返回 try 块中的值 1，最终结果就是 31。
题目 2
public class TryDemo {
public static void main(String[] args) {
System.out.println(test1());
}
public static int test1() {
try {
return 2;
} finally {
return 3;
}
}
}
执行结果：3。 try 返回前先执行 finally，结果 finally 里不按套路出牌，直接 return 了，自然也就走不到 try 里面的 return 了。 注意：finally 里面使用 return 仅存在于面试题中，实际开发这么写要挨揍的。
题目 3
public class TryDemo {
public static void main(String[] args) {
System.out.println(test1());
}
public static int test1() {
int i = 0;
try {
i = 2;
return i;
} finally {
i = 3;
}
}
}
执行结果：2。 大家可能会以为结果应该是 3，因为在 return 前会执行 finally，而 i 在 finally 中被修改为 3 了，那最终返回 i 不是应该为 3 吗？ 但其实，在执行 finally 之前，JVM 会先将 i 的结果暂存起来，然后 finally 执行完毕后，会返回之前暂存的结果，而不是返回 i，所以即使 i 已经被修改为 3，最终返回的还是之前暂存起来的结果 2。
字节流 vs 字符流？InputStream/OutputStream vs Reader/Writer？
InputStream 和 OutputStream。Reader 和 Writer。节点流 vs 处理流（包装流）？
FileInputStream、FileReader。BufferedInputStream、InputStreamReader。处理流不能独立存在，必须连接到一个节点流。FileInputStream / FileOutputStream 用于读写文件的字节流。
BufferedInputStream / BufferedOutputStream 为字节流提供缓冲功能，提高读写效率。
InputStreamReader / OutputStreamWriter（桥接字节与字符）
InputStreamReader：将字节输入流转换为字符输入流，可以指定字符编码。
OutputStreamWriter：将字符输出流转换为字节输出流，可以指定字符编码。
BufferedReader / BufferedWriter（高效读写文本）
为字符流提供缓冲功能，BufferedReader 提供了 readLine() 方法，方便读取文本行。
PrintStream / PrintWriter（格式化输出）
提供 print、println、printf 等方法，方便格式化输出。
BIO、NIO、AIO 的区别？
FileChannel、ByteBuffer、Selector、Path、Files 工具类？
FileChannel：NIO 中用于读写文件的通道。ByteBuffer：NIO 中用于存储数据的缓冲区。Selector：NIO 中用于监控多个通道的事件（如连接、读就绪）。Path：NIO.2 中表示文件路径的接口。Files：NIO.2 中的工具类，提供了丰富的静态方法来操作文件和目录。零拷贝（transferTo）原理？
零拷贝技术（如 FileChannel.transferTo()）允许数据直接从文件系统缓存传输到网络套接字，而无需经过用户空间的缓冲区，减少了数据拷贝次数和上下文切换，极大地提高了大文件传输的性能。
读取文件时如何指定编码？（如 UTF-8）
使用 InputStreamReader 或 FileReader 的构造函数指定编码。
InputStreamReader isr = new InputStreamReader(new FileInputStream("file.txt"), "UTF-8");
BufferedReader br = new BufferedReader(isr);
乱码问题如何解决？ 乱码问题通常是由于读取和写入时使用的字符编码不一致导致的。解决方法是确保在整个 I/O 流程中使用一致的编码（如 UTF-8）。
什么是序列化？用途？（RMI、网络传输、深拷贝）
Serializable 是标记接口吗？为什么？
是的，Serializable 是一个标记接口，它没有定义任何方法。它的存在只是告诉 JVM 这个类的对象可以被序列化。
serialVersionUID 的作用？不声明会怎样？
serialVersionUID 是一个版本号，用于在反序列化时验证序列化者和反序列化者是否加载了与序列化兼容的类。如果对象的 serialVersionUID 与目标类的不匹配，会抛出 InvalidClassException。serialVersionUID。如果类的结构发生变化（如添加字段），生成的 serialVersionUID 也会改变，导致反序列化失败。因此，建议显式声明一个 static final long serialVersionUID。static 和 transient 字段是否被序列化？
static 字段：不会被序列化。因为 static 属于类，不属于对象实例。transient 字段：不会被序列化。transient 关键字用于标记不希望被序列化的字段。如何自定义序列化过程？（writeObject / readObject 方法）
可以通过在类中定义 private void writeObject(ObjectOutputStream out) 和 private void readObject(ObjectInputStream in) 方法来控制序列化和反序列化过程。这些方法可以调用 defaultWriteObject() 和 defaultReadObject() 来处理默认的序列化，然后添加自定义逻辑。
readResolve() 方法的作用？（防止反序列化破坏单例）
readResolve() 方法用于在反序列化时返回一个指定的对象。在单例模式中，可以返回单例实例，从而保证反序列化后仍然是同一个实例，防止破坏单例。
反序列化时会调用构造函数吗？ 不会。反序列化是通过从字节流中重建对象，而不是通过构造器。因此，构造器不会被调用。
子类序列化，父类是否也必须实现 Serializable？如果父类没有实现会怎样？
Serializable，那么父类的字段不会被序列化。Externalizable 接口与 Serializable 的区别？
Serializable：Java 的默认序列化机制，简单但性能较低。Externalizable：是 Serializable 的子接口，提供了 writeExternal(ObjectOutput out) 和 readExternal(ObjectInput in) 方法，允许完全控制序列化过程，性能更高，但需要手动实现。OSI 七层模型 vs TCP/IP 四层模型？
TCP vs UDP 的区别？
三次握手、四次挥手？
SYN 包。SYN-ACK 包。ACK 包。FIN 包。ACK 包。FIN 包。ACK 包。InetAddress 类的使用？
InetAddress 类用于表示互联网协议 (IP) 地址。可以用来获取主机名、IP 地址等信息。
InetAddress address = InetAddress.getByName("www.example.com");
System.out.println(address.getHostAddress());
URL / URLClassLoader？
URL：表示一个统一资源定位符。URLClassLoader：可以加载来自 URL 指定位置的类和资源。Socket、ServerSocket 编程模型？
ServerSocket：用于服务端，监听指定端口的连接请求。Socket：用于客户端和服务端，代表一个网络连接。实现一个简单的客户端 - 服务器通信？ 以下是一个完整的、可运行的简单客户端 - 服务器通信示例。
服务端 (Server)
import java.io.*;
import java.net.*;
public class SimpleServer {
public static void main(String[] args) throws IOException {
// 创建 ServerSocket，监听 8080 端口
ServerSocket serverSocket = new ServerSocket(8080);
System.out.println("服务器启动，等待客户端连接...");
// 接受客户端连接
Socket clientSocket = serverSocket.accept();
System.out.println("客户端已连接：" + clientSocket.getInetAddress());
// 获取输入流，读取客户端消息
BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
String clientMessage = in.readLine();
System.out.println("收到客户端消息：" + clientMessage);
// 获取输出流，向客户端发送响应
PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);
out.println("Hello from Server! 你的消息已收到：" + clientMessage);
// 关闭资源
in.close();
out.close();
clientSocket.close();
serverSocket.close();
}
}
客户端 (Client)
import java.io.*;
import java.net.*;
public class SimpleClient {
public static void main(String[] args) throws IOException {
// 连接到本地 8080 端口的服务器
Socket socket = new Socket("localhost", 8080);
// 获取输出流，向服务器发送消息
PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
out.println("Hello from Client!");
// 获取输入流，读取服务器响应
BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
String serverResponse = in.readLine();
System.out.println("收到服务器响应：" + serverResponse);
// 关闭资源
out.close();
in.close();
socket.close();
}
}
运行说明：
SimpleServer，它会启动并等待连接。SimpleClient，它会连接到服务器并发送消息。Buffer、Channel、Selector 的作用？
Buffer 到 Channel 或反之。Channel 的事件（如连接、读就绪），实现单线程管理多个连接。SocketChannel、ServerSocketChannel？
SocketChannel：NIO 中的客户端通道。ServerSocketChannel：NIO 中的服务端通道，用于监听连接。SelectionKey 的四种事件（OP_READ、OP_WRITE 等）？
OP_READ：读就绪。OP_WRITE：写就绪。OP_CONNECT：连接就绪。OP_ACCEPT：接收连接就绪。Netty 是一个基于 NIO 的高性能网络应用框架，解决了 NIO 的复杂性，提供了更高级的 API。
泛型类、泛型方法、泛型接口的定义？
public class Generic<T> { ... }public <E> void printArray(E[] inputArray) { ... }public interface Generator<T> { T method(); }类型通配符：<?>、<? extends T>、<? super T>（PECS 原则）？
<?>：无界通配符，表示未知类型。<? extends T>：上界通配符，表示 T 或其子类型。Producer Extends (PECS)。<? super T>：下界通配符，表示 T 或其父类型。Consumer Super (PECS)。Java 泛型是通过类型擦除实现的？编译后泛型信息还在吗？
是的，Java 泛型是通过类型擦除实现的。在编译期间，所有泛型类型信息都会被擦除，替换为它们的边界（如 Object 或指定的上界）。因此，运行时无法获取泛型的类型信息。
什么是桥方法（Bridge Method）？为什么需要？ 桥方法是编译器为了实现泛型重写而自动生成的合成方法。它用于解决类型擦除后方法签名冲突的问题，确保多态性正常工作。
不能 new T()？为什么？
因为在运行时，泛型类型 T 已经被擦除，JVM 无法知道 T 的具体类型，因此无法实例化。
不能创建泛型数组？如何绕过？（Array.newInstance()）
因为数组在运行时需要知道确切的组件类型，而泛型类型在运行时被擦除。可以通过 Array.newInstance() 方法绕过，例如 Array.newInstance(componentType, size)。
List 和 List 是否有继承关系？
没有。List<String> 不是 List<Object> 的子类型。泛型是不可变的。
原始类型（Raw Type）的风险？
使用原始类型会失去泛型的类型安全检查，可能导致 ClassCastException 在运行时抛出。
如何获取 Class 对象？（Class.forName()、.class、getClass()）
Class.forName("全限定类名")类名.class对象.getClass()反射获取构造器、方法、字段？
getConstructor() / getDeclaredConstructor()getMethod() / getDeclaredMethod()getField() / getDeclaredField()调用私有方法或访问私有字段？（setAccessible(true)）
通过 setAccessible(true) 可以绕过访问控制检查，访问私有成员。
依赖注入、工厂模式、JDBC 加载驱动、Spring AOP、动态代理等？
反射广泛应用于框架中，如 Spring 通过反射创建和管理 Bean，JDBC 通过 Class.forName() 加载驱动，动态代理在运行时生成代理类。
反射的性能开销？如何优化？（MethodHandle、缓存 Method 对象）
反射性能较低，因为需要进行类型检查和安全检查。可以通过缓存Method、Field 对象或使用 MethodHandle 来优化。
反射破坏单例？如何防止？ 反射可以通过调用私有构造器破坏单例。防止方法是在构造器中检查实例是否已存在并抛出异常。
该包提供了 Field、Method、Constructor 等类，用于表示和操作类的成员。
说一下你对注解的理解？ Java 注解本质上是一个标记，可以理解成生活中的一个人的一些小装扮，比如戴什么什么帽子，戴什么眼镜。 注解可以标记在类上、方法上、属性上等，标记自身也可以设置一些值，比如帽子颜色是绿色。 有了标记之后，我们就可以在编译或者运行阶段去识别这些标记，然后搞一些事情，这就是注解的用处。 例如我们常见的 AOP，使用注解作为切点就是运行期注解的应用；比如 lombok，就是注解在编译期的运行。 注解生命周期有三大类，分别是： ● RetentionPolicy.SOURCE：给编译器用的，不会写入 class 文件 ● RetentionPolicy.CLASS：会写入 class 文件，在类加载阶段丢弃，也就是运行的时候就没这个信息了 ● RetentionPolicy.RUNTIME：会写入 class 文件，永久保存，可以通过反射获取注解信息 像常见的 @Override 就是给编译器用的，编译器编译的时候检查没问题就 over 了，class 文件里面不会有 Override 这个标记。 再比如 Spring 常见的 @Autowired，就是 RUNTIME 的，所以在运行的时候可以通过反射得到注解的信息，还能拿到标记的值 required。
JDK 1.8 都有哪些新特性？ JDK 1.8 新增了不少新的特性，如 Lambda 表达式、接口默认方法、Stream API、日期时间 API、Optional 类等。 ①、Java 8 允许在接口中添加默认方法和静态方法。 public interface MyInterface { default void myDefaultMethod() { System.out.println("My default method"); } static void myStaticMethod() { System.out.println("My static method"); } } ②、Lambda 表达式描述了一个代码块（或者叫匿名方法），可以将其作为参数传递给构造方法或者普通方法以便后续执行。 public class LambdaTest { public static void main(String[] args) { new Thread(() -> System.out.println("Hello World")).start(); } } 《Effective Java》的作者 Josh Bloch 建议使用 Lambda 表达式时，最好不要超过 3 行。否则代码可读性会变得很差。 ③、Stream 是对 Java 集合框架的增强，它提供了一种高效且易于使用的数据处理方式。 List list = new ArrayList<>(); list.add("中国加油"); list.add("世界加油"); list.add("世界加油"); long count = list.stream().distinct().count(); System.out.println(count); ④、Java 8 引入了一个全新的日期和时间 API，位于 java.time 包中。这个新的 API 纠正了旧版 java.util.Date 类中的许多缺陷。 LocalDate today = LocalDate.now(); System.out.println("Today's Local date : " + today); LocalTime time = LocalTime.now(); System.out.println("Local time : " + time); LocalDateTime now = LocalDateTime.now(); System.out.println("Current DateTime : " + now); ⑤、引入 Optional 是为了减少空指针异常。 Optional optional = Optional.of("Hello"); optional.isPresent(); // true optional.get(); // "Hello" optional.orElse("Fallback"); // "Hello" optional.ifPresent((s) -> System.out.println(s.charAt(0))); // "H"
Lambda 表达式了解多少？ Lambda 表达式主要用于提供一种简洁的方式来表示匿名方法，使 Java 具备了函数式编程的特性。 比如我们可以使用 Lambda 表达式来简化线程的创建： new Thread(() -> System.out.println("Hello World")).start(); 这比以前的匿名内部类要简洁很多。 所谓的函数式编程，就是把函数作为参数传递给方法，或者作为方法的结果返回。比如说我们可以配合 Stream 流进行数据过滤： List numbers = Arrays.asList(1, 2, 3, 4, 5, 6); List evenNumbers = numbers.stream() .filter(n -> n % 2 == 0) .collect(Collectors.toList()); 其中 n -> n % 2 == 0 就是一个 Lambda 表达式。表示传入一个参数 n，返回 n % 2 == 0 的结果。
Java8 有哪些内置函数式接口？ JDK 1.8 API 包含了很多内置的函数式接口。其中就包括我们在老版本中经常见到的 Comparator 和 Runnable，Java 8 为他们添加了 @FunctionalInterface 注解，以用来支持 Lambda 表达式。 除了这两个之外，还有 Callable、Predicate、Function、Supplier、Consumer 等等。
Optional 了解吗？ Optional 是用于防范 NullPointerException。 可以将 Optional 看做是包装对象（可能是 null，也有可能非 null）的容器。当我们定义了一个方法，这个方法返回的对象可能是空，也有可能非空的时候，我们就可以考虑用 Optional 来包装它，这也是在 Java 8 被推荐使用的做法。 Optional optional = Optional.of("bam"); optional.isPresent(); // true optional.get(); // "bam" optional.orElse("fallback"); // "bam" optional.ifPresent((s) -> System.out.println(s.charAt(0))); // "b"
Stream 流用过吗？ Stream 流，简单来说，使用 java.util.stream 对一个包含一个或多个元素的集合做各种操作。这些操作可能是中间操作亦或是终端操作。终端操作会返回一个结果，而中间操作会返回一个 Stream 流。 Stream 流一般用于集合，我们对一个集合做几个常见操作： List stringCollection = new ArrayList<>(); stringCollection.add("add2"); stringCollection.add("aaa2"); stringCollection.add("bbb1"); stringCollection.add("aaa1"); stringCollection.add("bbb3"); stringCollection.add("ccc"); stringCollection.add("bbb2"); stringCollection.add("ddd1");
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
查找任何按下的键的javascript键代码、代码、位置和修饰符。 在线工具，Keycode 信息在线工具，online
JavaScript 字符串转义/反转义；Java 风格 \uXXXX（Native2Ascii）编码与解码。 在线工具，Escape 与 Native 编解码在线工具，online
使用 Prettier 在浏览器内格式化 JavaScript 或 HTML 片段。 在线工具，JavaScript / HTML 格式化在线工具，online
Terser 压缩、变量名混淆，或 javascript-obfuscator 高强度混淆（体积会增大）。 在线工具，JavaScript 压缩与混淆在线工具，online
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online