共计 3607 个字符，预计需要花费 10 分钟才能阅读完成。
JAVA 枚举，比你设想中还要有用！
我常常发现自己在 Java 中应用枚举来示意某个对象的一组潜在值。
在编译时确定类型能够具备什么值的能力是一种弱小的能力，它为代码提供了构造和意义。
当我第一次理解枚举时，过后我认为它们只是一个为常量命名的工具，能够很容易地被动态常量字符串 ENUM_VAL_NAME 所取代。
起初我发现我错了。事实证明，Java 枚举具备相当高级的个性，能够使代码洁净、不易出错，功能强大。
让咱们一起来看看 Java 中的一些高级枚举个性，以及如何利用这些个性使代码更简略、更可读。
枚举是类！
在 Java 中，枚举是 Object 的一个子类。让咱们看看所有枚举的基类，Enum<E>（为简洁起见进行了批改）。
public abstract class Enum<E extends Enum<E>>
implements Constable, Comparable<E>, Serializable {
private final String name;
public final String name() {return name;}
private final int ordinal;
public final int ordinal() {return ordinal;}
protected Enum(String name, int ordinal) {
this.name = name;
this.ordinal = ordinal;
}
public String toString() {return name;}
public final boolean equals(Object other) {return this==other;}
public final int hashCode() {return super.hashCode();
}
public final int compareTo(E o) {Enum<?> other = (Enum<?>)o;
Enum<E> self = this;
if (self.getClass() != other.getClass() && // optimization
self.getDeclaringClass() != other.getDeclaringClass())
throw new ClassCastException();
return self.ordinal - other.ordinal;
}
}
咱们能够看到，这基本上只是一个惯例的抽象类，有两个字段，name 和 ordinal。
所以说枚举都是类，所以它们具备惯例类的许多个性。
咱们可能为枚举提供实例办法、构造函数和字段。咱们能够重写 toString（），但不能重写 hashCode（）或 equals（Object other）。
接下来咱们看下咱们的枚举示例，Operation
enum Operation {
ADD,
SUBTRACT,
MULTIPLY
}
这个枚举示意一个 Operation 能够对两个值执行，并将生成一个后果。对于如何实现此性能，您最后的想法可能是应用 switch 语句，如下所示：
public int apply(Operation operation, int arg1, int arg2) {switch(operation) {
case ADD:
return arg1 + arg2;
case SUBTRACT:
return arg1 - arg2;
case MULTIPLY:
return arg1 * arg2;
default:
throw new UnsupportedOperationException();}
}
当然，这样子会有一些问题。
第一个问题是，如果咱们将一个新操作增加到咱们的枚举 Operation 中，编译器不会告诉咱们这个开关不能正确处理新操作。
更蹩脚的是，如果一个懈怠的开发人员在另一个类中复制或从新编写这些代码，咱们可能无奈更新它。
第二个问题是默认状况 default，每段程序外面都是必须的，只管咱们晓得在正确的代码里它永远不会产生。
这是因为 Java 编译器晓得下面的第一个问题，并且心愿确保咱们可能解决在不知情的状况下向 Operation 中增加了新枚举。
还好，Java8 用函数式编程为咱们提供了一个洁净的解决方案。
函数枚举实现
因为枚举是类，所以咱们能够创立一个枚举字段来保留执行操作的函数。
然而在咱们找到解决方案之前，让咱们先来看看一些重构。
首先，让咱们把开关放在 enum 类中。
enum Operation {
ADD,
SUBTRACT,
MULTIPLY;
public static int apply(Operation operation, int arg1, int arg2) {switch(operation) {
case ADD:
return arg1 + arg2;
case SUBTRACT:
return arg1 - arg2;
case MULTIPLY:
return arg1 * arg2;
default:
throw new UnsupportedOperationException();}
}
}
咱们能够这样做：Operation.apply(Operation.ADD, 2, 3);
因为咱们当初从 Operation 中调用办法，所以咱们能够将其更改为实例办法并应用 this，而不是用 Operation.apply（）来实现，如下所示：
public int apply(int arg1, int arg2) {switch(this) {
case ADD:
return arg1 + arg2;
case SUBTRACT:
return arg1 - arg2;
case MULTIPLY:
return arg1 * arg2;
default:
throw new UnsupportedOperationException();}
}
像这样应用：Operation.ADD.apply(2, 3);
看起来变好了。当初让咱们更进一步，通过应用函数式编程齐全打消 switch 语句。
enum Operation {ADD((x, y) -> x + y),
SUBTRACT((x, y) -> x - y),
MULTIPLY((x, y) -> x * y);
Operation(BiFunction<Integer, Integer, Integer> operation) {this.operation = operation;}
private final BiFunction<Integer, Integer, Integer> operation;
public int apply(int x, int y) {return operation.apply(x, y);
}
}
这里我做的是：
- 增加了一个字段 BiFunction<Integer, Integer, Integer> operation
- 用 BiFunction 创立了用于 Operation 的构造函数。
- 调用枚举定义中的构造函数，并用 lambda 指定 BiFunction<Integer, Integer, Integer>。
这个 java.util.function.BiFunction operation 字段是对采纳两个参数的函数（办法）的援用。
在咱们的例子中，两个参数都是 int 型，返回值也是 int 型。可怜的是，Java 参数化类型不反对原语，所以咱们必须应用 Integer。
因为 BiFunction 是用 @functioninterface 正文的，所以咱们能够应用 Lambda 表示法定义一个。
因为咱们的函数承受两个参数，所以咱们能够应用（x，y）来指定它们。
而后咱们定义了一个单行办法，它应用 ->x+y 返回一个值。这相当于上面的办法，只是更简洁而已。
class Adder implements BiFunction<Integer, Integer, Integer> {
@Override
public Integer apply(Integer x, Integer y) {return x + y;}
}咱们的新 Operation 实现采纳雷同的形式：Operation.ADD.apply(2, 3);.
然而，这种实现更好，因为编译器会通知咱们何时增加了新 Operation，这要求咱们更新新函数。如果没有这一点，如果咱们在增加新 Operation 时还不记得更新 switch 语句，就有可能失去 UnsupportedOperationException（）。
要害要点
- Enum 枚举是 Enum<T> 的扩大类。
- Enum 枚举能够有字段、构造函数和实例办法。
- Enum 枚举字段能够存储函数。与 lambdas 配合应用，能够创立洁净、平安的特定于枚举的函数实现，并在编译时强制执行它们（而不是应用 switch）。
上面是这个示例的 GitHub 地址。（https://github.com/alex-power…）
本文参考：https://medium.com/javarevisi…
欢送关注我的公众号：程序猿 DD，取得独家整顿的收费学习资源助力你的 Java 学习之路！另每周赠书不停哦～
