两个常被一笔带过、实战却到处都是的语法:代码里 status = 3 满天飞,没人记得 3 是什么——该用枚举;一个类只在某个类里用一次,还非要独立成文件——该用内部类。
枚举(enum)把一组固定常量收编成类型,调用方只能从名单里选,拼错直接编译报错:
enum Status {
WAIT_PAY, PAID, SHIPPED, DONE // 名单就这四个,想加走审批
}
void handle(Status s) {
switch (s) {
case WAIT_PAY -> System.out.println("催付");
case PAID -> System.out.println("发货");
default -> System.out.println("售后");
}
}
handle(Status.PAID); // 点出来选,不可能手滑写成 "APID"
进阶用法:每个常量挂自己的说明文案和行为,枚举瞬间变成小型策略表:
enum Level {
INFO(0, "正常"),
WARN(1, "警告"),
ERROR(2, "严重故障");
final int code; // 字段
final String label;
Level(int code, String label) { // 构造方法天然私有
this.code = code;
this.label = label;
}
boolean needSms() { return code >= 2; } // 行为也能带
}
Level.ERROR.needSms(); // true——发短信
反编译一眼见底:enum 会被编译成一个继承 java.lang.Enum 的 final 类,每个常量是类里的一个 static final 实例,类加载时创建。两个红利白拿:
Status.values() 拿全名单,valueOf("PAID") 按名取,ordinal() 是序号配合专门的容器更香:EnumMap 内部是数组,比 HashMap 还快。注意别拿 ordinal 当数据库存的值——常量顺序一调整,历史数据全乱,要么存 name,要么存自定义 code 字段。
内部类(Inner Class)是把一个类定义在另一个类里面,按住的位置分四种:
class Outer {
private int x = 1;
class Member { // ①成员内部类:能直接摸 Outer.this.x
void show() { System.out.println(x); }
}
static class Nested { // ②静态内部类:不持外部引用,最独立
void show() { System.out.println("不依赖外部对象"); }
}
void method() {
class Local { } // ③局部内部类:方法里定义,出了方法就没
Runnable r = new Runnable() { // ④匿名内部类:用一次即弃
public void run() { System.out.println(x); }
};
r.run();
}
}
什么时候用?两个信号:这个类只为一外部类服务(Map.Entry 就是 Map 的静态内部类,Builder 也是);或者只在一处使用(给按钮挂个监听器,犯不着起名建文件)。
实战里 ② 和 ④ 出场率最高:静态内部类当「逻辑上归属但不想耦合」的组织单元;匿名内部类在老代码里遍地是监听器和线程,新代码则大多被 Lambda 取代(5.1 节)。
一个附带规矩:匿名/局部内部类用外部局部变量,该变量必须事实上的 final(不能再被改)——变量生命周期被偷偷延长了,可变会引发数据不一致。
枚举本质是类,自然能 implements 接口,而且能让每个常量各自重写方法:
interface Alert { void alarm(String msg); }
enum Level implements Alert {
INFO { public void alarm(String m) { /* 正常,不吵人 */ } },
ERROR { public void alarm(String m) { System.out.println("短信告警:" + m); } };
}
这样枚举就成了一张策略表:遍历 Level.values(),各级别执行各级别的告警,加一个级别只加一个常量。比一堆 if-else 干净,这招在规则引擎、状态机代码里非常常见。
枚举键有专属容器,内部拿数组按 ordinal 直接定位,比 HashMap 的哈希计算还快:
EnumMap<Status, Integer> count = new EnumMap<>(Status.class);
for (Order o : orders) count.merge(o.status, 1, Integer::sum);
EnumSet 是它的兄弟,位向量实现,做「权限位、星期几多选」这类集合运算又快又省内存。名字带 Enum 的容器记一句就够:键天生是枚举时,它们是更快的那扇门。
普通单例要防双重检查锁、防反射攻击、防反序列化破功,代码一大坨。枚举单例极短:
public enum Singleton {
INSTANCE;
public void doSomething() { /* 业务 */ }
}
调用就是 Singleton.INSTANCE.doSomething()。JVM 保证实例在类加载时唯一创建;反射想对枚举 newInstance 直接抛异常;反序列化也不会多造一份——三道防线出厂自带。《Effective Java》把它列为单例首选。代价是不能懒加载、不能继承其他类,场景合适就是最优解。
编译后内部类的 class 文件叫 Outer$Inner,匿名内部类是 Outer$1、Outer$2。日志和异常栈里看到这类名字要认识:它就是内部类,别当成乱码。反过来也说明,内部类没破坏「一个文件一个 public 类」的规矩,只是编译器帮你合了文件——源码组织更整洁,产物一点没特殊。
Builder 模式的标准长相是「静态内部类 Builder」:外部类构造收窄,由内部 Builder 一点点攒参数,最后 build() 造出对象。为什么住在里面?因为它天生只为这个类服务,放外面平白多一个文件,还暗示别人可以复用。lombok 的 @Builder 注解能自动生成这一整套。「零件住在机器里」——这是用内部类组织代码的核心直觉。
订单流转是枚举最典型的主场:WAIT_PAY 到 PAID 到 SHIPPED 到 DONE,每步「从哪能到哪」是业务规则。用枚举把规则写死:
enum OrderStatus {
WAIT_PAY { OrderStatus next() { return PAID; } },
PAID { OrderStatus next() { return SHIPPED; } },
SHIPPED { OrderStatus next() { return DONE; } },
DONE { OrderStatus next() { return DONE; } }; // 终态
abstract OrderStatus next();
}
非法流转(待支付直接跳已发货)在类型层面就不存在了,比一堆 if 校验干净。数据库存 code 字段,内存里用 next() 推进——这就是最小状态机,工作流引擎是它的工业加强版。
迁移老代码按三步走:先把散落的魔法数字收成常量表;再建枚举贴上 code 字段和查询方法;最后全局替换比较。每步都能编译通过,随时可停。
枚举和 switch 是天生一对。箭头式 switch 里 case 直接写常量名,不用写 Status.PAID 全名——switch 括号里已经声明了你在判断谁:
String desc = switch (s) {
case WAIT_PAY -> "待支付";
case PAID, SHIPPED -> "处理中";
case DONE -> "已完成";
};
多常量合并、直接产值,2.2 篇学的特性在枚举上用着最顺。switch 表达式必须列全分支,漏一个编译器直接报错——比 if 链漏分支静默出错安全一个量级。状态少用 switch 就够,状态多、流转复杂再上抽象方法版。
枚举是收编常量名单的 final 类,实例由 JVM 造好、天生单例,能带字段和行为;内部类按住处分四种,静态嵌套和匿名最常用——一个组织代码,一个用完即弃。