你必定須要知道的高階JAVA枚舉特性！

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學習之路！另每週贈書不停哦～