Java枚舉的使用方法詳解

發(fā)布時間：2020-10-25 20:49:31 來源：腳本之家閱讀：148 作者：SexyCode 欄目：編程語言

Java枚舉的使用方法詳解

前言你代碼中的flag和status，都應該用枚舉來替代

很多人都說，枚舉在實際開發(fā)中很少用到，甚至就沒用到。因為，他們的代碼往往是這樣子的：

public class Constant { 
  /* 
   * 以下幾個變量表示英雄的狀態(tài) 
   */ 
  public final static int STATUS_WALKING = 0;//走  
  public final static int STATUS_RUNNINGING = 1;//跑 
  public final static int STATUS_ATTACKING = 2;//攻擊  
  public final static int STATUS_DEFENDING = 3;//防御  
  public final static int STATUS_DEAD = 4;//掛了  
   
  /* 
   * 以下幾個變量表示英雄的等級 
   */ 
  //此處略去N行代碼 
}

然后，他們是這樣使用這個類的：

hero.setStatus(Contant.STATUS_ATTACKING);

嗯，然后他們就說，“我在實際開發(fā)中很少用到枚舉”

當然，他們的意思是說很少用到枚舉Enum這個類。

但是，我想說的是，上面這些代碼，通通應該用Enum去實現(xiàn)。

為什么？

因為他們的代碼完全建立在對隊友的信任，假設(shè)來了個奇葩隊友，做了這件事：

hero.setStatus(666);

你說，屏幕上的英雄會怎么樣呢？

總之，假如你在實際編程中經(jīng)常使用這樣的代碼，那是時候好好學習一下Enum了。

枚舉初探為什么要使用枚舉類型

生活中處處都有枚舉，包括“天然的枚舉”，比如行星、一周的天數(shù)，也包括我們設(shè)計出來的枚舉，比如csdn的tab標簽，菜單等。

Java代碼中表示枚舉的方式，大體上有兩種，一是int枚舉，而是Enum枚舉，當然，我們都知道，Enum枚舉才是Java提供的真正枚舉。

那么，為什么我們要使用Enum枚舉類型呢？先來看看在Java 1.5之前，沒有枚舉類型時，我們是怎樣表示枚舉的。

以八大行星為例，每個行星對應一個int值，我們大概會這樣寫

public class PlanetWithoutEnum { 
  public static final int PLANET_MERCURY = 0; 
  public static final int PLANET_VENUS = 1; 
  public static final int PLANET_EARTH = 2; 
  public static final int PLANET_MARS = 3; 
  public static final int PLANET_JUPITER = 4; 
  public static final int PLANET_SATURN = 5; 
  public static final int PLANET_URANUS = 6; 
  public static final int PLANET_NEPTUNE = 7; 
}

這種叫int枚舉模式，當然你也可以使用String枚舉模式，無論采用何種方式，這樣的做法，在類型安全和使用方便性上都很差。
如果變量planet表示一個行星，使用者可以給這個值賦與一個不在我們枚舉值里面的值，比如 planet = 9，這是哪個行星估計也只有天知道了; 再者，我們很難計算出到底有多少個行星，我們也很難對行星進行遍歷操作等等。

現(xiàn)在我們用枚舉來創(chuàng)建我們的行星。

public enum Planet { 
  MERCURY, VENUS, EARTH, MARS, JUPITER, SATURN, URANUS, NEPTUNE; 
}

上面這個是最簡單的枚舉，我們姑且叫做Planet 1.0，這個版本的行星枚舉，我們實現(xiàn)了一個功能，就是任何一個Planet類型的變量，都可以由編譯器來保證，傳到給參數(shù)的任何非null對象一定屬于這八個行星之一。

然后，我們對Planet進行升級，Java允許我們給枚舉類型添加任意的方法，這里引言書中的代碼，大家自行體會一下枚舉的構(gòu)造器、公共方法、枚舉遍歷等知識點。

public enum Planet { 
  MERCURY(3.302e+23, 2.439e6),  
  VENUS(4.869e+24, 6.052e6),  
  EARTH(5.975e+24,6.378e6),  
  MARS(6.419e+23, 3.393e6),  
  JUPITER(1.899e+27, 7.149e7),  
  SATURN(5.685e+26, 6.027e7),  
  URANUS(8.683e+25, 2.556e7),  
  NEPTUNE(1.024e+26,2.477e7); 
  private final double mass; // In kilograms 
  private final double radius; // In meters 
  private final double surfaceGravity; // In m / s^2 
 
  // Universal gravitational constant in m^3 / kg s^2 
  private static final double G = 6.67300E-11; 
 
  // Constructor 
  Planet(double mass, double radius) { 
    this.mass = mass; 
    this.radius = radius; 
    surfaceGravity = G * mass / (radius * radius); 
  } 
 
  public double mass() { 
    return mass; 
  } 
 
  public double radius() { 
    return radius; 
  } 
 
  public double surfaceGravity() { 
    return surfaceGravity; 
  } 
 
  public double surfaceWeight(double mass) { 
    return mass * surfaceGravity; // F = ma 
  } 
}

//注：這里對書中的代碼做了微調(diào) 
public class WeightTable { 
  public static void main(String[] args) { 
    printfWeightOnAllPlanets(8d); 
  } 
 
  public static void printfWeightOnAllPlanets(double earthWeight) { 
    double mass = earthWeight / Planet.EARTH.surfaceGravity(); 
    for (Planet p : Planet.values()) 
      System.out.printf("Weight on %s is %f%n", p, p.surfaceWeight(mass)); 
  } 
}

運行WeightTable，打印結(jié)果如下：

Weight on MERCURY is 3.023254
Weight on VENUS is 7.240408
Weight on EARTH is 8.000000
Weight on MARS is 3.036832
Weight on JUPITER is 20.237436
Weight on SATURN is 8.524113
Weight on URANUS is 7.238844
Weight on NEPTUNE is 9.090108

在這個小程序里，我們用到了枚舉的values()方法，這個方法返回了枚舉類型里的枚舉變量的集合，非常實用。

枚舉進階計算器運算符枚舉類

上一小節(jié)的例子里，我們用到了枚舉類的公共方法，這一節(jié)，我們以計算器運算符 Operation 枚舉類為例，看看怎么實現(xiàn)對于

每一個枚舉對象，執(zhí)行不同的操作。

首先，我們很容易想到的一個方法，在公共方法里，使用switch去判斷枚舉類型，然后執(zhí)行不同的操作，代碼如下：

public enum OperationUseSwitch { 
  PLUS, MINUS, TIMES, DIVIDE; 
 
  double apply(double x, double y) { 
    switch (this) { 
      case PLUS: 
        return x + y; 
      case MINUS: 
        return x + y; 
      case TIMES: 
        return x + y; 
      case DIVIDE: 
        return x + y; 
    } 
    // 如果this不屬于上面四種操作符，拋出異常 
    throw new AssertionError("Unknown operation: " + this); 
  } 
}

這段代碼確實實現(xiàn)了我們的需求，但是有兩個弊端。

首先是我們不得不在最后拋出異?；蛘咴趕witch里加上default，不然無法編譯通過，但是很明顯，程序的分支是不會進入異常或者default的。

其次，這段代碼非常脆弱，如果我們添加了新的操作類型，卻忘了在switch里添加相應的處理邏輯，執(zhí)行新的運算操作時，就會出現(xiàn)問題。

還好，Java枚舉提供了一種功能，叫做特定于常量的方法實現(xiàn)。

我們只需要在枚舉類型中聲明一個抽象方法，然后在各個枚舉常量中去覆蓋這個方法，實現(xiàn)如下：

public enum Operation { 
  PLUS { 
    double apply(double x, double y) { 
      return x + y; 
    } 
  }, 
  MINUS { 
    double apply(double x, double y) { 
      return x - y; 
    } 
  }, 
  TIMES { 
    double apply(double x, double y) { 
      return x * y; 
    } 
  }, 
  DIVIDE { 
    double apply(double x, double y) { 
      return x / y; 
    } 
  }; 
 
  abstract double apply(double x, double y); 
}

這樣，也就再也不會出現(xiàn)添加新操作符后忘記添加對應的處理邏輯的情況了，因為編譯器就會提示我們必須覆蓋apply方法。

不過，這種特定于常量的方法實現(xiàn) 有一個缺點，那就是你很難在枚舉常量之間共享代碼。

我們以星期X的枚舉為例，周一到周五是工作日，執(zhí)行一種邏輯，周六周日，休息日，執(zhí)行另一種邏輯。

如果還是使用特定于常量的方法實現(xiàn)，寫出來的代碼可能就是這樣的：

public enum DayUseAbstractMethod { 
  MONDAY { 
    @Override 
    void apply() { 
      dealWithWeekDays();//偽代碼 
    } 
  }, 
  TUESDAY { 
    @Override 
    void apply() { 
      dealWithWeekDays();//偽代碼 
    } 
  }, 
  WEDNESDAY { 
    @Override 
    void apply() { 
      dealWithWeekDays();//偽代碼 
    } 
  }, 
  THURSDAY { 
    @Override 
    void apply() { 
      dealWithWeekDays();//偽代碼 
    } 
  }, 
  FRIDAY { 
    @Override 
    void apply() { 
      dealWithWeekDays();//偽代碼 
    } 
  }, 
  SATURDAY { 
    @Override 
    void apply() { 
      dealWithWeekEnds();//偽代碼 
    } 
  }, 
  SUNDAY { 
    @Override 
    void apply() { 
      dealWithWeekEnds();//偽代碼 
    } 
  }; 
 
  abstract void apply(); 
}

很明顯，我們這段代碼里面有相當多的重復代碼。

那么要怎么優(yōu)化呢，我們不妨這樣想，星期一星期二等等是一種枚舉，那么工作日和休息日，難道不也是一種枚舉嗎，我們能不能給Day的構(gòu)造函數(shù)傳入一個工作日休息日的DayType枚舉呢？這也就是書中給出的一種叫策略枚舉的方法，代碼如下：

public enum Day { 
  MONDAY(DayType.WEEKDAY), TUESDAY(DayType.WEEKDAY), WEDNESDAY( 
      DayType.WEEKDAY), THURSDAY(DayType.WEEKDAY), FRIDAY(DayType.WEEKDAY), SATURDAY( 
      DayType.WEEKDAY), SUNDAY(DayType.WEEKDAY); 
  private final DayType dayType; 
 
  Day(DayType daytype) { 
    this.dayType = daytype; 
  } 
 
  void apply() { 
    dayType.apply(); 
  } 
 
  private enum DayType { 
    WEEKDAY { 
      @Override 
      void apply() { 
        System.out.println("hi, weekday"); 
      } 
    }, 
    WEEKEND { 
      @Override 
      void apply() { 
        System.out.println("hi, weekend"); 
      } 
    }; 
    abstract void apply(); 
  } 
}

通過策略枚舉的方式，我們把Day的處理邏輯委托給了DayType，個中奧妙，讀者可以細細體會。

枚舉集合 EnumSet的使用

EnumSet提供了非常方便的方法來創(chuàng)建枚舉集合，下面這段代碼，感受一下

public class Text { 
  public enum Style { 
    BOLD, ITALIC, UNDERLINE, STRIKETHROUGH 
  } 
 
  // Any Set could be passed in, but EnumSet is clearly best 
  public void applyStyles(Set<Style> styles) { 
    // Body goes here 
    for(Style style : styles){ 
      System.out.println(style); 
    } 
  } 
 
  // Sample use 
  public static void main(String[] args) { 
    Text text = new Text(); 
    text.applyStyles(EnumSet.of(Style.BOLD, Style.ITALIC)); 
  } 
}

這個例子里，我們使用了EnumSet.of方法，輕松創(chuàng)建了枚舉集合。

枚舉Map EnumMap的使用

假設(shè)對于香草（Herb），有一個枚舉屬性Type(一年生、多年生、兩年生)

Herb:

public class Herb { 
  public enum Type { ANNUAL, PERENNIAL, BIENNIAL } 
 
  private final String name; 
  private final Type type; 
   
  Herb(String name, Type type) { 
    this.name = name; 
    this.type = type; 
  } 
 
  @Override public String toString() { 
    return name; 
  } 
}

現(xiàn)在，假設(shè)我們有一個Herb數(shù)組，我們需要對這個Herb數(shù)組按照Type進行分類存放。

所以接下來，我們需要創(chuàng)建一個Map，value肯定是Herb的集合了，那么用什么作為key呢？

有的人會使用枚舉類型的ordinal()方法，這個函數(shù)返回int類型，表示枚舉遍歷在枚舉類里的位置，這樣做，缺點很明顯，由于你的key的類型是int，不能保證傳入的int一定能和枚舉類里的變量對應上。

所以，在key的選擇上，毫無疑問，只能使用枚舉類型，也即Herb.Type。

最后還有一個問題，要使用什么Map? Java為枚舉類型專門提供了一種Map，叫EnumMap，相比較與其他Map，這種Map在處理枚舉類型上更快，有興趣的同學可以研究一下這個map的內(nèi)部實現(xiàn)。

下面讓我們看看怎么使用EnumMap：

public static void main(String[] args) { 
  Herb[] garden = { new Herb("Basil", Type.ANNUAL), 
      new Herb("Carroway", Type.BIENNIAL), 
      new Herb("Dill", Type.ANNUAL), 
      new Herb("Lavendar", Type.PERENNIAL), 
      new Herb("Parsley", Type.BIENNIAL), 
      new Herb("Rosemary", Type.PERENNIAL) }; 
 
  // Using an EnumMap to associate data with an enum - Page 162 
  Map<Herb.Type, Set<Herb>> herbsByType = new EnumMap<Herb.Type, Set<Herb>>( 
      Herb.Type.class); 
  for (Herb.Type t : Herb.Type.values()) 
    herbsByType.put(t, new HashSet<Herb>()); 
  for (Herb h : garden) 
    herbsByType.get(h.type).add(h); 
  System.out.println(herbsByType); 
 
}

總結(jié)

和int枚舉相比，Enum枚舉的在類型安全和使用便利上的優(yōu)勢是不言而喻的。
Enum為枚舉提供了豐富的功能，如文章中提到的特定于常量的方法實現(xiàn)和策略枚舉。
EnumSet和EnumMap是兩個為枚舉而設(shè)計的集合，在實際開發(fā)中，用到枚舉集合時，請優(yōu)先考慮這兩個。

如有疑問請留言或者到本站社區(qū)交流討論，感謝閱讀，希望能幫助到大家，謝謝大家對本站的支持！

向AI問一下細節(jié)

Java枚舉的使用方法詳解

猜你喜歡

最新資訊

相關(guān)推薦

相關(guān)標簽