談?wù)勀憧赡懿⒉涣私獾膉ava枚舉

更新時(shí)間：2020年09月03日 10:37:01 作者：apocelipes

這篇文章主要給大家介紹了一些關(guān)于你可能并不了解的java枚舉的相關(guān)資料，文中通過(guò)示例代碼介紹的非常詳細(xì)，對(duì)大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價(jià)值，需要的朋友們下面隨著小編來(lái)一起學(xué)習(xí)學(xué)習(xí)吧

前言

枚舉在java里也算個(gè)老生長(zhǎng)談的內(nèi)容了，每當(dāng)遇到一組需要類(lèi)舉的數(shù)據(jù)時(shí)我們都會(huì)自然而然地使用枚舉類(lèi)型：

public enum Color {
  RED, GREEN, BLUE, YELLOW;

  public static void main(String[] args) {
    Color red = Color.RED;
    Color redAnother = Color.RED;
    Color blue = Color.BLUE;

    System.out.println(red.equals(redAnother)); // true
    System.out.println(red.equals(blue)); // false
  }
}

當(dāng)然今天我們要探討的并非是java中enum的基礎(chǔ)語(yǔ)法，本次的主題將會(huì)深入enum的本質(zhì)，并探討部分高階用法。本文基于Oracle JDK 14.0.2和jad v1.5.8e（由于jad已經(jīng)很久未進(jìn)行更新，對(duì)于新版本的jdk支持不是很完善，但單純分析enum和interface已經(jīng)足夠）。

自定義枚舉值背后的秘密

枚舉默認(rèn)的值是從0開(kāi)始遞增的數(shù)值，通常來(lái)說(shuō)這完全夠用了。不過(guò)java中還允許我們對(duì)枚舉的值做個(gè)性化定制，例如：

// 我們不僅想用英語(yǔ)的方位，同時(shí)還想取得對(duì)應(yīng)的本地化名稱(chēng)（這里是中文）
enum Direction {
  EAST("東"),
  WEST("西"),
  NORTH("北"),
  SOUTH("南");

  private final String name;

  // 注意是private
  private Direction(String name) {
    this.name = name;
  }

  public String getName() {
    return this.name;
  }
}

public class Test {
  public static void main(String[] args) {
    for (var v : Direction.values()) {
      System.out.println(v.toString() + "-->" + v.getName());
    }
  }
}

編譯并運(yùn)行程序，你將會(huì)得到下面這樣的結(jié)果：

EAST-->東
WEST-->西
NORTH-->北
SOUTH-->南

很多教程到此就結(jié)束了，點(diǎn)到為止，對(duì)于枚舉值后面的圓括號(hào)有什么作用，為什么構(gòu)造函數(shù)需要private修飾都一筆帶過(guò)甚至連解釋說(shuō)明都沒(méi)給出。然而理解這些卻是我們進(jìn)一步學(xué)習(xí)枚舉的高階用法的前提。

不過(guò)沒(méi)關(guān)系，我們可以自己動(dòng)手一探究竟，比如看看反編譯后的代碼，從編譯器處理枚舉類(lèi)型的方法中一探究竟。這里我們將會(huì)利用jad，具體的使用教程參考園內(nèi)其他優(yōu)秀文章，本文不進(jìn)行贅述，我們直接看反編譯后的結(jié)果：

final class Direction extends Enum
{

  /* 省略部分無(wú)關(guān)緊要的方法 */

  private Direction(String s, int i, String s1)
  {
    super(s, i);
    name = s1;
  }

  public String getName() // 這是我們自定義的getter
  {
    return name;
  }

  public static final Direction EAST;
  public static final Direction WEST;
  public static final Direction NORTH;
  public static final Direction SOUTH;
  private final String name;
  // 省略不重要的部分字段

  static 
  {
    EAST = new Direction("EAST", 0, "\u4E1C");
    WEST = new Direction("WEST", 1, "\u897F");
    NORTH = new Direction("NORTH", 2, "\u5317");
    SOUTH = new Direction("SOUTH", 3, "\u5357");
    // 省略部分字段的初始化
  }
}

首先看到我們的enum是一個(gè)類(lèi)，其次它繼承自java.lang.Enum（這意味著enum是無(wú)法顯式指定基類(lèi)的），而我們?cè)贒irection的構(gòu)造函數(shù)中調(diào)用了其父類(lèi)的構(gòu)造函數(shù)，通過(guò)閱讀文檔可知，java.lang.Enum的構(gòu)造函數(shù)是protected修飾的，也就是說(shuō)對(duì)于java.lang包以外的使用者無(wú)法調(diào)用這個(gè)構(gòu)造函數(shù)。同時(shí)文檔也指出，該構(gòu)造函數(shù)是由編譯器自動(dòng)調(diào)用的。因此我們自己定義的enum的構(gòu)造函數(shù)也是無(wú)法正常調(diào)用的，只能由編譯器用來(lái)初始化enum的枚舉成員。既然本身無(wú)法被用戶調(diào)用那么java干脆直接不允許protected和public（default和private允許）修飾自定義enum類(lèi)型的構(gòu)造函數(shù)以免造成誤用。

另外我們的自定義構(gòu)造函數(shù)其實(shí)是被編譯器進(jìn)行了合成，除了自定義參數(shù)之外還有枚舉成員的字符串名稱(chēng)以及一個(gè)從0開(kāi)始的序號(hào)（可用ordinal方法獲?。?，前兩個(gè)參數(shù)編譯器會(huì)自動(dòng)為我們添加，而自定義參數(shù)則是根據(jù)在我們給定的枚舉成員后的圓括號(hào)里的值傳遞給構(gòu)造函數(shù)，簡(jiǎn)單說(shuō)就是：

EAST("東"),
WEST("西"),
NORTH("北"),
SOUTH("南");

// 轉(zhuǎn)換為（unicode字符被轉(zhuǎn)碼）
EAST = new Direction("EAST", 0, "\u4E1C");
WEST = new Direction("WEST", 1, "\u897F");
NORTH = new Direction("NORTH", 2, "\u5317");
SOUTH = new Direction("SOUTH", 3, "\u5357");

如果我需要更多字段，只需要像這樣：

public enum Planet {
  // 帶有兩個(gè)自定義數(shù)值
  MERCURY (3.303e+23, 2.4397e6),
  VENUS  (4.869e+24, 6.0518e6),
  EARTH  (5.976e+24, 6.37814e6),
  MARS  (6.421e+23, 3.3972e6),
  JUPITER (1.9e+27,  7.1492e7),
  SATURN (5.688e+26, 6.0268e7),
  URANUS (8.686e+25, 2.5559e7),
  NEPTUNE (1.024e+26, 2.4746e7);

  // 保存自定義值的字段，不使用final也可以，但枚舉值一般不應(yīng)該發(fā)生改變
  private final double mass;  // in kilograms
  private final double radius; // in meters
  // 在這里使用default的權(quán)限控制，即package-private
  Planet(double mass, double radius) {
    this.mass = mass;
    this.radius = radius;
  }
  public double mass() { return mass; }
  public double radius() { return radius; }
}

這就是自定義枚舉值背后的秘密。

至此我們的疑問(wèn)幾乎都得到了解答，然而細(xì)心觀察就會(huì)發(fā)現(xiàn)，我們的枚舉成員都是Direction的_靜態(tài)字段_！因此我們不能把這些枚舉成員當(dāng)作類(lèi)型來(lái)使用：

public void work(Direction.EAST e) {
  // 這是無(wú)法通過(guò)編譯的
}

靜態(tài)字段很好理解，因?yàn)槲覀冃枰ㄟ^(guò)類(lèi)名+枚舉成員名Direction.WEST直接引用，但為什么字段類(lèi)型要是Direction的呢？

別著急，下一節(jié)答案就將揭曉。

為枚舉添加抽象方法

這一節(jié)看起來(lái)很荒謬，抽象方法似乎和枚舉八桿子打不到一塊兒去?？墒亲屑?xì)想一想，在上一節(jié)中我們已經(jīng)為枚舉添加了getter成員方法，這說(shuō)明我們還可以為枚舉添加其他的方法從而定制枚舉類(lèi)型的行為，以上一節(jié)的Planet為例，我們可以添加計(jì)算任意物體在某個(gè)行星表面所受重力和質(zhì)量的大?。?/p>

public enum Planet {
  
  /* 定義枚舉成員和初始化的相關(guān)重復(fù)代碼，此處不再重復(fù) */

  private double mass() { return mass; }
  private double radius() { return radius; }

  // universal gravitational constant (m3 kg-1 s-2)
  public static final double G = 6.67300E-11;

  double surfaceGravity() {
    return G * mass / (radius * radius);
  }
  double surfaceWeight(double otherMass) {
    return otherMass * surfaceGravity();
  }
  public static void main(String[] args) {
    if (args.length != 1) {
      System.err.println("Usage: java Planet <earth_weight>");
      System.exit(-1);
    }
    double earthWeight = Double.parseDouble(args[0]);
    double mass = earthWeight/EARTH.surfaceGravity();
    for (Planet p : Planet.values())
      System.out.printf("Your weight on %s is %f%n",
               p, p.surfaceWeight(mass));
  }
}

運(yùn)行結(jié)果如下：

$ java Planet.java 70

Your weight on MERCURY is 26.443033
Your weight on VENUS is 63.349937
Your weight on EARTH is 70.000000
Your weight on MARS is 26.511603
Your weight on JUPITER is 177.139027
Your weight on SATURN is 74.621088
Your weight on URANUS is 63.358904
Your weight on NEPTUNE is 79.682965

既然能定制整個(gè)enum的行為，那是否意味著我們可以單獨(dú)定義枚舉成員的行為呢，畢竟方法最終還是從枚舉成員值身上進(jìn)行調(diào)用的。

答案是肯定的，還記得在上一節(jié)最后部分編譯器是怎么處理枚舉成員的嗎？

EAST = new Direction("EAST", 0, "\u4E1C");
WEST = new Direction("WEST", 1, "\u897F");
NORTH = new Direction("NORTH", 2, "\u5317");
SOUTH = new Direction("SOUTH", 3, "\u5357");

沒(méi)錯(cuò)，枚舉成員本身也是enum對(duì)象的一個(gè)實(shí)例！而且這些枚舉成員雖然是Direction類(lèi)型的，但實(shí)際上還可以引用Direction的派生類(lèi)型。

假設(shè)我們有一個(gè)Color類(lèi)型的枚舉，對(duì)于每個(gè)枚舉成員我們都一個(gè)定制的print方法用于打印不同的信息：

enum Color {
  RED{
    // 先不用管這是什么語(yǔ)法，后面會(huì)解釋
    @Override
    public void print() {
      // Linux上輸出彩色字符串
      System.out.println("\u001B[1;31m This is red text \u001B[0m");
    }
  },
  BLUE{
    @Override
    public void print() {
      System.out.println("\u001B[1;34m This is blue text \u001B[0m");
    }
  },
  GREEN{
    @Override
    public void print() {
      System.out.println("\u001B[1;32m This is green text \u001B[0m");
    }
  };

  // 枚舉成員必須要覆寫(xiě)的抽象方法
  public abstract void print();
}

public class Test {
  public static void main(String[] args) {
    for (var v : Color.values()) {
      v.print();
    }
  }
}

運(yùn)行結(jié)果如下：

要想知道原理，我們還是得借助jad，這是Color.class經(jīng)過(guò)處理后的內(nèi)容：

// 變成了抽象類(lèi)
abstract class Color extends Enum
{
  // 構(gòu)造函數(shù)
  private Color(String s, int i)
  {
    super(s, i);
  }

  public abstract void print();

  public static final Color RED;
  public static final Color BLUE;
  public static final Color GREEN;

  static 
  {
    // 重點(diǎn)從這開(kāi)始
    RED = new Color("RED", 0) {

      public void print()
      {
        System.out.println("\033[1;31m This is red text \033[0m");
      }

    };
    BLUE = new Color("BLUE", 1) {

      public void print()
      {
        System.out.println("\033[1;34m This is blue text \033[0m");
      }

    };
    GREEN = new Color("GREEN", 2) {

      public void print()
      {
        System.out.println("\033[1;32m This is green text \033[0m");
      }

    };
  }
}

細(xì)心的讀者大概已經(jīng)發(fā)現(xiàn)了，這不就是_匿名內(nèi)部類(lèi)_么？說(shuō)對(duì)了，我們的enum類(lèi)型這次實(shí)際上變成了抽象類(lèi)，而枚舉成員則是繼承自Color的匿名內(nèi)部類(lèi)并實(shí)現(xiàn)了抽象方法。所以最開(kāi)始我們用注釋標(biāo)記的大括號(hào)其實(shí)可以理解成匿名類(lèi)的類(lèi)體。不過(guò)需要注意的是，雖然這里顯式使用了new來(lái)創(chuàng)建了匿名內(nèi)部類(lèi)，但構(gòu)造函數(shù)仍然是編譯器代為調(diào)用的。

如果想增加自定義的枚舉數(shù)據(jù)呢？可以這樣做：

enum Color {
  RED(31){
    @Override
    public void print() {
      System.out.println("\u001B[1;31m This is red text \u001B[0m");
    }
  },
  BLUE(34){
    @Override
    public void print() {
      System.out.println("\u001B[1;34m This is blue text \u001B[0m");
    }
  },
  GREEN(32){
    @Override
    public void print() {
      System.out.println("\u001B[1;32m This is green text \u001B[0m");
    }
  };

  // color code
  private final int colorCode;
  private Color(int code) {
    colorCode = code;
  }
  public int getColorCode() {
    return colorCode;
  }

  public abstract void print();
}

我們看看編譯后的代碼，限于篇幅，我只保留了重要的部分：

abstract class Color extends Enum
{

  /* 大量省略代碼 */

  private Color(String s, int i, int j)
  {
    super(s, i);
    colorCode = j;
  }

  public abstract void print();

  public static final Color RED;
  public static final Color BLUE;
  public static final Color GREEN;
  private final int colorCode;

  static 
  {
    // 參數(shù)傳遞給了構(gòu)造函數(shù)
    RED = new Color("RED", 0, 31) {

      public void print()
      {
        System.out.println("\033[1;31m This is red text \033[0m");
      }

    };
    BLUE = new Color("BLUE", 1, 34) {

      public void print()
      {
        System.out.println("\033[1;34m This is blue text \033[0m");
      }

    };
    GREEN = new Color("GREEN", 2, 32) {

      public void print()
      {
        System.out.println("\033[1;32m This is green text \033[0m");
      }

    };
  }
}

總結(jié)一下，對(duì)于一個(gè)enum類(lèi)型來(lái)說(shuō)，通常會(huì)有如下格式：

[public] enum NAME [implements XXX, ...] {
  VALUE1 [(自定義數(shù)據(jù)，格式和自定義構(gòu)造函數(shù)函數(shù)的參數(shù)列表相同)]
  [{
    // 可以override或是追加新的method
  }],
  ...,
  VALUEN [(...)]
  [{
    // overrides or methods
  }];

  [存儲(chǔ)各種自定義數(shù)據(jù)的字段，最好用final修飾]
  [
    // 自定義構(gòu)造函數(shù)
    [private] NAME(和枚舉成員中給出的圓括號(hào)內(nèi)的內(nèi)容一致) { /* 設(shè)置數(shù)據(jù)字段 */ }
  ]

  [定義抽象方法或者重寫(xiě)object/Enum的方法或是添加普通類(lèi)方法]
}

給出的格式中用[]框住的部分都是可以省略的。

枚舉和接口

在上一節(jié)的最后，我們看到enum其實(shí)還可以實(shí)現(xiàn)interface（畢竟本質(zhì)上還是個(gè)class），所以上一節(jié)的例子可以這么寫(xiě)：

interface Printer {
  void print();
}

enum Color implements Printer {
  RED{
    @Override
    public void print() {
      System.out.println("\u001B[1;31m This is red text \u001B[0m");
    }
  },
  BLUE{
    @Override
    public void print() {
      System.out.println("\u001B[1;34m This is blue text \u001B[0m");
    }
  },
  GREEN{
    @Override
    public void print() {
      System.out.println("\u001B[1;32m This is green text \u001B[0m");
    }
  };
}

我個(gè)人更傾向于第二種方法，因?yàn)閑num主要是數(shù)據(jù)的集合，而對(duì)于數(shù)據(jù)表現(xiàn)出的行為/模式盡量使用interface進(jìn)行描述。

除此之外，enum還可以定義在iinterface中。假設(shè)我們有一個(gè)枚舉表示從周一到周日，同時(shí)給定一個(gè)方法isRestDay判斷當(dāng)前日期是否可以休息（比如有的人雙休有的人單休還有的人在周一或周五休息），不同類(lèi)型的人對(duì)于周幾該休息將會(huì)產(chǎn)生不同的答案，因此將它抽象成接口再合適不過(guò)了：

interface Relaxable {
  enum Weekly {
    Mon, Tue, Wed, Thu, Fri, Sat, Sun
  }

  boolean isRestDay(Relaxable.Weekly day);
}

class PersonA implements Relaxable {
  @Override
  public boolean isRestDay(Relaxable.Weekly day) {
    return day.equals(Relaxable.Weekly.Sat) || day.equals(Relaxable.Weekly.Sun);
  }
}

class PersonB implements Relaxable {
  @Override
  public boolean isRestDay(Relaxable.Weekly day) {
    return day.equals(Relaxable.Weekly.Sun);
  }
}

public class Relax {
  public static void main(String[] args) {
    var a = new PersonA();
    var b = new PersonB();
    var day = Relaxable.Weekly.Sat;
    System.out.println(a.isRestDay(day)); // true
    System.out.println(b.isRestDay(day)); // false
  }
}

PersonA擁有一個(gè)美好的雙休，而可憐的PersonB卻要在周六加班！使用jad查看生產(chǎn)的代碼：

interface Relaxable
{
  public static final class Weekly extends Enum
  {

    /* 省略了部分代碼 */

    public static final Weekly Mon;
    public static final Weekly Tue;
    public static final Weekly Wed;
    public static final Weekly Thu;
    public static final Weekly Fri;
    public static final Weekly Sat;
    public static final Weekly Sun;

    static 
    {
      Mon = new Weekly("Mon", 0);
      Tue = new Weekly("Tue", 1);
      Wed = new Weekly("Wed", 2);
      Thu = new Weekly("Thu", 3);
      Fri = new Weekly("Fri", 4);
      Sat = new Weekly("Sat", 5);
      Sun = new Weekly("Sun", 6);
    }

    private Weekly(String s, int i)
    {
      super(s, i);
    }
  }

  public abstract boolean isRestDay(Weekly weekly);
}

可以看出此時(shí)的enum僅僅只是interface中的一個(gè)靜態(tài)內(nèi)部類(lèi)而已。使用類(lèi)似的方法可以借由interface來(lái)組織多個(gè)不同但有弱關(guān)聯(lián)性的枚舉類(lèi)型，從而構(gòu)成類(lèi)似其他語(yǔ)言中namespace的組織結(jié)構(gòu)。

當(dāng)然，通常我們并不推薦用接口來(lái)組織多種不同的類(lèi)型或是構(gòu)成namespace，接口通常的作用是抽象出一組類(lèi)的共同特性，或是讓不同的類(lèi)之間可以遵守相同的協(xié)議從而簡(jiǎn)化開(kāi)發(fā)工作，主體應(yīng)該是接口提供的方法以及這些方法所依賴(lài)的共通的一小部分?jǐn)?shù)據(jù)類(lèi)型（例如上例，雖然例子不是很好）;而final class則更適合組織不同數(shù)據(jù)類(lèi)型和靜態(tài)常量，更進(jìn)一步的理由超過(guò)了本文的探討范疇，你可以在園內(nèi)搜索相關(guān)文章進(jìn)一步學(xué)習(xí)。

總結(jié)

在本文中，我們學(xué)到了：