Java / 知识点
Java 开发速查手册
手册条目
<类型> 结果 = switch (<值>) {
case <常量1>, <常量2> -> <表达式>;
default -> { yield <值>; }
};使用箭头分支、yield 和穷尽检查简化多分支逻辑。
使用 switch 表达式
当一个值需要映射为结果时,优先使用 switch 表达式。箭头分支避免意外贯穿,代码块分支用 yield 返回值;对枚举等有限类型,编译器还能检查是否覆盖所有分支。
基本语法
switch 表达式本身会产生值,因此通常直接赋给变量或从方法返回。单表达式分支使用 ->,需要多条语句时使用代码块,并以 yield 给出该分支的结果。
public class SwitchExpressionDemo {
enum Level {
LOW, MEDIUM, HIGH
}
static int score(Level level) {
return switch (level) {
case LOW -> 10;
case MEDIUM -> {
int base = 20;
// 代码块分支必须显式产出结果
yield base + 5;
}
case HIGH -> 50;
};
}
static String classify(int status) {
return switch (status) {
case 200, 201, 204 -> "success";
case 400, 404 -> "client-error";
default -> "other";
};
}
public static void main(String[] args) {
System.out.println("score=" + score(Level.MEDIUM));
System.out.println("status=" + classify(201));
}
}编译并运行:
javac --release 21 SwitchExpressionDemo.java
java SwitchExpressionDemo预期输出:
score=25
status=success读取结果时注意:MEDIUM 分支先执行局部计算,再由 yield 返回 25;状态码 201 与同一 case 中的多个标签匹配,返回 success。
高频用法
多个值返回同一结果时,用逗号合并标签,避免重复分支:
String type = switch (day) {
case SATURDAY, SUNDAY -> "weekend";
default -> "weekday";
};需要记录日志、校验或计算中间变量时,使用代码块分支:
int price = switch (level) {
case LOW -> 10;
case MEDIUM -> {
int discount = 2;
yield 20 - discount;
}
case HIGH -> 30;
};以上为片段示例,依赖已定义的 day、level 及对应枚举。生效行为是每个分支只产生一个结果,不会像传统冒号分支那样继续执行后续 case。
穷尽检查
switch 表达式必须覆盖所有可能输入。整数、字符串等开放集合通常需要 default;枚举覆盖全部常量后可以省略 default。省略后若未来新增枚举常量,相关代码会在重新编译时暴露缺失分支,比静默落入默认值更安全。
所有分支的结果还必须能推导为兼容类型。一个分支返回数字、另一个分支返回无关对象,可能导致类型过宽或直接编译失败,应统一返回类型。
风险与边界
箭头语法不会贯穿分支,不能依赖传统 case 的 fall-through 行为;若业务确实需要连续执行,应改用普通 if 或显式提取公共逻辑。
代码块分支中使用 break 不能为表达式返回值,必须使用 yield。选择器为 null 时通常会抛出 NullPointerException,生产代码应在进入 switch 前校验,或在明确支持的 Java 版本中显式处理 case null。
排障清单
- 报“switch expression does not cover all possible input values”:补齐枚举分支或增加
default。 - 报“no result expressions”:检查代码块分支是否在所有可达路径执行
yield或抛出异常。 - 编译器不识别
->或yield:确认实际使用的javac版本,并检查构建工具的source、target或release配置。 - 返回类型异常:逐个核对分支结果,避免混用不相关类型。
兼容性
switch 表达式在 Java 14 成为正式特性。生产项目建议使用与运行环境一致的 --release 编译;仅升级本地 JDK,而未同步 Maven、Gradle 或 CI 的编译级别,仍会构建失败。
<返回类型> <方法名>(<参数列表>) // 同名不同参数即重载
<返回类型> <方法名>(<类型>... <参数名>) // 可变参数,只能放在最后定义重载方法和可变参数并避免调用歧义。
方法重载与可变参数
方法重载用于同一操作接收不同参数类型或数量;可变参数用于参数个数不固定的调用。设计时要让编译器能唯一选择方法,避免 null、空参数和相近类型造成歧义。
基本语法
重载方法必须同名但参数列表不同,差异可以是参数个数、类型或顺序;仅修改返回类型不构成重载。可变参数写成 类型... 名称,在方法内部按数组使用,并且必须位于参数列表最后。
public class MethodOverloadDemo {
static String format(int value) {
return "int:" + value;
}
static String format(long value) {
return "long:" + value;
}
static String format(String prefix, int... values) {
int total = 0;
// 可变参数在方法内部就是 int[]
for (int value : values) {
total += value;
}
return prefix + total;
}
public static void main(String[] args) {
System.out.println(format(10));
System.out.println(format(10L));
System.out.println(format("sum=", 1, 2, 3));
int[] numbers = {4, 5};
System.out.println(format("sum=", numbers));
}
}编译并运行:
javac --release 21 MethodOverloadDemo.java
java MethodOverloadDemo预期输出:
int:10
long:10
sum=6
sum=910 精确匹配 int 重载,10L 匹配 long 重载;可变参数既可以接收多个独立实参,也可以直接接收同类型数组。
选择规则
重载在编译期根据实参的静态类型决定,不会根据对象运行时类型重新选择。通常优先级是:固定参数精确匹配或基本类型拓宽,其次装箱、拆箱,最后才尝试可变参数。
因此已有固定参数方法时,不要假设可变参数版本会被调用。下面的调用会优先选择固定参数重载:
static void send(String value) {}
static void send(String... values) {}
send("ok");这是片段示例,生效行为是调用 send(String);只有参数数量无法匹配固定版本时,才会考虑 send(String...)。
高频用法
可变参数适合日志字段、批量 ID、求和等“零个或多个同类型值”的入口。调用者不传该参数时,方法收到长度为 0 的数组,而不是自动收到一个元素。
固定前缀参数可以放在可变参数之前,例如 log(String level, Object... args)。一个方法只能声明一个可变参数,且不能在其后继续声明其他参数。
重载应表达同一语义。如果两个方法只是业务含义不同,即使参数类型恰好不同,也应使用不同名称,避免调用者通过猜类型理解行为。
歧义与安全替代
下面的设计会让无参数调用无法唯一匹配:
static void show(String... values) {}
static void show(Integer... values) {}
show(); // 编译失败:两个可变参数重载都适用预期结果:
编译失败,错误信息包含:reference to show is ambiguous触发条件是多个可变参数重载都能接收相同实参;后果是调用方无法编译。安全替代方案是改成不同方法名,或保留一个可变参数入口并在方法内部显式区分数据。
直接传入 null 还可能被解释为“整个数组为 null”,方法内遍历时触发 NullPointerException。需要表示单个空元素时应显式转换,例如 (String) null;需要空集合时传 new String[0],不要裸传 null。
排障清单
- 报“method is already defined”:检查是否只改了返回类型,参数列表实际上没有变化。
- 报“reference is ambiguous”:检查
null、空参数、装箱类型和多个可变参数重载,必要时显式强制类型或调整 API。 - 调用了非预期重载:查看变量声明类型,而不是只看运行时对象类型。
- 可变参数遍历空指针:确认调用方是否把
null当作整个数组传入。 - 修改重载后旧调用编译失败:新增方法可能改变最优匹配,应重新编译并覆盖关键调用测试。
兼容性
方法重载自 Java 早期版本即支持;可变参数自 Java 5 支持。泛型可变参数可能产生堆污染警告,只有在方法不会写入不安全元素、也不会泄露底层数组时,才考虑使用 @SafeVarargs。
理解 Java 值传递以及对象引用作为参数时的行为。
理解参数传递
方法修改对象后结果是否会传回调用方,先看它修改的是对象字段,还是把参数指向另一个对象。Java 始终按值传递;基本类型复制数值,引用类型复制引用值。
判断修改落点
调用 change(number, box) 时,方法获得两个独立的局部变量。修改局部整数不会改变调用方整数;两个引用仍可访问同一个可变对象,所以修改该对象的字段能被调用方观察到。参数重新赋值后,调用方引用仍指向原对象。

完整示例
保存为 PassValue.java。示例先修改共享对象,再重新赋值参数,区分两种操作造成的结果。
public class PassValue {
static class Box {
int value;
Box(int value) { this.value = value; }
}
static void change(int n, Box b) {
n = 9; // 只改方法自己的整数副本
b.value = 8; // 两个引用仍指向同一个对象
b = new Box(99); // 只替换方法自己的引用副本
}
public static void main(String[] args) {
int number = 1;
Box box = new Box(2);
change(number, box);
System.out.println(number + "," + box.value);
}
}预期结果:运行后输出 1,8,不会输出 9,99。在 JDK 21 中执行:
javac PassValue.java
java PassValue预期输出:
1,8返回新值的做法
如果方法的职责是替换对象,让它返回新对象,再由调用方显式接收,例如把接口设计为 Box replace(Box old),调用位置写 box = replace(box)。如果只需更新字段,则直接修改对象,但要把这种副作用写入方法约定。
数组和集合也遵守相同规则:修改数组元素、调用集合的 add 会影响共享对象;把形参改成新数组或新集合不会替换调用方变量。不可修改集合可能直接抛出 UnsupportedOperationException,不能只凭引用类型就判断可修改。
常见误用
String 不可变,拼接产生新值,形参上的重新赋值不会修改调用方字符串。给引用加 final 只禁止该变量再次赋值,不会冻结所指对象。需要隔离修改时应按对象结构做防御性复制;只复制外层集合,内部可变元素仍可能共享。排错时分别打印调用前后字段和值,不用内存地址或 hashCode 作为对象复制的证明。
定义类、字段、构造器并完成对象初始化。
类与构造器
需要把一组字段和约束一起初始化时,使用类与构造器。构造器负责让新对象在创建完成时满足约束,避免对象先产生、调用方再补填必需字段。
基本语法与约束
构造器与类同名,没有返回类型;写上 void 就变成普通方法。使用 new 创建实例时调用构造器。声明任意构造器后,编译器不会再替你生成无参构造器,因此不能假定 new Account() 总能编译。
this.field 表示当前对象的字段;this(...) 调用同类其他构造器。在本示例采用的 Java 21 语法中,this(...) 或 super(...) 必须是构造器第一条语句,二者不能同时直接调用。重载构造器要把校验汇聚到一个入口。
完整初始化示例
保存为 AccountDemo.java。账户持有非空编号与非负余额,构造失败时不会向调用方返回一个半初始化账户。
import java.util.Objects;
public class AccountDemo {
static final class Account {
private final String id;
private final int balance;
Account(String id) { this(id, 0); }
Account(String id, int balance) {
// 统一入口执行校验,避免重载构造器遗漏约束
this.id = Objects.requireNonNull(id, "id");
if (id.isBlank() || balance < 0) {
throw new IllegalArgumentException("invalid account");
}
this.balance = balance;
}
String label() { return id + ":" + balance; }
}
public static void main(String[] args) {
System.out.println(new Account("A").label());
try {
new Account("B", -1); // 负例验证构造约束确实生效
} catch (IllegalArgumentException ex) {
System.out.println(ex.getMessage());
}
}
}预期结果:默认余额为 0,负余额被拒绝。运行命令:
javac AccountDemo.java
java AccountDemo预期输出:
A:0
invalid account字段与访问边界
private 限制外部直接改字段,final 使字段在初始化后不能再次赋值。示例的字段是字符串和整数;若字段换成 List,final 不会让列表不可变,应按业务需求复制列表或提供只读视图,并考虑内部元素是否可变。
构造器可使用 public、包可见或 private 控制创建位置。调用方没有权限访问构造器时,会在编译阶段报错;不要为了绕过错误就全部改成公开,先确认是否应通过工厂创建。
初始化失败的处理
构造器不应启动后台线程或把 this 注册到全局监听器,避免其他代码看到尚未初始化的状态。网络连接、线程启动等可失败资源操作更适合显式创建和关闭的生命周期。修改初始化逻辑后,至少验证正常输入、空编号和负余额;不要用事后 setter 修复一个本应在创建时被拒绝的对象。
public | protected | (默认,包内可见) | private
private <类型> <字段>; public <类型> get<字段>() { ... }选择 public、protected、默认访问级别和 private。
Java 访问控制
访问控制决定类、构造器、字段和方法能被哪些代码访问。选择原则是先用最小权限:仅类内部使用选 private,同包协作使用默认访问级别,需要对子类开放选 protected,稳定的外部 API 才使用 public。
可见范围
| 修饰符 | 当前类 | 同一包 | 不同包子类 | 其他代码 |
|---|---|---|---|---|
public |
是 | 是 | 是 | 是 |
protected |
是 | 是 | 是 | 否 |
| 默认访问级别 | 是 | 是 | 否 | 否 |
private |
是 | 否 | 否 | 否 |
默认访问级别没有关键字,直接省略修饰符。顶级类只能使用 public 或默认访问级别;成员内部类才可以使用四种修饰符。
主示例
下面代码放入 AccessDemo.java,演示同包内的访问结果。被注释的语句取消注释后会编译失败。
class Parent {
public int publicValue = 1;
protected int protectedValue = 2;
int packageValue = 3; // 未写修饰符:仅同包可见
private int privateValue = 4;
public int readPrivateValue() {
return privateValue; // 私有状态通过受控方法暴露
}
}
class Child extends Parent {
void printValues() {
System.out.println(publicValue);
System.out.println(protectedValue);
System.out.println(packageValue);
// System.out.println(privateValue); // 编译失败:private 仅 Parent 内可见
}
}
public class AccessDemo {
public static void main(String[] args) {
Child child = new Child();
child.printValues();
System.out.println(child.readPrivateValue());
}
}预期输出
1
2
3
4读取方法:前三行分别来自 public、protected 和默认访问成员;最后一行通过 public 方法间接读取 private 字段。
选择方式
对外控制器、服务接口或公共 DTO 的必要成员使用 public。实体状态通常设为 private,通过方法校验后再修改。只供同一包中的实现类协作时,优先默认访问级别,避免扩大 API 面。
protected 适合明确设计为继承扩展点的方法,不适合当作“比 public 小一点”的通用权限。不同包子类访问 protected 成员时,通常应通过当前子类实例或其子类实例访问,不能任意借助一个父类对象访问。
风险与边界
把字段直接设为 public 会让调用方绕过校验,后续改结构也更容易破坏兼容性;更安全的做法是保持字段 private,只公开必要操作。把构造器设为 private 会阻止外部实例化,适用于工厂方法或单例,但误用会导致框架无法创建对象,应确认序列化、ORM 或依赖注入框架是否要求可访问构造器。
排查“无法访问”编译错误时,依次确认成员修饰符、调用代码所在包、是否真正存在继承关系,以及访问表达式的对象类型。不要为快速通过编译直接改成 public,先判断调用是否越过了原本的模块边界。
static <类型> <类变量>;
static final <类型> <常量名> = <值>;
final <类型> <变量> = <值>;定义类成员、常量和不可继承或不可重写的结构。
Java static 与 final
static 表示成员属于类本身,所有实例共享;final 表示赋值、继承或重写受到限制。常量通常写成 public static final,实例固定属性使用 final 字段,禁止继承或重写时分别修饰类或方法。
基本语法
class Example {
static int count; // 类变量,所有实例共享
static final int MAX_RETRY = 3; // 类常量
final String id; // 每个实例只能赋值一次
Example(String id) {
this.id = id; // final 字段可在构造器中完成初始化
}
static int currentCount() {
return count; // static 方法不能直接访问实例字段 id
}
final void validate() {
// 子类不能重写该方法
}
}
final class FixedPolicy {
// 该类不能被继承
}这是结构示例,生效行为可通过编译器验证:重复给 id 赋值、从 FixedPolicy 继承或重写 validate() 都会编译失败。
主示例
将下面代码保存为 StaticFinalDemo.java 后运行。
public class StaticFinalDemo {
private static int createdCount = 0;
private static final int MAX_RETRY = 3;
private final String id;
public StaticFinalDemo(String id) {
this.id = id;
createdCount++; // 每创建一个实例,更新共享计数
}
public String label() {
return id + "-retry-" + MAX_RETRY;
}
public static int getCreatedCount() {
return createdCount;
}
public static void main(String[] args) {
StaticFinalDemo first = new StaticFinalDemo("A");
StaticFinalDemo second = new StaticFinalDemo("B");
System.out.println(first.label());
System.out.println(second.label());
System.out.println(StaticFinalDemo.getCreatedCount());
}
}预期输出
A-retry-3
B-retry-3
2读取方法:两个对象各自保存不同的 final id,但共同使用同一个 static createdCount 和同一个 static final MAX_RETRY。
高频用法
工具方法没有实例状态时声明为 static,调用时使用 ClassName.method(),避免为调用方法创建无意义对象。不可变配置值声明为 static final,命名通常使用大写下划线。构造后必须固定的依赖或标识声明为 final 字段,并在声明处或每个构造器中完成赋值。
final 方法用于锁定关键校验或模板流程;final 类用于明确禁止扩展,例如不可变值对象或安全边界类。只有确实不允许继承时才使用,避免过早限制测试替身和扩展能力。
风险与边界
static 可变字段在多线程和多实例部署中容易形成共享状态问题:并发修改可能丢失更新,进程重启后数据也会清空。安全替代方案是优先使用局部变量、不可变对象、并发容器,或把持久状态交给数据库与 Redis。
final 只保证引用不能重新指向其他对象,不保证对象内容不可变。例如 final List<String> 仍可执行 add。需要真正不可变时,使用不可变类型、List.copyOf() 或防御性复制。
出现“non-static variable cannot be referenced from a static context”时,说明静态代码直接访问了实例成员。应传入实例、把逻辑移到实例方法,或确认该状态是否真的应该改成静态成员;不要仅为消除报错就盲目添加 static。
record 类型名(类型 组件名, 类型 组件名) {
// 可添加校验、静态成员和实例方法
}使用 record 快速声明不可变数据载体和值对象。
定义 record
record 适合声明只承载数据的值对象,例如请求参数、查询结果和领域值。编译器会根据组件列表生成私有 final 字段、访问器、构造器、equals、hashCode 和 toString,减少样板代码。
基本语法
record 类型名(类型 组件名, 类型 组件名) {
// 可添加校验、静态成员和实例方法
}组件访问器与字段同名,不使用 JavaBean 的 getXxx() 形式。record 本身隐式为 final,不能继承其他类,但可以实现接口。
高频用法
下面使用紧凑构造器校验金额,并规范化币种。参数调整完成后,编译器会自动把参数赋给同名组件字段。
import java.util.Locale;
import java.util.Objects;
record Money(long cents, String currency) {
public Money {
if (cents < 0) {
throw new IllegalArgumentException("cents must be >= 0");
}
currency = Objects.requireNonNull(currency, "currency")
.toUpperCase(Locale.ROOT);
}
public String display() {
long major = cents / 100;
long minor = cents % 100;
return major + "." + (minor < 10 ? "0" : "") + minor + " " + currency;
}
}
public class RecordDemo {
public static void main(String[] args) {
Money first = new Money(1299, "usd");
Money second = new Money(1299, "USD");
System.out.println(first.display());
System.out.println(first.equals(second));
System.out.println(first);
}
}预期输出:
12.99 USD
true
Money[cents=1299, currency=USD]读取时重点确认:equals 按全部组件比较;toString 默认输出类型名和组件值;访问组件使用 first.cents()、first.currency()。
风险与边界
record 只保证组件引用不能重新赋值,不保证引用对象内部不可变。组件是 List、数组或可变 DTO 时,外部仍可能修改其内容,导致值对象状态变化。安全做法是在构造器中使用 List.copyOf(),数组使用 clone(),返回时也避免暴露可变引用。
不要把组件名称随意改动后直接发布为兼容升级。名称会影响访问器、toString、反射结果以及部分 JSON 序列化字段。对外接口需要稳定字段时,先确认序列化配置和消费者兼容性。
排障清单
- 编译出现“records are not supported”,检查
java -version、javac -version与构建工具的--release是否一致。 - 框架绑定失败时,确认框架版本支持 record 构造器绑定,并检查 JSON 字段名是否与组件名一致。
- 需要无参构造器、可变属性或继承基类时,不要强行使用 record,改用普通类。
兼容性
record 在 Java 16 成为正式特性;Java 14、15 仅以预览特性提供。生产项目建议使用 Java 17 或更高长期支持版本,并在 Maven、Gradle、IDE 和运行环境中统一目标版本。
enum 类型名 { 枚举项1, 枚举项2 }
类型名.valueOf("<名称>") / 类型名.values()使用枚举表示有限状态并为枚举项添加字段和方法。
定义枚举
enum 用于表示取值集合固定的状态、类型或策略。枚举项是类型安全的单例对象,可以携带稳定编码、展示名称和业务判断方法,避免散落的字符串或数字常量。
基本语法
enum 类型名 {
枚举项1,
枚举项2
}需要字段和方法时,在最后一个枚举项后写分号,再定义构造器、访问器和业务方法。枚举构造器不能公开,由 JVM 在创建枚举项时调用。
高频用法
下面为订单状态增加持久化编码、展示名称和状态迁移判断,并提供按编码解析的方法。
import java.util.Arrays;
enum OrderStatus {
CREATED("C", "待支付"),
PAID("P", "已支付"),
CLOSED("X", "已关闭");
private final String code;
private final String label;
OrderStatus(String code, String label) {
this.code = code;
this.label = label;
}
public String code() {
return code;
}
public String label() {
return label;
}
public boolean canTransitionTo(OrderStatus target) {
return this == CREATED && (target == PAID || target == CLOSED);
}
public static OrderStatus fromCode(String code) {
return Arrays.stream(values())
.filter(status -> status.code.equals(code))
.findFirst()
.orElseThrow(() -> new IllegalArgumentException("unknown code: " + code));
}
}
public class EnumDemo {
public static void main(String[] args) {
OrderStatus current = OrderStatus.CREATED;
System.out.println(current.label());
System.out.println(current.canTransitionTo(OrderStatus.PAID));
System.out.println(OrderStatus.fromCode("P"));
}
}预期输出:
待支付
true
PAID枚举比较直接使用 ==,不需要 equals();遍历全部枚举项使用 OrderStatus.values();按名称解析可使用 OrderStatus.valueOf("PAID")。
风险与边界
数据库、消息和外部接口不要保存 ordinal()。枚举顺序变化会导致原有数字映射到错误状态,可能造成订单状态误判。安全做法是定义不会随排序变化的 code,持久化和传输都使用该编码。
valueOf() 只接受与枚举项完全一致且区分大小写的名称,非法输入会抛出 IllegalArgumentException。外部输入优先通过 fromCode() 统一校验,并在接口层转换为明确错误响应。
新增枚举项后,已有 switch、权限规则、前端映射和数据库约束可能没有覆盖新值。上线前应检查所有分支;对关键状态机,不要用 default 静默吞掉未知状态。
排障清单
- 解析失败时,先打印原始值,检查大小写、空格以及使用的是名称还是业务编码。
- JSON 返回值不符合预期时,确认序列化的是枚举名称、字段还是自定义编码。
- 状态迁移异常时,把允许迁移规则集中在枚举或状态机中,避免多个服务各自维护不同判断。
- 枚举项很多且需要频繁按编码查询时,使用静态
Map<String, OrderStatus>建立索引,避免每次遍历。
兼容性
枚举自 Java 5 起可用。枚举字段、方法和接口实现均为稳定语法;涉及 JSON、ORM 或配置绑定时,兼容性主要取决于所用框架的映射规则,而不是 Java 语言版本。
class <子类> extends <父类> {
@Override
<返回类型> <方法名>(<参数>) { ... super.<方法名>(...); }
}继承父类、调用 super 并正确重写实例方法。
继承与方法重写
用于让子类复用父类实现,并在保持相同方法契约的前提下替换实例行为。生产代码中优先配合 @Override,让编译器及时发现方法名或参数写错。
基本语法
子类通过 extends 继承一个父类。super(...) 调用父类构造器,必须位于子类构造器第一行;super.method() 用于在重写方法中复用父类逻辑。
public class InheritanceDemo {
static class Payment {
private final String orderNo;
Payment(String orderNo) {
this.orderNo = orderNo;
}
String summary() {
return "order=" + orderNo;
}
void execute() {
System.out.println("execute generic payment");
}
}
static class CardPayment extends Payment {
CardPayment(String orderNo) {
super(orderNo); // 父类没有无参构造器,必须显式传参
}
@Override
void execute() {
System.out.println(super.summary());
System.out.println("execute card payment");
}
}
public static void main(String[] args) {
Payment payment = new CardPayment("P20260802001");
payment.execute(); // 运行时按实际对象类型调用重写方法
}
}预期输出
order=P20260802001
execute card payment变量声明类型是 Payment,实际对象是 CardPayment,因此调用的是子类重写后的 execute();其中 super.summary() 仍执行父类实现。
重写规则
- 方法名和参数列表必须一致,返回类型可使用协变返回类型。
- 子类访问权限不能比父类更严格,例如父类是
protected,子类可改为public,不能改为默认或private。 final方法不能重写,private方法对子类不可见,构造器不会被继承。static方法属于类,只会发生方法隐藏,不参与运行时多态。- 子类抛出的受检异常不能比父类声明得更宽。
高频用法
在父类提供稳定流程、子类只替换局部行为时使用重写;需要保留父类公共逻辑时先调用 super.method(),再补充子类逻辑;通过父类类型接收不同子类对象,可统一调用并获得各自实现。
风险与边界
父类构造器调用可重写方法时,子类字段可能尚未初始化,可能得到空值或触发异常。安全做法是避免在构造阶段调用可重写方法,改为构造完成后显式初始化。
误把字段同名定义当成重写会产生字段隐藏,访问结果取决于引用的声明类型。共享数据应放在父类受控字段中,并通过方法访问。
继承层级过深会让行为来源难以定位。只有存在稳定的“是一个”关系时才继承;仅为复用代码时优先考虑组合。
排障清单
@Override编译失败:核对方法名、参数类型、泛型擦除和父类可见性。- 父类构造器报错:确认子类第一条语句是否调用了正确的
super(...)。 - 实际未进入子类方法:检查方法是否为
static、private,或参数列表是否意外形成重载。 - 出现递归调用:检查重写方法中是否错误调用了
this.method(),需要父类实现时使用super.method()。
速查:重写看实际对象类型,重载看编译期参数匹配;不确定是否真正重写时,始终加 @Override。
interface <接口名> { <返回类型> <方法>(); default <返回类型> <方法>() { ... } }
abstract class <类名> implements <接口名> { abstract <返回类型> <方法>(); }根据共享行为和共享状态选择接口或抽象类。
接口与抽象类
接口用于定义可由不同类型实现的能力,抽象类用于共享状态、构造过程和部分实现。常见做法是“抽象类承载公共骨架,接口暴露可组合能力”。
选择依据
| 需求 | 优先选择 |
|---|---|
| 多个无关类共享同一种能力 | 接口 |
| 需要统一字段、构造器或受保护方法 | 抽象类 |
| 一个类需要组合多种能力 | 多个接口 |
| 子类共享流程,但部分步骤必须自定义 | 抽象类的模板方法 |
Java 类只能直接继承一个类,但可以实现多个接口。接口不保存实例状态;接口字段隐式为 public static final,不适合承载每个对象各自变化的数据。
可运行示例
下面同时使用抽象类和接口:Employee 保存公共状态并提供骨架,Billable 定义可开票能力,具体类负责实现计算逻辑。
public class TypeChoiceDemo {
interface Billable {
String invoiceLine();
default boolean canInvoice() {
return true;
}
}
static abstract class Employee {
private final String name;
protected Employee(String name) {
this.name = name;
}
protected String name() {
return name;
}
abstract int monthlyCost();
String label() {
return name + ":" + monthlyCost();
}
}
static final class Developer extends Employee implements Billable {
private final int salary;
Developer(String name, int salary) {
super(name);
this.salary = salary;
}
@Override
int monthlyCost() {
return salary;
}
@Override
public String invoiceLine() {
return name() + " cost=" + monthlyCost();
}
}
public static void main(String[] args) {
Developer developer = new Developer("Alice", 20000);
System.out.println(developer.label());
System.out.println(developer.invoiceLine());
System.out.println(developer.canInvoice());
}
}预期输出
Alice:20000
Alice cost=20000
true抽象类不能直接实例化,但可以包含字段、构造器、普通方法和抽象方法。接口方法由实现类提供;default 方法可添加兼容性的默认行为。
高频用法
- 对外 API、插件扩展点和跨层能力优先使用接口,调用方只依赖契约。
- 多个近亲类共享校验、字段和固定流程时使用抽象类。
- 需要同时具备缓存、审计、序列化等能力时实现多个小接口,避免一个巨型接口。
- 框架骨架稳定、步骤可替换时,在抽象类中保留固定流程,把变化点声明为抽象方法。
风险与边界
抽象类会占用唯一的类继承位置,后续无法再继承其他基类。只需要行为契约时应改用接口,公共实现可放入组合对象或接口默认方法。
接口增加抽象方法会导致所有已有实现类编译失败。兼容性允许时可增加 default 方法,但默认实现必须语义安全,不能静默掩盖必需逻辑。
实现多个接口且出现同签名 default 方法时会产生编译冲突。实现类必须显式重写,并用 InterfaceName.super.method() 选择或组合默认实现。
排障清单
- 提示“类不是抽象的”:检查是否遗漏接口方法或抽象方法实现,尤其注意方法必须为
public才能实现接口方法。 - 构造失败:抽象类没有可匹配的构造器时,在子类构造器第一行补充
super(...)。 - 默认方法冲突:显式重写冲突方法,不要依赖声明顺序。
- 类型判断过多:调用方若频繁使用
instanceof区分实现,通常说明接口职责过宽或缺少多态方法。
速查:只约定“能做什么”选接口;还要统一“保存什么、怎样构造、哪些步骤复用”选抽象类。
<父类型> obj = new <子类型>();
if (obj instanceof <子类型> sub) { ... } // 模式匹配使用多态、instanceof 模式匹配和安全类型转换。
多态与类型判断
当同一段业务逻辑需要处理多个实现类时,用父类或接口接收对象,通过重写方法获得不同结果;只有确实需要访问子类专有能力时,再使用 instanceof 模式匹配完成安全转换。
基本语法
多态的关键是“父类型引用指向子类型对象”。调用可重写的实例方法时,JVM 按对象的实际类型选择实现,而不是按变量声明类型选择。
public class PolymorphismDemo {
interface Animal {
String speak();
}
static final class Dog implements Animal {
@Override
public String speak() {
return "汪";
}
void fetch() {
System.out.println("Dog 正在捡球");
}
}
static final class Cat implements Animal {
@Override
public String speak() {
return "喵";
}
}
static void inspect(Animal animal) {
System.out.println(animal.getClass().getSimpleName() + ": " + animal.speak());
// 模式匹配会同时完成类型检查和局部变量绑定,避免重复强转
if (animal instanceof Dog dog) {
dog.fetch();
} else {
System.out.println("不是 Dog,不做转换");
}
}
public static void main(String[] args) {
inspect(new Dog());
inspect(new Cat());
}
}预期输出
Dog: 汪
Dog 正在捡球
Cat: 喵
不是 Dog,不做转换读取时先看 speak():虽然参数声明为 Animal,实际执行的是 Dog 或 Cat 的重写方法。随后只有 Dog 分支能取得 dog 变量并调用 fetch()。
高频用法
方法参数、集合元素和返回值优先声明为接口或抽象父类,例如 List<Animal>,这样新增实现类时调用方通常不用修改。子类差异能够由重写方法表达时,直接调用多态方法,不要额外判断类型。
当差异无法放进公共接口,例如只对某个实现执行诊断、导出或设备能力调用时,使用 obj instanceof Type variable。对 null 执行 instanceof 会得到 false,不会抛出异常。
风险与边界
直接执行 (Dog) animal 的触发条件是对象实际类型不是 Dog;后果是运行时抛出 ClassCastException,当前请求可能中断。安全替代方案是先用模式匹配判断,或重新设计接口,让调用方不需要向下转换。
大量连续的 instanceof 通常表示公共抽象不足;后果是新增子类时需要修改多个分支,容易漏处理。优先把稳定行为下沉为重写方法;只有跨类型算法或外部协议适配时再保留集中判断。
静态方法、字段访问和私有方法不参与运行时多态。若发现“明明是子类对象却调用了父类逻辑”,先检查目标是否为可重写的实例方法,以及子类方法签名是否真正使用了 @Override。
排障清单
- 出现
ClassCastException:打印obj.getClass().getName(),核对真实类型,再删除无保护强转。 - 子类方法未执行:检查参数列表、返回类型和包名是否一致,并保留
@Override让编译器发现误写。 - 分支始终不进入:确认对象不是代理类、包装类或其他实现;必要时检查框架返回的实际类型。
- 分支越来越多:评估是否应增加接口方法、策略对象或访问者,而不是继续堆叠类型判断。
兼容性
instanceof Type variable 模式匹配从 Java 16 起正式可用,生产项目通常可直接在 Java 17/21 使用。Java 8~15 需先判断再显式转换:if (animal instanceof Dog) { Dog dog = (Dog) animal; }。
class Box<T> { ... }
<T extends Comparable<T>> T max(List<? extends T> items)
List<? super Integer> sink定义泛型类和方法并使用通配符控制类型边界。
使用泛型
当容器、工具方法或业务组件需要复用同一套逻辑,同时又要在编译期限制元素类型时使用泛型。T 用于表达确定且相关联的类型,通配符用于规定调用方可以读取或写入的边界。
基本语法
泛型类型把具体类型交给使用者指定;泛型方法在返回类型前声明 <T>。需要接收一组不同的数字子类型时使用 ? extends Number,需要向目标集合写入整数时使用 ? super Integer。
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class GenericsDemo {
static final class Box<T> {
private final T value;
Box(T value) {
this.value = value;
}
T get() {
return value;
}
}
static <T> T firstOrNull(List<T> values) {
return values.isEmpty() ? null : values.get(0);
}
static double sum(List<? extends Number> numbers) {
double total = 0;
for (Number number : numbers) {
total += number.doubleValue();
}
return total;
}
static void addDefaults(List<? super Integer> target) {
// 下界保证可以安全写入 Integer,但读取时只能按 Object 处理
target.add(10);
target.add(20);
}
public static void main(String[] args) {
Box<String> box = new Box<>("order-1001");
List<Integer> numbers = Arrays.asList(1, 2, 3);
List<Number> target = new ArrayList<>();
System.out.println(box.get());
System.out.println(firstOrNull(numbers));
System.out.println(sum(Arrays.asList(1, 2.5, 3)));
addDefaults(target);
System.out.println(target);
}
}预期输出
order-1001
1
6.5
[10, 20]Box<String> 保证 get() 返回 String。firstOrNull 的参数和返回值共享同一个 T,编译器会根据实参推断为 Integer。sum 只读取数字,addDefaults 只向目标写入整数。
类型边界速查
| 写法 | 适用场景 | 可安全执行 |
|---|---|---|
List<T> |
元素类型需要保持一致并在多个位置关联 | 按 T 读写 |
List<?> |
只关心它是某种列表 | 读取为 Object,通常不能写入 |
List<? extends Number> |
读取 Integer、Long、Double 等数字 |
读取为 Number,不能新增具体数字 |
List<? super Integer> |
把 Integer 写入 Integer、Number 或 Object 列表 |
可写入 Integer,读取为 Object |
可用“生产者用 extends,消费者用 super”快速判断;同一个参数既要稳定读取又要写入时,优先使用明确的 T,不要强行套通配符。
高频用法
定义仓储、响应体、缓存值等单一类型容器时使用 Class<T> 或 Container<T>。定义 map、convert、first 等输入输出类型相关的方法时使用泛型方法。API 只读取调用方集合时使用上界通配符,只向集合写入某类对象时使用下界通配符。
需要限制类型能力时可写 <T extends Comparable<T>> 或 <T extends Base & Interface>。类上界必须放在第一个位置,并且最多只能有一个类上界。
风险与边界
使用原始类型 List 的触发条件是省略类型参数;后果是编译器无法检查写入内容,错误常在读取转换时以 ClassCastException 暴露。安全替代方案是补齐具体类型,旧接口暂时无法修改时至少使用 List<?> 并消除未经检查的强转。
Java 泛型采用类型擦除,运行时通常无法判断 List<String> 与 List<Integer>,也不能直接创建 new T()、new T[10] 或判断 obj instanceof List<String>。需要创建实例时传入 Class<T>、Supplier<T> 或工厂;需要数组时优先改用 List<T>。
对可变参数泛型数组进行写入可能产生堆污染,后果是远离写入位置才出现类型转换异常。只有确认方法不会修改或泄露该数组时才使用 @SafeVarargs,不要用注解掩盖真实警告。
排障清单
- 出现
unchecked警告:定位原始类型、未经检查的转换或泛型可变参数,不要直接全局抑制。 extends集合无法add:它代表未知子类型,改为? super T、明确的List<T>,或把写入职责移出方法。- 返回值被推断成
Object:检查实参是否使用了原始类型,或在调用处显式提供类型参数。 - API 类型签名过长:为稳定业务概念定义命名泛型类,避免多层嵌套通配符降低可读性。
兼容性
示例语法可在 Java 8 及以上运行。Java 9 起可用 List.of 创建不可变列表,但其行为与 ArrayList 不同;需要新增、删除元素时仍应显式创建可变集合。
@Retention(RetentionPolicy.RUNTIME) @Target(ElementType.METHOD)
@interface <注解名> { String value() default ""; }
<元素>.getAnnotation(<注解名>.class)声明注解、配置保留策略并读取注解信息。
定义与读取注解
用于给类、方法等程序元素附加结构化标记,并在运行时通过反射读取参数。关键是把保留策略设为 RUNTIME;否则代码能编译,但运行时可能取不到注解。
基本语法
下面定义 @Audit,限制其只能标记类和方法,并读取类级、方法级配置。
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.lang.reflect.Method;
public class AnnotationDemo {
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD})
public @interface Audit {
String value();
int level() default 1;
}
@Audit(value = "order-service", level = 2)
static class OrderService {
@Audit("create-order")
public void create() {
}
}
public static void main(String[] args) throws Exception {
Class<OrderService> type = OrderService.class;
Audit typeAudit = type.getAnnotation(Audit.class);
Method method = type.getDeclaredMethod("create");
Audit methodAudit = method.getAnnotation(Audit.class);
System.out.printf("type=%s, level=%d%n",
typeAudit.value(), typeAudit.level());
System.out.printf("method=%s, level=%d%n",
methodAudit.value(), methodAudit.level());
}
}保存为 AnnotationDemo.java 后运行:
javac AnnotationDemo.java
java AnnotationDemo预期输出:
type=order-service, level=2
method=create-order, level=1第二行的 level=1 来自注解属性的默认值,说明未显式配置的属性会使用声明时的默认值。
保留策略与目标位置
| 配置 | 作用 | 读取结果 |
|---|---|---|
RetentionPolicy.SOURCE |
仅保留在源码 | 编译后不可通过反射读取 |
RetentionPolicy.CLASS |
写入 class 文件 | JVM 默认不向反射暴露 |
RetentionPolicy.RUNTIME |
保留到运行期 | 可用反射 API 读取 |
@Target |
限制可标记位置 | 用错位置时直接编译失败 |
常用目标包括 TYPE、METHOD、FIELD、PARAMETER 和 CONSTRUCTOR。需要支持多个位置时,在 @Target 中传入数组。
常用读取方式
isAnnotationPresent(Audit.class) 适合只判断是否存在;getAnnotation 读取可见注解;getDeclaredAnnotation 只检查当前元素直接声明的注解。读取方法、字段或构造器时,先通过 getDeclaredMethod、getDeclaredField 或 getDeclaredConstructor 定位目标,再调用对应的注解读取方法。
对可重复注解,应使用 getAnnotationsByType 或 getDeclaredAnnotationsByType,不要只调用 getAnnotation,否则无法完整取得同类型的多条配置。
风险与边界
当注解未配置 RUNTIME 时,反射读取会返回 null,随后直接调用属性会触发 NullPointerException。安全做法是先判空或调用 isAnnotationPresent,并在注解定义处明确保留策略。
@Inherited 只影响类上的注解继承,不会让方法注解、字段注解或接口注解自动出现在实现类上。需要处理接口、父类或代理对象时,应明确遍历实际目标类、接口和父类,而不是假设注解会自动传播。
注解适合表达相对稳定的元数据,不适合保存运行中频繁变化的开关。动态配置应放入配置中心、数据库或环境变量,避免为了改一个值重新编译和发布。
排障清单
- 读取结果为
null:检查是否使用RetentionPolicy.RUNTIME,以及读取的是否为真正声明注解的类或成员。 - 报
NoSuchMethodException:方法名和参数类型必须完全匹配,重载方法尤其要传入准确参数列表。 - 代理类上找不到注解:定位被代理的目标类,必要时同时检查接口方法与实现方法。
- 属性读取不符合预期:确认是否使用了默认值,以及是否误读了父类或接口上的同名注解。
Java 8 起支持 @Repeatable;Java 16 起可用 ElementType.RECORD_COMPONENT 标记记录组件。普通类、方法和字段注解在主流 JDK 中用法一致。
Class<?> type = Class.forName("<完整类名>");
Field field = type.getDeclaredField("<字段>"); field.setAccessible(true);
Method method = type.getMethod("<方法>", <参数类型>...); method.invoke(<对象>, <参数>...);动态读取类型、字段、构造器和方法并执行调用。
使用反射
用于在编译期不知道具体类型时,动态检查类、字段、构造器和方法,并完成实例化、读写或调用。排障时重点区分公开成员与当前类声明成员,并保留原始异常原因。
基本语法
下面动态加载内部类,读取字段,调用私有构造器创建对象,再修改私有字段并执行私有方法。
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class ReflectionDemo {
static class User {
private String name;
private User(String name) {
this.name = name;
}
private String greet(String prefix) {
return prefix + ", " + name;
}
}
public static void main(String[] args) throws Exception {
Class<?> type = Class.forName("ReflectionDemo$User");
System.out.println("type=" + type.getSimpleName());
for (Field field : type.getDeclaredFields()) {
System.out.printf("field=%s:%s%n",
field.getName(), field.getType().getSimpleName());
}
Constructor<?> constructor =
type.getDeclaredConstructor(String.class);
constructor.setAccessible(true);
Object user = constructor.newInstance("Alice");
Field nameField = type.getDeclaredField("name");
nameField.setAccessible(true);
nameField.set(user, "Bob");
Method greet =
type.getDeclaredMethod("greet", String.class);
greet.setAccessible(true);
Object result = greet.invoke(user, "Hello");
System.out.println("result=" + result);
}
}保存为 ReflectionDemo.java 后运行:
javac ReflectionDemo.java
java ReflectionDemo预期输出:
type=User
field=name:String
result=Hello, Bob内部类的二进制名称使用 $,所以 Class.forName 中写成 ReflectionDemo$User。实际包名存在时,还要加完整包路径。
常用 API
| 目标 | 常用方法 | 读取范围 |
|---|---|---|
| 类型 | Class.forName、对象.getClass()、类型.class |
获取 Class 对象 |
| 字段 | getField / getDeclaredField |
前者仅公开可见,后者只查当前类声明 |
| 构造器 | getConstructor / getDeclaredConstructor |
参数类型必须精确匹配 |
| 方法 | getMethod / getDeclaredMethod |
前者包含继承的公开方法 |
| 调用 | newInstance、Field.get/set、Method.invoke |
可能抛出访问、参数或目标异常 |
处理继承层次中的私有字段时,要从当前类开始逐级调用 getSuperclass(),并在每一级使用 getDeclaredField 或 getDeclaredFields;单次调用不会自动搜索父类私有成员。
高频用法
- 根据配置中的类名加载实现类,并通过约定构造器创建实例。
- 在框架、序列化或测试工具中扫描字段、方法和注解,建立映射关系。
- 排查运行对象的真实类型、成员签名和注解位置,确认代理、继承或重载是否导致定位偏差。
反复调用同一个成员时,可缓存 Method、Field 或 Constructor,避免重复查找。使用可卸载的自定义类加载器时,缓存要随类加载器释放,否则可能阻止类卸载。
风险与边界
setAccessible(true) 会绕过普通 Java 访问检查,使代码依赖类的私有实现。字段改名、方法签名调整或 JDK 模块边界收紧后,运行时可能直接失败。优先使用公开构造器、公开方法、标准 SPI 或 MethodHandles;--add-opens 只适合作为受控迁移方案,不应长期无范围开放模块。
反射调用不会提供完整的编译期类型检查。参数数量、引用类型、基本类型装箱或接收对象不匹配时,会触发 IllegalArgumentException。调用前应核对 getParameterTypes(),并对外部输入做类型转换与校验。
Method.invoke 中目标方法抛出的异常会被包装成 InvocationTargetException。排障时应读取 getCause(),否则日志只会看到反射包装异常,遗漏真正的业务错误。
排障清单
ClassNotFoundException:确认全限定类名、运行时 classpath、依赖范围和类加载器是否正确。NoSuchFieldException或NoSuchMethodException:检查是否误用getField/getMethod,并核对名称、大小写和完整参数类型。IllegalAccessException:优先改用公开 API;确需访问非公开成员时,再评估setAccessible和模块开放范围。InaccessibleObjectException:常见于 Java 9 之后访问未开放的 JDK 模块,避免反射 JDK 内部实现,或由模块声明精确开放目标包。InvocationTargetException:记录并处理getCause(),真正异常来自被调用方法。IllegalArgumentException:检查调用对象是否属于声明类,以及实参数量、顺序和类型是否一致。
Java 9 引入模块系统后,跨模块深度反射受到限制;较新的 JDK 对 JDK 内部包封装更严格。Java 16 起可通过 Class.isRecord() 和 getRecordComponents() 检查记录类型。
try { ... } catch (<异常类型> e) { ... } finally { ... }
throw new <异常类型>("<消息>");
<返回类型> <方法>() throws <受检异常> { ... }使用 try、catch、finally、throw 和 throws 处理异常。
捕获与抛出异常
用于在异常发生时终止当前失败路径、保留错误信息,并在调用边界决定恢复、转换或继续抛出。try 包围可能失败的代码,catch 处理匹配异常,finally 执行必须收尾的逻辑,throw 主动创建异常,throws 声明方法可能向上抛出的异常。
基本语法
try {
// 可能抛出异常的代码
} catch (IllegalArgumentException e) {
// 处理当前能够恢复或转换的异常
} finally {
// 无论成功或失败都执行
}catch 按从上到下匹配,子类异常必须写在父类前面,否则后面的分支不可达。throws 只是把处理责任交给调用方,不会自动记录日志或恢复执行。
可运行示例
下面的程序同时演示正常返回、主动 throw、方法 throws、调用方 catch 和 finally 收尾。
public class ExceptionDemo {
static int divide(int dividend, int divisor) throws ArithmeticException {
if (divisor == 0) {
// 在参数不满足方法契约时立即终止当前路径
throw new ArithmeticException("divisor must not be 0");
}
return dividend / divisor;
}
public static void main(String[] args) {
try {
System.out.println("result=" + divide(10, 2));
System.out.println(divide(10, 0));
} catch (ArithmeticException e) {
// 当前边界能够给出明确处理结果,因此在这里捕获
System.out.println("caught: " + e.getMessage());
} finally {
System.out.println("cleanup");
}
}
}预期输出
result=5
caught: divisor must not be 0
cleanup第二次调用抛出异常后,try 中后续语句不再执行,控制流直接进入匹配的 catch,最后执行 finally。
高频用法
业务参数非法时,优先在最早发现问题的位置 throw,避免错误数据继续向下传播。调用外部文件、网络或数据库 API 时,只捕获当前层真正能处理的异常;无法恢复时补充上下文并保留原始 cause 后继续抛出。
多个异常处理逻辑相同时,可使用 catch (IOException | SQLException e),但联合捕获中的异常变量不能重新赋值。资源关闭优先使用 try-with-resources,而不是手写 finally,因为它能正确处理关闭阶段产生的附加异常。
风险与边界
不要使用 catch (Exception e) {} 吞掉异常。触发后程序会表现为“继续运行但结果错误”,排障时又没有堆栈;安全做法是处理、转换或记录后重新抛出。
不要在 finally 中 return、throw 或覆盖原变量。该写法会掩盖 try 或 catch 中原本的返回值和异常;收尾逻辑应保持简单,资源释放失败也应保留原始异常信息。
生产日志避免在每一层重复打印同一异常,否则一次故障会产生多份相同堆栈。通常在最终处理边界记录一次,并附带请求号、关键业务标识和必要参数,禁止输出密码、令牌等敏感值。
排障清单
先查看异常类型、消息和最底层 Caused by,再定位第一处业务代码栈帧。若 catch 未进入,检查实际异常类型是否匹配;若 finally 未达到预期,检查进程是否被强制终止,或收尾代码自身是否再次抛出异常。
class <名称>Exception extends RuntimeException {
<名称>Exception(String message, Throwable cause) { super(message, cause); }
}定义业务异常并选择受检异常或非受检异常。
自定义异常
用于把业务失败转换成稳定、可识别的异常类型,使调用方能够按错误码处理,而不是依赖易变化的错误文本。自定义异常应表达一个明确失败语义,并保留原始 cause、业务错误码和必要上下文。
类型选择
| 类型 | 定义方式 | 适用情况 |
|---|---|---|
| 受检异常 | extends Exception |
调用方通常能够恢复,并且希望编译器强制处理,例如特定文件导入失败 |
| 非受检异常 | extends RuntimeException |
参数非法、状态冲突、业务规则不满足,通常由统一异常处理器转换为响应 |
不要仅因为“这是业务异常”就全部定义为受检异常。若每一层只能机械地声明 throws,受检异常会扩大方法签名,却没有增加恢复能力。
可运行示例
下面定义一个带稳定错误码的非受检业务异常,并在服务边界捕获。金额使用整数表示最小货币单位,避免浮点误差。
public class CustomExceptionDemo {
static final class BizException extends RuntimeException {
private final String code;
BizException(String code, String message) {
super(message);
this.code = code;
}
BizException(String code, String message, Throwable cause) {
// 包装底层异常时必须保留 cause,便于查看完整调用链
super(message, cause);
this.code = code;
}
String getCode() {
return code;
}
}
static long withdraw(long balance, long amount) {
if (amount <= 0) {
throw new IllegalArgumentException("amount must be positive");
}
if (amount > balance) {
throw new BizException(
"BALANCE_NOT_ENOUGH",
"balance=" + balance + ", requested=" + amount
);
}
return balance - amount;
}
public static void main(String[] args) {
try {
System.out.println("remaining=" + withdraw(100, 130));
} catch (BizException e) {
System.out.println(e.getCode() + ": " + e.getMessage());
}
}
}预期输出
BALANCE_NOT_ENOUGH: balance=100, requested=130调用方可以依赖 BALANCE_NOT_ENOUGH 做响应映射、国际化或监控聚合,而不需要解析 message。实际项目中错误码应集中定义,避免不同模块重复使用同一字符串表达不同含义。
设计要点
异常类保持不可变,字段使用 final,只存排障和响应映射真正需要的数据。消息应描述失败事实,不写“系统异常”这类无定位价值的文本。
包装底层异常时使用带 Throwable cause 的构造器,例如数据库唯一键冲突可转换为“订单已存在”,同时保留原异常。不要把异常对象当普通分支结果频繁创建;可预期且高频的状态查询更适合返回明确结果类型。
风险与边界
自定义异常层级过深会导致调用方难以判断应该捕获哪一类。触发条件是每个小场景都新建父子类,后果是统一处理器和监控规则不断膨胀;安全做法是保留少量稳定基类,通过错误码区分业务语义。
异常消息若拼接手机号、卡号、令牌或完整请求体,进入日志后会造成敏感信息泄露。只记录必要标识,敏感字段应脱敏,详细上下文放在受控审计系统中。
不要在业务方法内部捕获自定义异常后原样重新抛出并重复记录日志。若没有新增上下文,直接让异常向上传播;若需要转换,必须保留 cause,并在最终处理边界只记录一次完整堆栈。
排障清单
统一异常处理器未命中时,检查异常是否被其他 catch 提前转换、代理层是否包装成其他类型,以及类是否来自不同模块版本。错误码为空时,检查所有构造器是否都完成赋值;堆栈缺少根因时,检查包装异常时是否遗漏 cause。
try (<资源类型> r1 = new <资源类型>(...); <资源类型> r2 = ...) { ... } // 资源需实现 AutoCloseable使用 try-with-resources 安全关闭流、连接和其他资源。
自动关闭资源
try-with-resources 用于管理实现 AutoCloseable 的流、Socket、JDBC 连接等资源。无论代码正常结束、提前返回还是抛出异常,Java 都会自动调用 close(),避免连接泄漏和文件句柄耗尽。
基本语法
资源写在 try (...) 中,可声明多个;初始化顺序从左到右,关闭顺序从右到左。catch 和 finally 都是可选的。
public class TryWithResourcesDemo {
static final class Resource implements AutoCloseable {
private final String name;
Resource(String name) {
this.name = name;
System.out.println("open " + name);
}
void use() {
System.out.println("use " + name);
}
@Override
public void close() {
System.out.println("close " + name);
}
}
public static void main(String[] args) {
// 多个资源会按声明的相反顺序关闭
try (Resource first = new Resource("first");
Resource second = new Resource("second")) {
first.use();
second.use();
// 模拟业务失败,验证异常路径仍会执行 close()
throw new IllegalStateException("business failed");
} catch (IllegalStateException e) {
System.out.println("caught: " + e.getMessage());
}
}
}预期输出:
open first
open second
use first
use second
close second
close first
caught: business failed读取方法:即使业务代码抛出异常,两个资源仍被关闭;后声明的 second 先关闭。
高频用法
文件读取时把最外层包装流放进资源声明即可,关闭包装流会继续关闭底层流。JDBC 通常按 Connection、PreparedStatement、ResultSet 的顺序声明,退出时自动按相反顺序释放。
Java 9 起,已在外部声明且保持 final 或“有效 final”的资源可以直接写入 try (resource);Java 8 需要在括号内重新声明变量。
风险与边界
资源初始化过程中若后一个资源创建失败,前面已成功创建的资源仍会关闭。若业务异常和 close() 异常同时发生,业务异常是主异常,关闭异常保存在 getSuppressed() 中,排障时不要只看 getCause()。
不要在资源关闭后继续返回依赖它的惰性对象,例如返回基于已关闭连接的 Stream 或游标。触发后会在后续遍历时报“资源已关闭”或连接异常;安全做法是在 try 内完成遍历并返回已物化的数据。
排障清单
- 确认资源类型实现了
AutoCloseable,而不是只提供同名close()方法。 - 连接数持续上涨时,检查是否把资源创建放在
try外且未纳入资源声明。 - 日志只看到业务异常时,同时打印
exception.getSuppressed()。 - 多资源存在依赖关系时,按“被依赖者先声明、依赖者后声明”安排关闭顺序。
速查:能放进 try (...) 的资源优先使用该语法,不再手写重复的 finally 关闭代码。
Optional.ofNullable(<值>)
.map(<函数>).filter(<条件>)
.orElse(<默认值>) / .orElseThrow(() -> new <异常>(...))通过 Optional 表达可能缺失的返回值并避免错误用法。
使用 Optional
Optional<T> 适合表示“方法可能返回一个值,也可能没有值”。它让调用方显式处理缺失情况,但不能替代参数校验、异常处理或集合类型。
基本用法
使用 Optional.of(value) 包装确定非空的值,使用 Optional.ofNullable(value) 接受可能为 null 的值,使用 Optional.empty() 表示缺失。消费结果时优先使用 map、filter、orElseGet 和 orElseThrow,不要直接调用 get()。
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;
public class OptionalDemo {
private static final Map<Long, String> USERS = new HashMap<>();
static {
USERS.put(1L, "Alice");
USERS.put(2L, "Bob");
}
static Optional<String> findUserName(long id) {
// 在可能返回 null 的边界统一转换为 Optional
return Optional.ofNullable(USERS.get(id));
}
public static void main(String[] args) {
String first = findUserName(1L)
.map(String::toUpperCase)
.orElseGet(() -> "UNKNOWN");
// 缺失时直接进入兜底分支,不执行 map 或 filter 中的转换
String missing = findUserName(9L)
.filter(name -> name.length() >= 3)
.orElse("NOT_FOUND");
System.out.println(first);
System.out.println(missing);
}
}预期输出:
ALICE
NOT_FOUND读取方法:存在的值经过 map 转换;缺失值不会执行转换链,直接使用兜底结果。
高频用法
查询方法可返回 Optional<T>,调用方使用 orElseThrow 把“查不到”转换为明确异常。仅在值存在时执行副作用可用 ifPresent;需要继续转换时优先保留链式调用,避免先 isPresent() 再 get()。
map 适合返回普通值的转换函数;转换函数本身返回 Optional 时使用 flatMap,否则会得到 Optional<Optional<T>>。
风险与边界
orElse(createDefault()) 会立即执行参数表达式,即使值存在也会创建默认对象。默认值计算昂贵或有副作用时,可能造成额外查询、写入或性能损耗;安全替代是 orElseGet(() -> createDefault())。
不要使用 Optional.of(null),它会立即抛出 NullPointerException。不要把 Optional 作为普通 DTO 字段、方法参数或集合元素,否则会增加序列化和调用复杂度;参数是否允许为空应通过重载、校验或明确类型约束表达。
Optional 只表示值缺失,不携带失败原因。数据库异常、网络超时等故障若被转换为 Optional.empty(),会被误判为“数据不存在”;安全做法是继续抛出或封装异常。
兼容性
核心 API 自 Java 8 可用;ifPresentOrElse 从 Java 9 提供,isEmpty 从 Java 11 提供。面向 Java 8 编译时使用 !optional.isPresent() 代替 isEmpty()。
速查:返回值可能缺失时使用 Optional;参数、字段、集合和错误状态通常不要使用。
根据顺序、去重、键值映射和并发需求选择集合。
选择集合类型
先确定是否需要重复元素、顺序、按键查找以及多线程访问,再选集合。以下示例用 Java 21 标准库比较去重、插入顺序和计数,避免把某次观察到的迭代顺序当成契约。
按需求选择
| 需求 | 常用起点 | 关键边界 |
|---|---|---|
| 按位置读取、保留重复 | ArrayList |
中间插入删除需移动元素 |
| 两端排队或栈 | ArrayDeque |
不接受 null,并非线程安全 |
| 去重且无需顺序 | HashSet |
顺序未承诺,依赖正确的相等与哈希 |
| 去重且保留插入顺序 | LinkedHashSet |
重复加入不会产生第二个元素 |
| 按键计数 | HashMap |
迭代顺序未承诺 |
| 键排序或范围查询 | TreeMap |
比较器应与相等语义一致 |
| 多线程共享键值 | ConcurrentHashMap |
不接受空键或空值,复合操作需原子 API |
可运行对照
保存为 CollectionChoice.java。计数使用 merge,输出时用 TreeMap 固定展示顺序;这不改变哈希表本身的顺序承诺。
import java.util.*;
public class CollectionChoice {
public static void main(String[] args) {
List<String> input = List.of("b", "a", "b");
Set<String> unique = new LinkedHashSet<>(input);
Map<String, Integer> counts = new HashMap<>();
// 合并已有值,避免重复写 containsKey / get / put
for (String item : input) counts.merge(item, 1, Integer::sum);
System.out.println(input);
System.out.println(unique);
System.out.println(new TreeMap<>(counts)); // 固定输出便于核对
try {
input.add("c");
} catch (UnsupportedOperationException ex) {
System.out.println("immutable");
}
}
}预期结果:原列表保留重复,集合按第一次出现去重,计数按键排序展示;修改 List.of 创建的列表被拒绝。运行:
javac CollectionChoice.java
java CollectionChoice预期输出:
[b, a, b]
[b, a]
{a=1, b=2}
immutable并发与相等约束
HashMap 和 ArrayList 不能仅靠多个线程“写不同位置”就推定安全。共享计数可考虑 ConcurrentHashMap.merge;把 get 后 put 拆成两步仍可能丢更新。同步包装集合的遍历还需要遵守其外部同步约定。
自定义键的 equals 相等时,hashCode 必须一致。作为哈希键期间不要修改参与相等计算的字段,否则对象可能留在原桶里而查找失败。恢复时从可信源重新构建映射,不能只对变更后的键调用一次 remove 就假定清理完毕。
List.of 和 List.copyOf 不接受 null;只读集合也不保证元素对象不可变。性能不明确时用真实数据规模测量读取、插入和内存,不凭集合名称替换所有容器。
List<E> list = new ArrayList<>();
list.add(e) / list.get(i) / list.set(i, e) / list.remove(i) / list.removeIf(<条件>)
list.subList(<from>, <to>)完成列表的新增、删除、查找、替换和遍历。
操作 List
使用 List 完成有序数据的新增、删除、查找、替换和遍历。默认实现通常选 ArrayList;只有确实需要链表语义时再评估其他实现。
基本语法
| 操作 | 方法 | 结果 |
|---|---|---|
| 尾部新增 | add(value) |
返回是否成功 |
| 指定位置插入 | add(index, value) |
原位置及后续元素右移 |
| 按下标读取 | get(index) |
下标从 0 开始 |
| 查找位置 | indexOf(value) |
未找到返回 -1 |
| 替换元素 | set(index, value) |
返回被替换的旧值 |
| 按下标删除 | remove(index) |
返回被删除元素 |
| 按值删除 | remove(value) |
只删除第一个匹配项 |
| 条件删除 | removeIf(predicate) |
删除所有满足条件的元素 |
可运行示例
示例覆盖插入、查找、替换、按值删除、条件删除、遍历,以及 List<Integer> 的删除重载陷阱。兼容 Java 8。
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class ListOperationsDemo {
public static void main(String[] args) {
List<String> services =
new ArrayList<>(Arrays.asList("gateway", "trade", "admin"));
services.add(1, "risk");
String first = services.get(0);
int tradeIndex = services.indexOf("trade");
if (tradeIndex >= 0) {
services.set(tradeIndex, "trade-v2");
}
services.remove("admin");
services.removeIf(name -> name.startsWith("gate"));
System.out.println("first=" + first);
System.out.println("tradeIndex=" + tradeIndex);
for (int i = 0; i < services.size(); i++) {
System.out.println(i + ":" + services.get(i));
}
List<Integer> ids = new ArrayList<>(Arrays.asList(10, 20, 30));
ids.remove(1); // 删除下标 1,对应元素 20
ids.remove(Integer.valueOf(30)); // 删除值 30,而不是下标 30
System.out.println("ids=" + ids);
}
}预期输出
first=gateway
tradeIndex=2
0:risk
1:trade-v2
ids=[10]tradeIndex=2 是因为先在下标 1 插入了 risk。最终列表删除了 admin 和以 gate 开头的元素,只剩 risk、trade-v2。
高频用法
查找后再修改时,先判断 indexOf 是否返回 -1,避免把不存在的元素位置传给 set。只判断是否存在时直接使用 contains,无需额外获取下标。
批量替换可使用 replaceAll,自定义排序可使用 sort。需要安全删除当前遍历元素时,优先使用 removeIf;需要复杂遍历状态时使用 Iterator.remove()。
风险与边界
- 访问
get(size)、set(-1, value)或在空列表上读取下标,会触发IndexOutOfBoundsException。安全替代是先检查0 <= index && index < size()。 - 在增强
for循环中直接调用list.remove,通常会触发ConcurrentModificationException。安全替代是使用removeIf或迭代器自身的remove。 List<Integer>.remove(1)会按下标删除,而不是删除数值1。按值删除时显式写成remove(Integer.valueOf(1))。Arrays.asList生成的是定长列表,List.of生成的是不可修改列表;调用新增或删除会失败。需要修改时用new ArrayList<>(source)创建副本。- 对
ArrayList频繁在头部或中间插入、删除,会反复移动元素。若需求本质是队列或双端队列,优先使用ArrayDeque。
兼容性
removeIf、replaceAll 和 sort 从 Java 8 可用;List.of 从 Java 9 可用。生产代码不要把可修改性建立在接口声明上,应确认列表的实际创建方式。
速查提示:先区分“下标”与“元素值”,再执行删除;所有下标操作都以 0 为起点。