/** * 枚举的工具方法类提供格式化和解析LocalDate的方法 */ public enum DateUtil { INSTANCE;// 这就是一个枚举常量代表 DateUtil 的唯一实例 private final DateTimeFormatter formatter DateTimeFormatter.ofPattern(yyyy-MM-dd); public String formatDate(LocalDate date) { return date.format(formatter); } public LocalDate parseDate(String dateStr) { return LocalDate.parse(dateStr, formatter); } public static void main(String[] args) { System.out.println(DateUtil.INSTANCE.formatDate(LocalDate.now())); } }这里INSTANCE表示DateUtil枚举的唯一实例通过DateUtil.INSTANCE即可访问。它具备以下特性单例性JVM 保证每个枚举值只有一个实例DateUtil.INSTANCE全局唯一。线程安全实例化由 JVM 在类加载时完成天然线程安全。序列化安全枚举的序列化机制保证反序列化时不会创建新实例。反射安全无法通过反射创建枚举实例。因此INSTANCE常用于实现单例模式例如工具类、配置类等场景既简洁又安全。public enum ErrorCode { SUCCESS(0, 成功), PARAM_ERROR(1001, 参数错误), SYSTEM_ERROR(5001, 系统错误); private final int code; private final String message; ErrorCode(int code, String message) { this.code code; this.message message; } // 通过code查找枚举 public static ErrorCode valueOf(int code) { return Arrays.stream(values()) .filter(e - e.code code) .findFirst() .orElse(SYSTEM_ERROR); } public int getCode() { return code; } public String getMessage() { return message; } public static void main(String[] args) { ErrorCode errorCode ErrorCode.valueOf(1001); System.out.println(errorCode.getMessage()); } }/** * 1. 枚举抽象方法策略模式 * */ public enum Operation { PLUS { Override public int apply(int x, int y) { return x y; } }, MINUS { Override public int apply(int x, int y) { return x - y; } }, MULTIPLY { Override public int apply(int x, int y) { return x * y; } }; public abstract int apply(int x, int y); public static void main(String[] args) { // 使用 int result Operation.PLUS.apply(5, 3); // 返回 8 System.out.println(result: result); } }/** * 2. 枚举实现接口 */ public enum FileOperation implements Command{ OPEN { Override public void execute() { System.out.println(打开文件); } }, SAVE { Override public void execute() { System.out.println(保存文件); } }; public static void main(String[] args) { // 使用 FileOperation.OPEN.execute(); } } public interface Command { void execute(); }public enum OrderStatus { CREATED { Override public OrderStatus next() { return PAID; } }, PAID { Override public OrderStatus next() { return SHIPPED; } }, SHIPPED { Override public OrderStatus next() { return DELIVERED; } }, DELIVERED { Override public OrderStatus next() { return this; // 最终状态 } }; public abstract OrderStatus next(); public static void main(String[] args) { OrderStatus status OrderStatus.CREATED; System.out.println(status.next()); } }/** 在Java枚举中valueOf() 是一个静态方法它的作用是 将字符串转换为对应的枚举值. // 将字符串 ALIPAY 转换为枚举值 PaymentMethod.ALIPAY PaymentMethod paymentMethod PaymentMethod.valueOf(ALIPAY); // 将字符串 WECHAT 转换为枚举值 PaymentMethod.WECHAT PaymentMethod paymentMethod PaymentMethod.valueOf(WECHAT); / public enum PaymentMethod { ALIPAY { Override public PaymentStrategy createStrategy() { return new AlipayStrategy(); } }, WECHAT { Override public PaymentStrategy createStrategy() { return new WechatStrategy(); } }; public abstract PaymentStrategy createStrategy(); // 静态工厂方法 public static PaymentStrategy getStrategy(String method) { return valueOf(method.toUpperCase()).createStrategy(); } public static void main(String[] args) { PaymentStrategy alipayStrategy getStrategy(alipay); alipayStrategy.pay(); } } public interface PaymentStrategy { void pay(); } public class AlipayStrategy implements PaymentStrategy { Override public void pay() { System.out.println(支付宝支付); } } public class WechatStrategy implements PaymentStrategy { Override public void pay() { System.out.println(微信支付); } }public enum Permission { READ(1), // 0001 WRITE(2), // 0010 EXECUTE(4), // 0100 DELETE(8); // 1000 private final int mask; Permission(int mask) { this.mask mask; } public int getMask() { return mask; } // 权限组合 public static int combine(Permission... permissions) { return Arrays.stream(permissions) .mapToInt(Permission::getMask) .reduce(0, (a, b) - a | b); } // 检查权限 public static boolean hasPermission(int permissions, Permission permission) { return (permissions permission.getMask()) ! 0; } public static void main(String[] args) { // 使用 int myPermissions Permission.combine(Permission.READ, Permission.WRITE); System.out.println(myPermissions myPermissions ); boolean canWrite Permission.hasPermission(myPermissions, Permission.WRITE); System.out.println(canWrite canWrite ); } }public enum PizzaSize { SMALL(30, 25.0), MEDIUM(35, 35.0), LARGE(40, 45.0); private final int diameter; private final double price; PizzaSize(int diameter, double price) { this.diameter diameter; this.price price; } public int getDiameter() { return diameter; } public double getPrice() { return price; } /** * 语法特点 * 箭头语法使用 - 而不是传统的 : * 直接返回值不需要 break 语句每个 case 直接返回结果 * 表达式特性整个 switch 可以作为一个表达式使用有返回值 * * 优势 * 更简洁代码行数减少 * 更安全避免了忘记写 break 导致的 fall-through 问题 * 更直观每个 case 直接对应一个返回值 * */ // public PizzaSize upgrade() { // return switch (this) { // case SMALL - MEDIUM; // case MEDIUM - LARGE; // case LARGE - LARGE; // 已经是最大 // }; // } /** * 主要变化说明 * 语法结构 * * 从 switch (this) { case SMALL - MEDIUM; } 改为传统的 switch-case 语法 * 使用冒号 : 而不是箭头 - * 每个case需要明确的 return 语句 * 添加default分支 * * 在Java 8中建议添加default分支来处理未知情况 * 防止未来添加新的枚举值时出现未处理的情况 * 代码风格 * * 每个case分支独占一行提高可读性 * 保持原有的注释说明 * * return */ public PizzaSize upgrade() { switch (this) { case SMALL: return MEDIUM; case MEDIUM: return LARGE; case LARGE: return LARGE; // 已经是最大 default: throw new IllegalArgumentException(Unknown pizza size: this); } } public static void main(String[] args) { PizzaSize size PizzaSize.SMALL; size size.upgrade(); System.out.println(size.getDiameter() : size.getPrice()); } }public enum ReportType { PDF { Override protected String generateHeader() { return PDF Header; } Override protected String generateFooter() { return PDF Footer; } }, EXCEL { Override protected String generateHeader() { return Excel Header; } Override protected String generateFooter() { return Excel Footer; } }; // 模板方法 public final String generateReport(String content) { return generateHeader() \n content \n generateFooter(); } protected abstract String generateHeader(); protected abstract String generateFooter(); public static void main(String[] args) { ReportType reportType ReportType.PDF; String report reportType.generateReport(Hello World); System.out.println(report: report); } }package com.hihonor.marketing.crowd; /** * 枚举值本质上是单例模式而且是Java中实现单例模式的最佳方式。 * 为什么枚举是天然的单例 * JVM保证唯一性每个枚举值在JVM中只有一个实例 * 线程安全枚举的实例化由JVM在类加载时完成天然线程安全 * 序列化安全枚举的序列化机制保证了反序列化时不会创建新实例 * 反射安全无法通过反射创建枚举实例 * * 这种写法确保了 * Singleton.INSTANCE 在整个JVM中只有一个实例 * 线程安全无需额外的同步机制 * 序列化和反序列化安全 * 总结 * 枚举值确实是单例模式而且是《Effective Java》作者Joshua Bloch推荐的实现单例的最佳方式。它解决了传统单例实现中的线程安全、序列化、反射攻击等问题代码简洁且功能强大。 */ public enum Singleton { INSTANCE;// 这就是一个单例实例 private int counter 0; public void doSomething() { counter; System.out.println(执行次数: counter); } public static void main(String[] args) { // 使用 - 线程安全防止反射攻击 Singleton.INSTANCE.doSomething(); } }public enum Validator { NOT_NULL(Objects::nonNull, 不能为空), NOT_BLANK(s - s ! null !s.toString().trim().isEmpty(), 不能为空或空白), POSITIVE(n - n ! null ((Number)n).doubleValue() 0, 必须为正数); private final PredicateObject predicate; private final String message; Validator(PredicateObject predicate, String message) { this.predicate predicate; this.message message; } public boolean validate(Object value) { return predicate.test(value); } public String getMessage() { return message; } public static void main(String[] args) { System.out.println(Validator.NOT_NULL.validate(hello)); System.out.println(Validator.NOT_NULL.validate(null)); } }