Java 基础面试三

Java 泛型

【中等】Java 泛型的作用是什么？⭐⭐

Java 泛型是什么？

泛型允许在类、接口、方法上使用类型参数（如 <T>），使代码能适应多种数据类型，同时保证类型安全。

Java 泛型有什么用？

• 类型安全：编译时检查类型，避免运行时 ClassCastException。
• 代码复用：同一套逻辑可处理不同数据类型（如 List<String> 和 List<Integer>）。
• 消除强制转换：直接使用泛型类型，无需手动转换（如 (String) list.get(0)）。

Java 泛型有什么特性？

• 类型擦除：泛型仅在编译时有效，运行时类型信息会被擦除（List<String> 运行时变成 List）。
• 通配符 <?>：表示未知类型（如 List<?> 可接受任意类型的 List）。
• 界限限定：
  • T extends Class（限定类型范围，如 <T extends Number>）。
  • <? super T>（支持父类类型）。

简单示例

// 泛型类
class Box<T> {
    private T content;
    public void set(T content) { this.content = content; }
    public T get() { return content; }
}

// 使用
Box<String> box = new Box<>();
box.set("Hello");
String value = box.get(); // 无需强制转换

一句话总结：泛型让代码更灵活、安全，减少冗余和运行时错误。

【中等】什么是 Java 泛型的上下界限定符？⭐⭐

Java 泛型的上下界限定符用于限制泛型类型参数的范围，确保类型安全，提供更灵活的类型约束。

Java 什么是上界限定符？有什么用？

上界限定符（<? extends T>） 限定泛型类型必须是 T 或其子类（T 可以是类或接口）。

特点：

• 只读安全：能安全读取数据（因为元素至少是 T 类型）。
• 不能写入：无法确定具体子类型，防止类型污染。

示例：

// 接受 Number 或其子类（如 Integer, Double）
void printList(List<? extends Number> list) {
    for (Number num : list) {  // 安全读取
        System.out.println(num);
    }
    // list.add(1);  // 编译错误！无法安全写入
}

Java 什么是下界限定符？有什么用？

下界限定符（<? super T>）限定泛型类型必须是 T 或其父类。

特点：

• 可写入：能安全添加 T 及其子类的对象。
• 读取受限：只能以 Object 类型读取（因为父类型不确定）。

示例：

// 接受 Integer 或其父类（如 Number, Object）
void addNumbers(List<? super Integer> list) {
    list.add(1);     // 安全写入 Integer
    list.add(2);
    // Integer num = list.get(0);  // 编译错误！需强制转换
    Object obj = list.get(0);      // 只能以 Object 读取
}

通配符限定对比

类型	语法	读取	写入	应用
上界	? extends T	安全（作为 T）	禁止	生产者场景
下界	? super T	需转 Object	安全（T 及子类）	消费者场景
无界	?	作为 Object	禁止	完全不确定类型

小结

• extends T：安全读取，限制类型上界。如遍历 List<? extends Number>。
• super T：安全写入，限制类型下界。如 Collections.copy(dest<? super T>, src<? extends T>)。
• PECS 原则（Producer-Extends, Consumer-Super）指导何时用哪种限定符。
  • 生产者（Producer） 用 extends（输出数据）。
  • 消费者（Consumer） 用 super（输入数据）。

【中等】泛型擦除的作用是什么？⭐⭐

泛型擦除是 Java 在编译时检查类型安全、运行时丢弃类型信息的折中设计，平衡了兼容性、性能和类型安全，但牺牲了部分运行时灵活性。

泛型擦除是 Java 泛型的实现机制：

• 编译时：泛型类型（如 <T>、List<String>）会被检查，确保类型安全。
• 运行时：所有泛型类型信息会被擦除，替换为原始类型（Raw Type）或边界类型（如 Object/extends 上限）。

泛型擦除规则

泛型定义	擦除后类型	示例
无界限 <T>	Object	List<T> → List
有界限 <T extends Number>	Number（边界类型）	Box<T> → Box<Number>
通配符 <?> / <? extends T>	边界类型	List<?> → List
<? super T>	Object	List<? super Integer> → List

泛型擦除作用

• 兼容性：确保泛型代码能与旧版 Java（非泛型）字节码兼容。
• 运行时效率：避免为每个泛型类型生成新类，减少 JVM 负担。
• 简化设计：统一类型系统，避免 C++ 模板的复杂性。

泛型擦除的问题

• 类型信息丢失：运行时无法获取泛型参数（如 List<String> 和 List<Integer> 运行时都是 List）。

  List<String> list = new ArrayList<>();
  System.out.println(list.getClass());  // 输出 ArrayList，而非 ArrayList<String>

• 强制类型转换：编译器自动插入类型转换代码。

  List<String> list = new ArrayList<>();
  String s = list.get(0);  // 编译后实际为：(String) list.get(0)

• 不支持原生类型：不能直接使用 List<int>，必须用包装类（如 List<Integer>）。

绕过擦除的限制

• 显式传递 Class<T>：通过反射保留类型信息。

  <T> void create(Class<T> clazz) {
      T instance = clazz.newInstance();  // 运行时知道具体类型
  }

• 类型令牌（Type Token）：利用匿名子类捕获泛型类型。

  new TypeToken<List<String>>() {};  // Guava 提供的方案

典型问题与解决方案

问题场景	解决方案
需要运行时获取泛型类型	传递 Class<T> 参数或使用 Type Token
泛型数组创建（new T[]）	使用 Object[] 转换或反射（Array.newInstance）
方法重载冲突（如 void foo(List<String>) 和 void foo(List<Integer>)）	编译报错（擦除后方法签名相同）

Java 反射

【简单】什么是反射？反射有什么作用？⭐⭐

反射（Reflection）是 Java 提供的动态机制，允许程序在运行时：

• 获取类的信息（类名、方法、字段、注解等）
• 操作类的成员（调用方法、访问/修改字段、创建对象等）
• 绕过访问控制（如调用私有方法）

反射核心类：

• Class<T>：表示类或接口
• Method：表示类的方法
• Field：表示类的字段
• Constructor：表示类的构造方法

反射的主要用途

• 动态代理（如插件化开发）
• 依赖注入（如 Spring 的依赖注入）
• ORM（Hibernate 的 ORM 映射）
• 测试工具（如 Mockito 模拟对象）
• 绕过访问限制（调试或特殊场景）

如何使用反射？

获取 Class 对象

// 方式1：通过类名.class
Class<String> strClass = String.class;

// 方式2：通过对象.getClass()
String s = "Hello";
Class<?> strClass2 = s.getClass();

// 方式3：通过Class.forName("全限定类名")
Class<?> strClass3 = Class.forName("java.lang.String");  // 需处理ClassNotFoundException

创建对象

// 方式1：直接调用无参构造（需强制类型转换）
Class<?> clazz = Class.forName("com.example.User");
User user = (User) clazz.newInstance();  // 已过时，推荐用 getConstructor()

// 方式2：调用带参构造
Constructor<?> constructor = clazz.getConstructor(String.class, int.class);
User user = (User) constructor.newInstance("Alice", 25);

调用方法

// 获取方法（需方法名 + 参数类型）
Method method = clazz.getMethod("setName", String.class);

// 调用方法（需对象实例 + 参数值）
method.invoke(user, "Bob");  // 相当于 user.setName("Bob")

// 调用静态方法
Method staticMethod = clazz.getMethod("staticMethod");
staticMethod.invoke(null);  // 静态方法传 null

访问/修改字段

// 获取字段（包括私有字段）
Field field = clazz.getDeclaredField("name");

// 允许访问私有字段
field.setAccessible(true);  // 关闭访问检查

// 读取字段值
String name = (String) field.get(user);  // 相当于 user.name

// 修改字段值
field.set(user, "Charlie");  // 相当于 user.name = "Charlie"

获取注解信息

// 获取类/方法/字段上的注解
Annotation[] annotations = clazz.getAnnotations();
if (clazz.isAnnotationPresent(MyAnnotation.class)) {
    MyAnnotation anno = clazz.getAnnotation(MyAnnotation.class);
}

【简单】反射有什么优缺点？⭐⭐

优点	缺点
动态性高（运行时决定行为）	性能较差（比直接调用慢）
可访问私有成员（突破封装）	代码可读性降低
支持泛型擦除后的类型操作	安全隐患（如破坏单例）

性能优化建议：

• 缓存 Class/Method/Field 对象：避免重复反射调用。
• 优先使用 getDeclaredXXX：比 getXXX 更高效（不检查继承链）。
• 限制 setAccessible(true)：频繁调用影响性能。

注意事项：

• 反射可以破坏封装性（如修改 final 字段、调用私有方法）。
• 慎用 setAccessible(true)：可能导致安全漏洞（如绕过权限检查）。

扩展

Java Reflection: Why is it so slow? 。

【中等】什么是 Java 中的动态代理？⭐⭐

动态代理是一种在运行时动态创建代理对象的技术，允许在不修改原始类代码的情况下，增强或拦截目标对象的方法调用。

Java 动态代理通过 Proxy 和 InvocationHandler 在运行时生成接口代理对象，非侵入式地实现方法拦截和功能增强，是 AOP 和框架设计的核心技术。

• java.lang.reflect.Proxy：提供静态方法创建代理对象（核心方法：Proxy.newProxyInstance()）。
• java.lang.reflect.InvocationHandler：接口，实现代理逻辑（核心方法：invoke()）。

【示例】动态代理示例

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

// 1. 定义接口
interface Hello {
    void sayHello();
}

// 2. 实现接口
class HelloImpl implements Hello {
    public void sayHello() {
        System.out.println("Hello World!");
    }
}

public class SimpleProxyDemo {
    public static void main(String[] args) {
        // 3. 创建实际对象
        Hello realHello = new HelloImpl();

        // 4. 创建代理对象
        Hello proxyHello = (Hello) Proxy.newProxyInstance(
            Hello.class.getClassLoader(), // 类加载器
            new Class<?>[] { Hello.class }, // 代理的接口
            new InvocationHandler() { // 调用处理器
                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                    System.out.println("Before method call");
                    Object result = method.invoke(realHello, args); // 调用真实对象的方法
                    System.out.println("After method call");
                    return result;
                }
            });

        // 5. 通过代理对象调用方法
        proxyHello.sayHello();
    }
}

动态代理的特点

• 运行时生成：代理类在运行时动态生成，无需手动编写。
• 基于接口：只能代理接口（不能代理普通类）。
• 非侵入性：无需修改原始代码即可增强功能。

应用场景

• AOP（面向切面编程）：如日志、事务管理（Spring AOP 基于动态代理）。
• 远程方法调用（RPC）：如 Dubbo 的消费者代理。
• 权限控制：拦截方法调用检查权限。

动态代理 vs 静态代理

对比项	动态代理	静态代理
生成时机	运行时动态生成	编译时手动编写
维护成本	低（自动适配接口）	高（需为每个类编写代理）
灵活性	高（通用逻辑集中处理）	低（逻辑分散）

局限性

• 仅支持接口代理：不能代理普通类（CGLIB 可弥补此问题）。
• 性能开销：反射调用比直接调用略慢（现代 JVM 已优化）。

扩展：CGLIB 动态代理

• 原理：通过字节码技术生成目标类的子类代理。
• 特点：可代理普通类，但无法代理 final 类/方法。

【中等】JDK 动态代理和 CGLIB 动态代理有什么区别？⭐⭐

JDK 动态代理 vs. CGLIB 动态代理：

代理类型	JDK 动态代理	CGLIB 代理
实现机制	基于接口，运行时生成代理类（$Proxy0）	基于继承，生成目标类的子类
技术依赖	Java 反射 API（Proxy类）	ASM 字节码操作库
限制条件	目标类必须实现接口	无法代理 final 类/方法
可代理目标	只能代理接口	可代理普通类和接口

性能对比

维度	JDK 动态代理	CGLIB 代理
生成速度	较快（反射生成）	较慢（需操作字节码）
调用速度	反射调用，略慢	直接方法调用，更快
内存占用	较小	较大（生成子类）

注：现代 JVM 对反射做了优化，JDK 代理性能差距已不明显。

使用示例

JDK 动态代理

// 要求：目标类必须实现接口
public interface UserService {
    void save();
}

// 代理逻辑
InvocationHandler handler = (proxy, method, args) -> {
    System.out.println("JDK 代理前置处理");
    Object result = method.invoke(target, args);
    System.out.println("JDK 代理后置处理");
    return result;
};

UserService proxy = (UserService) Proxy.newProxyInstance(
    target.getClass().getClassLoader(),
    target.getClass().getInterfaces(),  // 关键：需传入接口
    handler
);

CGLIB 代理

// 目标类无需实现接口
public class UserService {
    public void save() { System.out.println("保存用户"); }
}

// 代理逻辑
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(UserService.class);
enhancer.setCallback((MethodInterceptor) (obj, method, args, proxy) -> {
    System.out.println("CGLIB 代理前置处理");
    Object result = proxy.invokeSuper(obj, args);  // 直接调用父类方法
    System.out.println("CGLIB 代理后置处理");
    return result;
});

UserService proxy = (UserService) enhancer.create();  // 生成子类对象

如何选择？

场景	推荐代理	理由
目标对象实现了接口	JDK 动态代理	轻量级，标准库支持
目标对象无接口	CGLIB	唯一选择
需要代理 final 方法	JDK 动态代理	CGLIB 无法代理 final 方法
高性能要求（如高频调用）	CGLIB	直接方法调用更快
避免额外依赖	JDK 动态代理	CGLIB 需引入第三方库

主流框架的选择

• Spring AOP：
  • 默认使用 JDK 动态代理（如果目标有接口）
  • 无接口时自动切换为 CGLIB
  • 可通过 @EnableAspectJAutoProxy(proxyTargetClass=true) 强制使用 CGLIB
• MyBatis：Mapper 接口代理使用 JDK 动态代理

一句话总结

• JDK 动态代理：基于接口，反射实现，轻量但功能有限。
• CGLIB：基于继承，字节码增强，功能强但有 final 限制。
• 选择依据：目标是否有接口、性能需求、是否允许第三方依赖。

Java 注解

【中等】Java 中的注解原理是什么？⭐⭐

注解通过编译期处理（APT）或运行时反射实现元数据编程，其本质是特殊接口，由 JVM 或工具库按生命周期策略处理。

注解本质

• 元数据标签：注解本质是继承自 java.lang.annotation.Annotation 的接口
• 编译后保留策略：通过 @Retention 指定生命周期
  • SOURCE：仅保留在源码（如 @Override）
  • CLASS：保留到字节码（默认）
  • RUNTIME：运行时可通过反射读取（如 @SpringBootApplication）

核心处理机制

• 编译期处理：
  • APT（Annotation Processing Tool）：在编译时生成代码（如 Lombok）
  • 编译器检查：如 @Override 验证方法重写
• 运行时处理：
  • 反射读取：通过 getAnnotation() 获取注解信息（如 Spring 扫描 @Component）
  • 动态代理：结合 AOP 实现功能增强（如 @Transactional）

关键技术点

• 元注解：修饰注解的注解（如 @Target 指定作用目标）
• 注解属性：本质是接口方法（需编译时常量值）
• 字节码操作：ASM 等工具可直接修改字节码中的注解信息

应用场景

• 框架配置：Spring 的 @Autowired、@RequestMapping
• 代码生成：Lombok 的 @Data
• 静态检查：@Nullable、@Deprecated

【中等】如何自定义注解并使用注解处理器？⭐

自定义注解：

@Target(ElementType.METHOD)           // 作用目标
@Retention(RetentionPolicy.RUNTIME)   // 保留策略
@Documented
public @interface MyAnnotation {
    String value() default "";
    int priority() default 0;
}

元注解详解：

元注解	作用
@Target	作用目标（TYPE/FIELD/METHOD/PARAMETER 等）
@Retention	保留策略（SOURCE/CLASS/RUNTIME）
@Documented	Javadoc 包含
@Inherited	子类继承（仅类级别）
@Repeatable	可重复（Java 8+）

使用与读取：

@MyAnnotation(value = "test", priority = 1)
public void process() { ... }

// 反射读取
Method method = clazz.getMethod("process");
MyAnnotation anno = method.getAnnotation(MyAnnotation.class);

注解处理器（Annotation Processor）：编译期处理注解，生成代码（如 Lombok）。

@SupportedAnnotationTypes("com.example.MyAnnotation")
public class MyProcessor extends AbstractProcessor {
    @Override
    public boolean process(Set<? extends TypeElement> annotations,
                           RoundEnvironment roundEnv) {
        for (Element e : roundEnv.getElementsAnnotatedWith(MyAnnotation.class)) {
            // 用 Filer 生成源文件
        }
        return true;
    }
}

注册：META-INF/services/javax.annotation.processing.Processor 写入全限定名。

典型应用：Lombok、ButterKnife、MapStruct、Dagger。

Java 枚举

【中等】Java 枚举的原理是什么？⭐

Java 枚举（enum）从 JDK 5 引入，本质是继承自 java.lang.Enum 的 final 类，每个枚举常量是类的单例实例。

编译前：

public enum Color {
    RED, GREEN, BLUE;
}

编译后等价于（伪代码）：

public final class Color extends java.lang.Enum<Color> {
    public static final Color RED = new Color("RED", 0);
    public static final Color GREEN = new Color("GREEN", 1);
    public static final Color BLUE = new Color("BLUE", 2);

    private Color(String name, int ordinal) { super(name, ordinal); }

    public static Color[] values() { /* 返回所有常量 */ }
    public static Color valueOf(String name) { /* 按名称查找 */ }
}

枚举的核心特性：

特性	说明
继承关系	隐式继承 java.lang.Enum，无法再继承其他类
final 修饰	枚举类不可被继承（防止破坏单例）
实例唯一性	每个常量是 JVM 级别的单例（类加载时创建）
可定义成员	字段、方法、构造器（仅 private 包访问）
可实现接口	弥补无法继承的限制
支持 switch	编译器优化为 ordinal 比较

带属性和方法的枚举：

public enum OrderStatus {
    PENDING(0, "待支付"),
    PAID(1, "已支付"),
    SHIPPED(2, "已发货"),
    COMPLETED(3, "已完成");

    private final int code;
    private final String desc;

    OrderStatus(int code, String desc) {  // 构造器默认 private
        this.code = code;
        this.desc = desc;
    }

    public int getCode() { return code; }
    public String getDesc() { return desc; }

    // 实现接口方法或抽象方法
    public boolean canCancel() {
        return this == PENDING;
    }
}

枚举与反射：

• Constructor.newInstance() 禁止创建枚举对象（源码有强制检查）。
• Enum.valueOf() 是获取枚举实例的安全方式。

【中等】为什么说枚举是实现单例的最佳方式？⭐

《Effective Java》Item 3 明确推荐：单元素的枚举类型是实现 Singleton 的最佳方法。

枚举单例的优势：

public enum Singleton {
    INSTANCE;

    public void doSomething() { /* ... */ }
}

// 使用
Singleton.INSTANCE.doSomething();

对比维度	枚举单例	饿汉式	懒汉式（DCL）	静态内部类
线程安全	✔️ JVM 保证	✔️ 类加载保证	✔️ volatile+synchronized	✔️ 类加载保证
防反射攻击	✔️ 强制禁止	❌ 可破坏	❌ 可破坏	❌ 可破坏
防序列化破坏	✔️ 自动处理	❌ 需 readResolve	❌ 需 readResolve	❌ 需 readResolve
懒加载	❌ 否	❌ 否	✔️ 是	✔️ 是
代码简洁	⭐ 最简洁	简单	复杂	较简单

枚举单例的底层保证：

1. 类加载线程安全：枚举实例在类加载的 <clinit> 阶段创建，JVM 保证原子性。
2. 反射防御：Constructor.newInstance() 源码中检查 Enum，直接抛异常。
3. 序列化特殊处理：枚举的序列化/反序列化由 JVM 特殊处理，仅写入名称，反序列化时通过 valueOf 返回已有实例。

枚举单例的局限：

• 无法懒加载：枚举类加载时即创建实例。
• 无法继承其他类（枚举已继承 Enum）。

【简单】EnumMap 和 EnumSet 有什么用？⭐

EnumMap 和 EnumSet 是专为枚举优化的高性能容器，基于序号（ordinal）的数组实现。

EnumMap：

enum Day { MON, TUE, WED, THU, FRI, SAT, SUN }

EnumMap<Day, String> schedule = new EnumMap<>(Day.class);
schedule.put(Day.MON, "开会");
schedule.put(Day.FRI, "周报");

// 内部实现：Object[] values = new Object[Day.values().length]
// 索引 = key.ordinal()

EnumSet：

EnumSet<Day> weekend = EnumSet.of(Day.SAT, Day.SUN);
EnumSet<Day> workdays = EnumSet.range(Day.MON, Day.FRI);
EnumSet<Day> all = EnumSet.allOf(Day.class);

// 内部实现：当枚举数 ≤ 64 时用 RegularEnumSet（一个 long 位图）
// 否则用 JumboEnumSet（long[] 位图）

性能对比：

容器	底层	时间复杂度	内存占用
EnumMap	数组（索引=ordinal）	O(1)	极小（固定长度数组）
EnumSet	位图（bitmask）	O(1)	极小（1 个 long）
HashMap	哈希表	O(1) 平均	较大（节点+桶）
HashSet	HashMap	O(1) 平均	较大

适用场景：

• 枚举作为键的 Map → 用 EnumMap 替代 HashMap。
• 枚举集合操作（权限、状态组合）→ 用 EnumSet 替代 HashSet。

Java SPI

【中等】什么是 SPI，有什么用？⭐⭐

SPI 通过接口+配置文件实现运行时服务发现，是解耦和扩展的利器，JDBC/日志等经典框架均基于此机制。

SPI 是 Java 提供的服务发现机制，通过接口与实现分离，实现：

• 运行时动态加载实现类
• 解耦接口与实现
• 可插拔式扩展

核心组成

组件	作用	示例
接口	定义服务标准	java.sql.Driver
实现类	提供具体功能	com.mysql.cj.jdbc.Driver
配置文件	声明实现类	META-INF/services/接口全限定名

工作原理

• 在META-INF/services/下创建以接口全限定名命名的文件
• 文件中写入实现类全限定名（每行一个）
• 通过ServiceLoader动态加载实现类

主要应用场景

• JDBC 驱动加载（DriverManager）
• 日志门面实现（SLF4J → Logback/Log4j）
• Spring Boot 自动配置
• Dubbo 扩展点机制

优势与局限

优势	局限
实现热插拔	配置文件需严格规范
解耦接口与实现	原生 SPI 会加载所有实现类（可能浪费资源）
扩展性强	无默认实现筛选机制

与 API 的区别

维度	SPI	API
调用方向	由实现方提供，调用方选择	由提供方定义，调用方使用
控制权	调用方控制	提供方控制
典型场景	JDBC 驱动、日志实现	Java 标准库

改进方案

• Dubbo SPI：增加按需加载、扩展点缓存等优化
• Spring Factories：META-INF/spring.factories机制

Java IO

【简单】什么是序列化？什么是反序列化？⭐⭐

基本概念

• 序列化：将对象转换为字节流（用于存储/传输）
• 反序列化：将字节流恢复为对象

核心用途

• 持久化存储（如保存到文件/数据库）
• 网络传输（如 RPC 调用）
• 深拷贝实现（通过序列化+反序列化）

Java 实现方式

方式	特点	示例
Serializable接口	标记接口，默认 Java 序列化	class User implements Serializable
Externalizable接口	需手动实现读写逻辑	覆盖writeExternal()/readExternal()
第三方库（JSON/Protobuf 等）	跨语言、高效	Gson、Jackson、Protobuf

关键注意事项

• serialVersionUID：显式声明版本号，避免反序列化失败

  private static final long serialVersionUID = 1L;

• 敏感字段处理：用transient跳过序列化

  private transient String password;  // 不会被序列化

• 性能优化：

  • 避免序列化大对象
  • 第三方库（如 Protobuf）比 Java 原生序列化更快

常见序列化协议对比

协议	语言支持	可读性	性能	典型应用
Java 原生	仅 Java	差	低	Java RMI
JSON	多语言	好	中	Web API
Protobuf	多语言	差	高	gRPC
Hessian	多语言	差	中	Dubbo

安全风险

• 反序列化漏洞：恶意字节流可触发代码执行（需校验数据来源）
• 解决方案：
  • 使用白名单控制反序列化类
  • 替换为 JSON 等文本协议

【中等】Java 提供了哪些 IO 方式？⭐⭐

Java 提供了多种 I/O（输入输出）方式，主要分为 传统 I/O（BIO）、NIO（New I/O）、AIO（异步 I/O） 三大类，并支持 文件操作、网络通信、序列化 等场景。以下是主要 I/O 方式的概述及要点：

什么是 BIO？

传统 I/O（BIO，Blocking I/O）是同步阻塞式 I/O，适用于连接数较少、延迟不敏感的场景。

核心类：

• 字节流：InputStream / OutputStream（如 FileInputStream、FileOutputStream）
• 字符流：Reader / Writer（如 FileReader、FileWriter）
• 缓冲流：BufferedReader、BufferedWriter（提升性能）
• 标准 I/O：System.in（输入）、System.out（输出）

示例：

try (BufferedReader reader = new BufferedReader(new FileReader("file.txt"))) {
    String line;
    while ((line = reader.readLine()) != null) {
        System.out.println(line);
    }
}

缺点：每个连接需要独立的线程，高并发时资源消耗大。

什么是 NIO？

NIO（New I/O，Non-blocking I/O）是同步非阻塞 I/O，基于 通道（Channel） 和 缓冲区（Buffer），支持多路复用（Selector）。

核心类：

• Buffer：ByteBuffer、CharBuffer（数据存储）
• Channel：FileChannel、SocketChannel、ServerSocketChannel（数据传输）
• Selector：监听多个通道的事件（如连接、读、写）

示例（NIO 文件复制）：

try (FileChannel src = FileChannel.open(Paths.get("src.txt"));
     FileChannel dest = FileChannel.open(Paths.get("dest.txt"), StandardOpenOption.CREATE, StandardOpenOption.WRITE)) {
    src.transferTo(0, src.size(), dest);
}

• 优点：单线程可处理多个连接，适合高并发（如 Netty 框架底层）。
• 缺点：编程复杂度较高。

什么是 AIO？

AIO（Asynchronous I/O）是异步非阻塞 I/O，基于回调或 Future 机制，适用于高吞吐场景。

核心类：

• AsynchronousFileChannel（文件操作）
• AsynchronousSocketChannel（网络通信）
• CompletionHandler（回调接口）

示例（AIO 文件读取）：

AsynchronousFileChannel fileChannel = AsynchronousFileChannel.open(Paths.get("file.txt"));
ByteBuffer buffer = ByteBuffer.allocate(1024);
fileChannel.read(buffer, 0, buffer, new CompletionHandler<Integer, ByteBuffer>() {
    @Override
    public void completed(Integer result, ByteBuffer attachment) {
        System.out.println("Read " + result + " bytes");
    }
    @Override
    public void failed(Throwable exc, ByteBuffer attachment) {
        exc.printStackTrace();
    }
});

• 优点：真正异步，适合长连接、高吞吐场景（如大文件传输）。
• 缺点：JDK 实现较少，Linux 支持有限（底层依赖 epoll）。

有哪些常见的 IO 工具？

• 序列化：ObjectInputStream / ObjectOutputStream（Java 原生序列化）
• 压缩流：GZIPInputStream、ZipOutputStream
• 内存映射文件：MappedByteBuffer（NIO 高性能文件访问）
• Files 工具类（Java 7+）：

  Files.readAllLines(Paths.get("file.txt")); // 快速读取文件

BIO vs. NIO vs. AIO？

类型	模型	适用场景	典型框架
BIO	同步阻塞	低并发、简单 I/O	Java Socket
NIO	同步非阻塞	高并发、网络通信	Netty、Tomcat NIO
AIO	异步非阻塞	高吞吐、大文件操作	较少使用

选择建议：

• BIO：简单文件操作或低并发场景。
• NIO：高并发网络编程（如 Netty）。
• AIO：需要真正异步 I/O 的场景（但实际使用较少）。

如果需要更高层次的封装，可以考虑 Apache Commons IO、Guava 等工具库。

【困难】NIO 如何实现多路复用？⭐⭐

Java NIO 的核心组件有哪些？

Java NIO 多路复用的核心是通过 Selector 轮询事件 + 非阻塞 Channel + Buffer 数据交换，允许单线程管理多个通道的 I/O 操作。这是构建高性能网络应用的基础，也是 Netty 等框架的底层原理。

Java NIO 核心组件

• Selector（选择器）：核心多路复用器，可监控多个 Channel 的 I/O 事件（如连接、读、写）
  • 通过 Selector.open() 创建
  • 一个 Selector 可绑定多个 Channel
• Channel（通道）：非阻塞 I/O 操作的抽象，支持读写。主要类型：
  • SocketChannel：TCP 网络通信
  • ServerSocketChannel：监听 TCP 连接
  • FileChannel：文件 I/O（不支持 Selector）
• Buffer（缓冲区）：数据容器（如 ByteBuffer），Channel 通过 Buffer 读写数据。

Java NIO 多路复用的实现步骤是怎样的？

多路复用实现步骤

(1) 创建 Selector 并注册 Channel

Selector selector = Selector.open();
ServerSocketChannel serverChannel = ServerSocketChannel.open();
serverChannel.configureBlocking(false); // 必须设为非阻塞
serverChannel.register(selector, SelectionKey.OP_ACCEPT); // 注册监听事件

(2) 事件类型

• SelectionKey.OP_ACCEPT：接受连接（ServerSocketChannel）
• SelectionKey.OP_CONNECT：连接就绪（SocketChannel）
• SelectionKey.OP_READ：数据可读
• SelectionKey.OP_WRITE：数据可写

(3) 事件轮询

while (true) {
    int readyChannels = selector.select(); // 阻塞直到有事件就绪
    if (readyChannels == 0) continue;

    Set<SelectionKey> selectedKeys = selector.selectedKeys();
    Iterator<SelectionKey> keyIterator = selectedKeys.iterator();

    while (keyIterator.hasNext()) {
        SelectionKey key = keyIterator.next();

        if (key.isAcceptable()) {
            // 处理新连接
        } else if (key.isReadable()) {
            // 处理读事件
        } else if (key.isWritable()) {
            // 处理写事件
        }

        keyIterator.remove(); // 必须移除已处理的键
    }
}

Java NIO 的关键机制有哪些？

(1) 非阻塞模式

• Channel 必须设置为非阻塞：channel.configureBlocking(false)
• 避免单线程因 I/O 操作阻塞

(2) 事件驱动

• Selector 通过操作系统级轮询（如 Linux 的 epoll）监听事件
• 仅处理活跃的 Channel，避免无效遍历

(3) SelectionKey

• 绑定 Channel 与 Selector 的关系
• 可通过 key.attachment() 附加自定义对象（如会话状态）

Java NIO 的底层原理是什么？

• Linux：基于 epoll 实现（高效监控大量文件描述符）
• Windows：基于 IOCP（完成端口）
• 相比传统 BIO 的线程池模型，NIO 单线程可处理数千连接

NIO 优点

• 单线程管理多连接，资源消耗低
• 高并发支持（如 Netty 框架底层依赖 NIO）
• 避免线程上下文切换开销

NIO 适用场景

• 高并发网络服务（如聊天服务器、API 网关）
• 需要长连接的应用（如 WebSocket）
• 大数据量、低延迟的 I/O 操作

【困难】Java 写入文件到磁盘会经历哪些过程？⭐⭐

要点

• 四级流水：用户缓冲区 → 内核页缓存 → 磁盘缓存 → 物理介质。
• 两次复制：默认路径下数据在用户和内核空间之间有一份拷贝。
• 持久化分水岭：write 返回仅入内核缓存，fsync 才落盘。
• 零拷贝：transferTo 消除用户空间拷贝，但数据仍可能在内核缓存停留。
• 刷盘策略：异步定时 + 内存压力 + 显式同步。

详细流程

总体流程

[Java 代码] → [JVM 堆缓冲区] → [系统调用] → [内核页缓存] → [磁盘控制器] → [物理介质]

应用层写入

• 直接写入：调用 FileOutputStream.write(byte[])，通过 JNI 进入 native 方法。
• 缓冲写入：使用 BufferedOutputStream，数据先写入 JVM 堆内缓冲区（默认 8KB），满缓冲区时才触发系统调用，以减少频繁的上下文切换。

系统调用与用户态→内核态切换

• JVM 发起 write() 系统调用，CPU 从用户态切换到内核态。
• 数据从 JVM 堆内存（用户空间）复制到内核空间的 页缓存（Page Cache）。此复制是必须的，因为内核不能直接访问用户进程内存。

内核页缓存管理

• 写入的数据暂存在 Page Cache 中，对应内存页被标记为 脏页（Dirty）。
• 读优化：后续读可直接命中缓存，避免磁盘 I/O。
• 刷盘触发时机：
  • 定时回写：内核线程（如 pdflush）周期性扫描脏页，默认 30 秒刷盘。
  • 内存压力：可用内存低于阈值时强制刷盘。
  • 显式同步：应用程序调用 fsync() 或 fdatasync()，立即将指定文件的脏页刷入磁盘。
  • 文件关闭：close() 会隐含刷新，但不保证物理落盘（依赖于文件系统实现）。

硬件层写入

• 内核通过设备驱动程序向磁盘控制器发送指令。
• 磁盘缓存：若磁盘启用了写缓存，数据可能先写入磁盘的易失性缓存，随后才真正写入盘片。此时系统调用返回成功，但数据仍未持久化。
• 物理写入：最终数据磁化到机械盘片或写入闪存单元。

挑战

数据持久化保证

• write() 返回：仅表示数据已复制到内核页缓存，不保证落盘。若系统崩溃，数据可能丢失。
• flush() 作用：仅刷新 JVM 用户缓冲区到内核，不触发 fsync，因此仍不能保证落盘。
• 强制落盘 API：
  • FileDescriptor.sync()：调用 fsync()，同步文件数据和元数据。
  • FileChannel.force(boolean metaData)：参数为 true 时同时刷新文件元数据。

零拷贝

• FileChannel.transferTo()：数据直接从内核页缓存发送到目标通道（如 Socket），避免一次用户空间拷贝，显著提升性能。
• 内存映射文件 MappedByteBuffer：将文件区域映射到进程地址空间，通过内存操作读写，缺页时由内核加载，修改后的数据由内核异步刷盘。

直接 I/O 与标准 I/O

• 标准 I/O：通过页缓存，适合大多数应用。
• 直接 I/O：绕过页缓存，直接与磁盘交互（需文件系统支持，如 Linux O_DIRECT 标志），适用于数据库等自管理缓存的系统，但要求用户缓冲区对齐。

写放大与随机小写

• 每次写入可能引发整个页（通常 4KB）的“读-修改-写”操作，称为写放大。小写入应尽量合并（如使用 BufferedOutputStream）。

内核参数调优（Linux）

• /proc/sys/vm/dirty_ratio：脏页占用内存百分比上限，触发刷盘。
• /proc/sys/vm/dirty_expire_centisecs：脏页最长存活时间（默认 30 秒）。
• /proc/sys/vm/dirty_writeback_centisecs：内核回写线程唤醒间隔。

Java 语法糖

【中等】Java 中有哪些常见的语法糖？⭐⭐

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

Java 中最常用的语法糖主要有泛型、自动拆装箱、变长参数、枚举、内部类、增强 for 循环、try-with-resources 语法、lambda 表达式等。所有这些语法糖在编译阶段都会被"脱糖"(desugar)，即转换为更基础的 Java 语法结构。可以使用javap -c命令查看字节码来验证这一点。语法糖虽然不增加语言功能，但能显著提高代码的可读性和编写效率，是 Java 语言不断演进的重要组成部分。

自动装箱与拆箱 (Autoboxing/Unboxing)

// 自动装箱
Integer i = 10;  // 实际编译为 Integer.valueOf(10)

// 自动拆箱
int n = i;      // 实际编译为 i.intValue()

增强 for 循环 (foreach)

List<String> list = Arrays.asList("a", "b", "c");
// 语法糖形式
for (String s : list) {
    System.out.println(s);
}
// 实际编译为迭代器模式
for (Iterator<String> it = list.iterator(); it.hasNext();) {
    String s = it.next();
    System.out.println(s);
}

变长参数 (Varargs)

public void print(String... args) {
    for (String arg : args) {
        System.out.println(arg);
    }
}
// 实际编译为数组参数
public void print(String[] args) { ... }

数值字面量下划线

int million = 1_000_000;  // 编译后等同于 1000000

字符串拼接

String s = "a" + "b" + "c";
// 编译优化为
String s = "abc";

// 变量拼接会转为 StringBuilder
String a = "a", b = "b";
String result = a + b;
// 编译为
String result = new StringBuilder().append(a).append(b).toString();

switch 支持字符串 (Java 7+)

String fruit = "apple";
switch (fruit) {
    case "apple":
        System.out.println("It's an apple");
        break;
    // 实际编译为基于 hashCode() 和 equals() 的比较
}

默认构造方法

public class Person {}
// 如果没有显式定义构造方法，编译器会自动添加无参构造方法

枚举类 (Java 5+)

enum Color { RED, GREEN, BLUE }
// 实际编译为继承 java.lang.Enum 的类

内部类访问外部类成员

class Outer {
    private int x = 10;
    class Inner {
        void print() {
            System.out.println(x);  // 实际通过 Outer.this.x 访问
        }
    }
}

方法引用 (Java 8+)

List<String> list = Arrays.asList("a", "b", "c");
list.forEach(System.out::println);
// 编译为 lambda 表达式
list.forEach(s -> System.out.println(s));

钻石操作符 (Diamond Operator, Java 7+)

List<String> list = new ArrayList<>();  // 类型推断
// Java 7 之前需要
List<String> list = new ArrayList<String>();

集合字面量 (Java 9+ 的 List.of 等）

List<String> list = List.of("a", "b", "c");
Set<Integer> set = Set.of(1, 2, 3);
Map<String, Integer> map = Map.of("a", 1, "b", 2);

Lambda 表达式 (Java 8+)

// Lambda 表达式
Runnable r = () -> System.out.println("Hello");
// 实际生成实现 Runnable 的匿名类

try-with-resources (Java 7+)

try (InputStream is = new FileInputStream("file.txt")) {
    // 使用资源
}  // 自动调用 close()
// 编译为 try-finally 块

接口中的默认方法和静态方法 (Java 8+)

interface MyInterface {
    default void defaultMethod() {
        System.out.println("Default method");
    }

    static void staticMethod() {
        System.out.println("Static method");
    }
}

记录类 (Record, Java 14+)

record Point(int x, int y) {}
// 编译后自动生成：
// - 私有 final 字段 x 和 y
// - 公共构造方法
// - 访问器方法 x() 和 y()
// - equals(), hashCode(), toString()

instanceof 模式匹配

if (obj instanceof String s) {
    // 可以直接使用 s
    System.out.println(s.length());
}

文本块 (Text Blocks, Java 15+)

String html = """
    <html>
        <body>
            <p>Hello, world</p>
        </body>
    </html>
    """;

JDK 8 新特性

【中等】Optional 的正确使用方式？⭐⭐

Optional 是 Java 8 引入的容器对象，优雅处理可能为 null 的值。

核心方法：

方法	说明
of(T)	非 null 创建（null 抛 NPE）
ofNullable(T)	允许 null
isPresent() / isEmpty()	是否有值（Java 11+ isEmpty）
orElse(T)	无值返回默认
orElseGet(Supplier)	懒加载默认
orElseThrow()	无值抛异常
map / flatMap / filter	链式转换

正确用法：

String name = Optional.ofNullable(user)
    .map(User::getProfile)
    .map(Profile::getName)
    .orElse("unknown");

// 方法返回类型
public Optional<Address> findAddress(String userId) { ... }

反模式（应避免）：

// ❌ 字段类型（Optional 不可序列化）
private Optional<String> name;

// ❌ 方法参数
public void process(Optional<String> input) { ... }

// ❌ 直接 get
String s = optional.get();  // 可能 NPE

【中等】Lambda 表达式和函数式接口是什么？⭐⭐⭐

Lambda 表达式是 Java 8 引入的匿名函数，将行为作为参数传递，简化函数式编程。

// 传统匿名类
Collections.sort(list, new Comparator<String>() {
    public int compare(String a, String b) { return a.length() - b.length(); }
});

// Lambda 表达式
Collections.sort(list, (a, b) -> a.length() - b.length());
// 方法引用
list.sort(Comparator.comparingInt(String::length));

核心语法：(参数列表) -> { 方法体 }

形式	示例
无参	() -> System.out.println("hello")
单参（可省略括号）	s -> s.length()
多参	(a, b) -> a + b
方法引用	String::valueOf、System.out::println

函数式接口：只有一个抽象方法的接口，用 @FunctionalInterface 注解。Lambda 本质是函数式接口的实例。

函数式接口	方法	用途
Function<T,R>	R apply(T t)	输入 T 输出 R（转换）
Consumer<T>	void accept(T t)	消费 T（无返回）
Supplier<T>	T get()	生产 T（无输入）
Predicate<T>	boolean test(T t)	判断 T（返回布尔）
BiFunction<T,U,R>	R apply(T t, U u)	双输入单输出

记忆点：Lambda = “行为参数化”，函数式接口 = “只有一个抽象方法的接口”，两者配合实现简洁的函数式编程。

【困难】Stream API 的核心操作有哪些？⭐⭐⭐

Stream API（Java 8）提供对集合的声明式、链式、并行化数据处理能力。

核心流程：数据源 → 中间操作（链式） → 终端操作（触发执行）

List<String> names = users.stream()           // 数据源
    .filter(u -> u.getAge() > 18)              // 中间操作：过滤
    .sorted(Comparator.comparing(User::getName)) // 中间操作：排序
    .map(User::getName)                        // 中间操作：映射
    .distinct()                                // 中间操作：去重
    .limit(10)                                 // 中间操作：截断
    .collect(Collectors.toList());              // 终端操作：收集

中间操作 vs 终端操作：

类型	特点	常见操作
中间操作	返回 Stream，懒执行，链式调用	filter、map、flatMap、sorted、distinct、limit、skip、peek
终端操作	触发实际计算，返回结果或副作用	collect、forEach、reduce、count、findFirst、anyMatch、toList

reduce vs collect：

// reduce：元素归约为单个值
int sum = list.stream().reduce(0, Integer::sum);

// collect：元素收集到容器
Map<String, List<User>> groupByCity = users.stream()
    .collect(Collectors.groupingBy(User::getCity));

并行流：

long count = list.parallelStream()  // 利用多核 CPU 并行处理
    .filter(x -> x > 0)
    .count();

注意事项：

• 并行流不适用于小数据集（线程开销 > 计算收益）
• 避免在并行流中使用有副作用的操作
• findFirst 在并行流中代价高（需全局同步），优先用 findAny

【中等】Java 8 接口的默认方法和静态方法是什么？⭐⭐

Java 8 允许接口定义默认方法（default）和静态方法，解决了接口演化问题。

public interface Logger {
    void log(String msg);  // 抽象方法

    // 默认方法：提供默认实现，实现类可选择重写
    default void info(String msg) {
        log("[INFO] " + msg);
    }

    // 静态方法：通过接口名直接调用
    static Logger of(String name) {
        return msg -> System.out.println(name + ": " + msg);
    }
}

默认方法的菱形冲突规则：

场景	规则
类方法 vs 接口默认方法	类优先：类的实例方法始终胜出
两个接口有同名默认方法	编译报错，必须在子接口/实现类中显式重写
子接口重写父接口默认方法	子接口的版本生效

// 菱形冲突解决
interface A { default void hello() { System.out.println("A"); } }
interface B extends A { default void hello() { System.out.println("B"); } }
class C implements A, B {
    // 必须显式指定
    public void hello() { B.super.hello(); }  // 选择 B 的实现
}

【中等】Java 8 的 java.time API 解决了什么问题？⭐⭐

java.time（JSR-310）解决了 java.util.Date/Calendar 的三大痛点：非线程安全、设计混乱、时区处理复杂。

类	用途	示例
LocalDate	日期（无时间、无时区）	LocalDate.of(2024, 1, 1)
LocalTime	时间（无日期、无时区）	LocalTime.of(14, 30)
LocalDateTime	日期 + 时间（无时区）	LocalDateTime.now()
ZonedDateTime	日期 + 时间 + 时区	ZonedDateTime.now(ZoneId.of("Asia/Shanghai"))
Instant	时间戳（UTC）	Instant.now()
Duration	时间间隔（时分秒）	Duration.between(t1, t2)
Period	日期间隔（年月日）	Period.between(d1, d2)

核心优势：

• 不可变且线程安全：所有类都是 final + immutable
• API 设计清晰：plus/minus/with 语义明确
• 时区支持完善：ZoneId + ZonedDateTime

// 计算两个日期之间的天数
long days = ChronoUnit.DAYS.between(startDate, endDate);

// 格式化
String formatted = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));

JDK 11 新特性

【中等】Java 11 的 var 局部变量类型推断怎么用？有什么限制？⭐⭐

**var（JDK 10 引入，JDK 11 扩展）**让编译器自动推断局部变量类型，减少冗余代码。

// JDK 8：冗长的类型声明
Map<String, List<String>> map = new HashMap<String, List<String>>();

// var：编译器自动推断
var map = new HashMap<String, List<String>>();  // 类型仍然是 Map<String, List<String>>

// JDK 11 扩展：Lambda 参数上使用 var（可加注解）
list.stream().filter((@NotNull var s) -> s.length() > 5);

使用限制：

场景	是否支持	示例
局部变量	✔️	var list = new ArrayList<String>();
for 循环	✔️	for (var item : collection)
try-with-resources	✔️	try (var reader = new BufferedReader(...))
方法参数	❌	void method(var x) — 不允许
返回值	❌	var method() — 不允许
字段	❌	private var name; — 不允许
无初始化	❌	var x; — 不允许，无法推断
赋 null	❌	var x = null; — 不允许，无法推断

最佳实践：仅在类型明显时（如构造器右侧）使用 var，避免降低代码可读性。

【中等】Java 11 的 HTTP Client API 有什么特点？⭐⭐

**java.net.http.HttpClient（JDK 11 正式版）**是 Java 原生异步 HTTP 客户端，替代老旧的 HttpURLConnection。

HttpClient client = HttpClient.newHttpClient();

// 同步请求
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.example.com/users"))
    .header("Content-Type", "application/json")
    .POST(HttpRequest.BodyPublishers.ofString("{\"name\":\"Tom\"}"))
    .build();

HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());

// 异步请求（返回 CompletableFuture）
client.sendAsync(request, HttpResponse.BodyHandlers.ofString())
    .thenApply(HttpResponse::body)
    .thenAccept(System.out::println);

核心特点：

特性	说明
同步 + 异步	send() 同步、sendAsync() 异步（返回 CompletableFuture）
HTTP/2	默认支持 HTTP/2（多路复用、头部压缩）
WebSocket	内置 WebSocket 客户端支持
BodyHandlers	灵活处理响应体：ofString、ofFile、ofByteArray、ofLines

【中等】Java 11 的字符串 API 有哪些增强？⭐

Java 11 为 String 类新增了多个实用方法：

方法	说明	示例
isBlank()	是否为空或纯空白字符	" ".isBlank() → true
strip()	去除首尾空白（支持 Unicode）	" hello ".strip() → "hello"
stripLeading()	去除前导空白
stripTrailing()	去除尾部空白
lines()	按行分割返回 Stream	"a\nb\nc".lines().count() → 3
repeat(int)	重复拼接	"ab".repeat(3) → "ababab"

strip() vs trim()：strip() 基于 Character.isWhitespace()，支持 Unicode 空白字符；trim() 仅处理 ASCII ≤ 32 的字符。

【中等】Java 11 对 GC 有哪些重要更新？⭐⭐

JDK 11 是 GC 领域的重要里程碑，引入了两个新一代垃圾收集器：

收集器	JDK 版本	核心特点
ZGC（实验）	JDK 11	亚毫秒停顿（<10ms），支持 TB 级堆，基于着色指针 + 读屏障
Shenandoah	JDK 12	低延迟（与 ZGC 竞争），基于转发指针，Red Hat 开发

其他 GC 变更：

• G1 成为默认 GC（JDK 9 起）
• CMS 被标记为废弃（JDK 9），JDK 14 正式移除
• Epsilon GC（JDK 11）：不做任何回收，仅用于性能测试基准

启用示例：

# JDK 11 启用 ZGC
java -XX:+UseZGC -Xmx4g YourApplication

# JDK 11 启用 Epsilon（不做 GC，堆满即 OOM）
java -XX:+UseEpsilonGC -Xmx256m YourApplication

JDK 17 新特性

【中等】JDK 17 的 Sealed Classes（密封类）是什么？⭐⭐⭐

**密封类（Sealed Classes，JDK 17 正式版）**通过 sealed + permits 显式声明允许的子类，精确控制继承层级。

// 密封类：明确指定允许的子类
public sealed class Shape permits Circle, Square, Triangle {}

// 子类必须是 final、sealed 或 non-sealed 之一
public final class Circle extends Shape { ... }       // 不再可继承
public final class Square extends Shape { ... }       // 不再可继承
public non-sealed class Triangle extends Shape { ... }  // 恢复开放继承

与 Pattern Matching 结合（领域建模利器）：

public double area(Shape shape) {
    return switch (shape) {  // 编译器检查所有子类，无需 default
        case Circle c -> Math.PI * c.r() * c.r();
        case Square s -> s.side() * s.side();
        case Triangle t -> 0.5 * t.base() * t.height();
    };
}

适用场景：领域建模（限定业务概念取值范围）、类型安全的代数数据类型（ADT）、API 设计（配合 switch 穷尽检查）。

【中等】JDK 17 的 Record（记录类）是什么？⭐⭐⭐

Record（JDK 16 正式版）是 Java 的不可变数据载体，自动生成样板代码，是 Lombok @Data 的官方替代品。

// 一行定义
public record Point(int x, int y) {}

// 等价的传统 Java 类需 60+ 行（构造器、getter、equals、hashCode、toString）

// 使用
Point p = new Point(3, 4);
System.out.println(p.x());          // 3（注意：无 get 前缀）
System.out.println(p);              // Point[x=3, y=4]

紧凑构造器：用于参数校验

public record Range(int start, int end) {
    public Range {  // 紧凑构造器
        if (start > end) throw new IllegalArgumentException("start > end");
    }
}

Record 的限制：

• 不能继承其他类（隐式继承 java.lang.Record）
• 字段不可变（final）
• 不能声明 native 方法

【中等】JDK 17 的文本块（Text Blocks）是什么？⭐⭐

**文本块（Text Blocks，JDK 15 正式版）**用 """ 定义多行字符串，解决传统字符串拼接的可读性问题。

// JDK 8：冗长的字符串拼接
String json = "{\n" +
    "  \"name\": \"Tom\",\n" +
    "  \"age\": 18\n" +
    "}";

// 文本块：清晰的多行格式
String json = """
    {
      "name": "Tom",
      "age": 18
    }
    """;

特性：

特性	说明
自动缩进	以公共缩进为基准，自动去除多余缩进
换行符	统一为 \n（跨平台一致）
转义字符	支持 \s（保留尾部空格）、\\（行尾不换行）
String.formatted()	JDK 15+ 支持 """...""".formatted(args)

// 格式化文本块
String sql = """
    SELECT *
    FROM users
    WHERE age > %d AND city = '%s'
    """.formatted(18, "北京");

【中等】JDK 17 的 instanceof 模式匹配是什么？⭐⭐

**instanceof 模式匹配（JDK 16 正式版）**将类型检查和变量绑定合二为一，消除显式强制转换。

// JDK 8：需要显式转换
if (obj instanceof String) {
    String s = (String) obj;
    System.out.println(s.length());
}

// JDK 17：模式匹配，直接绑定变量
if (obj instanceof String s) {
    System.out.println(s.length());  // 无需转换
}

// 支持在条件中组合
if (obj instanceof String s && s.length() > 5) {
    System.out.println(s.toUpperCase());
}

作用域规则：绑定变量的作用域仅限于模式匹配为 true 的分支。

if (!(obj instanceof String s)) {
    return;  // s 不可用
}
// s 在此处可用（因为只有匹配成功才能执行到这里）
System.out.println(s.length());

【中等】JDK 17 的 switch 表达式增强是什么？⭐⭐

**switch 表达式（JDK 14 正式版）**引入了 -> 箭头语法和 yield 返回值，使 switch 可作为表达式使用。

// JDK 8：传统 switch（需要 break，容易遗漏）
int days;
switch (month) {
    case JANUARY: case MARCH: case MAY: days = 31; break;
    case FEBRUARY: days = 28; break;
    default: days = 30;
}

// JDK 17：switch 表达式（箭头语法，无需 break）
int days = switch (month) {
    case JANUARY, MARCH, MAY -> 31;
    case FEBRUARY -> 28;
    default -> 30;
};

// 多行代码块用 yield 返回值
String result = switch (code) {
    case 200 -> "OK";
    case 404 -> "Not Found";
    default -> {
        String msg = "Unknown: " + code;
        yield msg;  // 代码块中用 yield 返回值
    }
};

核心优势：

特性	传统 switch	JDK 17 switch 表达式
返回值	不支持	可直接赋值给变量
case 穿透	需 break（易遗漏）	-> 自动不穿透
多值合并	每个 case 一行	case A, B, C ->
穷尽检查	无强制	表达式必须穷尽所有分支

JDK 21 新特性

【中等】JDK 21 的 switch 模式匹配有什么增强？⭐⭐⭐

**switch 模式匹配（JDK 21 正式版）**将 switch 从“值匹配”升级为“类型匹配 + 守卫条件 + null 处理”的强大模式匹配工具。

核心增强：

// 1. 类型模式 + 守卫条件
Object obj = getShape();
String result = switch (obj) {
    case Circle c when c.radius() > 10 -> "大圆";
    case Circle c                       -> "小圆";
    case Square s                       -> "正方形，边长=" + s.side();
    case null                           -> "null 值";  // 显式处理 null
    default                             -> "其他";
};

// 2. 与密封类结合——编译器穷尽检查
sealed interface Shape permits Circle, Square {}
record Circle(double radius) implements Shape {}
record Square(double side) implements Shape {}

double area(Shape shape) {
    return switch (shape) {  // 无需 default，编译器确保穷尽
        case Circle c -> Math.PI * c.radius() * c.radius();
        case Square s -> s.side() * s.side();
    };
}

与传统 switch 的区别：

特性	传统 switch	JDK 21 switch 模式匹配
匹配对象	仅值（int、String、enum）	任意类型 + 模式
null 处理	抛 NPE	case null 显式处理
守卫条件	不支持	when 子句添加额外条件
穷尽检查	仅 enum	密封类 + enum 均可

【中等】JDK 21 的记录模式（Record Patterns）是什么？⭐⭐

记录模式（Record Patterns，JDK 21 正式版）允许在 instanceof 和 switch 中解构 Record 的字段，实现模式组合。

record Point(int x, int y) {}
record Line(Point start, Point end) {}

// 1. instanceof 中解构
Object obj = new Point(3, 4);
if (obj instanceof Point(int x, int y)) {
    System.out.println("x=" + x + ", y=" + y);  // 直接访问解构字段
}

// 2. 嵌套解构
Object obj2 = new Line(new Point(0, 0), new Point(5, 5));
if (obj2 instanceof Line(Point(var x1, var y1), Point(var x2, var y2))) {
    double length = Math.sqrt(Math.pow(x2 - x1, 2) + Math.pow(y2 - y1, 2));
}

// 3. switch 中解构
String describe(Object obj) {
    return switch (obj) {
        case Point(int x, int y) when x == 0 && y == 0 -> "原点";
        case Point(int x, int y)                        -> "点(" + x + "," + y + ")";
        case Line(Point s, Point e)                     -> "线段";
        default                                          -> "未知";
    };
}

核心价值：实现了代数数据类型的完整模式匹配，使 Java 具备了类似 Scala/Kotlin 的解构能力。

【中等】JDK 21 的未命名变量（Unnamed Variables）是什么？⭐⭐

**未命名变量（Unnamed Variables，JDK 21 预览）**用 _ 表示“声明但不使用”的变量，提升代码可读性。

// 1. 忽略不需要的变量
var _ = someExpensiveComputation();  // 只关心副作用，不用返回值

// 2. try-with-resources 中忽略资源
try (var _ = acquireLock()) {
    // 只关心锁的作用域，不使用锁对象
    doWork();
}

// 3. for 循环中忽略循环变量
for (var _ : collection) {
    count++;  // 只关心元素个数
}

// 4. catch 中忽略异常
try {
    riskyOperation();
} catch (Exception _) {  // 不关心异常对象
    log("操作失败");
}

// 5. switch 中忽略模式变量
switch (shape) {
    case Circle _ -> "这是一个圆";  // 不需要访问圆的字段
    case Square _ -> "这是一个正方形";
}

核心价值：明确表示“这个变量是故意不用的”，避免 IDE 警告，提升代码意图表达。

【中等】JDK 21 的 Scoped Values 是什么？与 ThreadLocal 有什么区别？⭐⭐

Scoped Values（JDK 21 预览，JEP 446） 是比 ThreadLocal 更安全、更高效的线程上下文传递方案，专为虚拟线程设计。

维度	ThreadLocal	Scoped Values
可变性	可任意修改（set/remove）	不可变，作用域内只读
生命周期	线程生命周期，需手动清理	作用域结束自动失效，无泄漏风险
虚拟线程友好	百万虚拟线程时内存开销巨大	轻量级，专为虚拟线程优化
继承性	InheritableThreadLocal 有性能问题	支持结构化并发中的安全传递

// Scoped Values 用法
private static final ScopedValue<String> USER = ScopedValue.newInstance();

// 在作用域内绑定值
ScopedValue.where(USER, "admin").run(() -> {
    processRequest();  // 内部可读取 USER
});

// 在任意深度读取
void processRequest() {
    String user = USER.get();  // "admin"，无需参数传递
}

适用场景：HTTP 请求上下文、用户身份、分布式追踪 ID 等“请求级”上下文传递，替代 Spring 中常见的 ThreadLocal 方案。