本文結合《Effective Java》第六章前半部分關於枚舉的介紹和自己的理解及實踐，講解了Java枚舉的知識點。文章發佈於專欄Effective Java，歡迎讀者訂閱。

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

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

public class Constant {
	/*
	 * 以下幾個變量表示英雄的狀態
	 */
	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);

嗯，然後他們就說，“我在實際開發中很少用到枚舉”

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

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

爲什麼？

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

hero.setStatus(666);

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

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

枚舉初探爲什麼要使用枚舉類型

生活中處處都有枚舉，包括“天然的枚舉”，比如行星、一週的天數，也包括我們設計出來的枚舉，比如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，這是哪個行星估計也只有天知道了; 再者，我們很難計算出到底有多少個行星，我們也很難對行星進行遍歷操作等等。

現在我們用枚舉來創建我們的行星。

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

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

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

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
	}
}

//注：這裏對書中的代碼做了微調
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，打印結果如下：

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()方法，這個方法返回了枚舉類型裏的枚舉變量的集合，非常實用。

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

上一小節的例子裏，我們用到了枚舉類的公共方法，這一節，我們以計算器運算符 Operation 枚舉類爲例，看看怎麼實現對於每一個枚舉對象，執行不同的操作。

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

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);
	}
}

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

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

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

還好，Java枚舉提供了一種功能，叫做 特定於常量的方法實現。

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

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);
}

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

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

我們以星期X的枚舉爲例，週一到週五是工作日，執行一種邏輯，週六週日，休息日，執行另一種邏輯。

如果還是使用 特定於常量的方法實現，寫出來的代碼可能就是這樣的：

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();
}

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

那麼要怎麼優化呢，我們不妨這樣想，星期一星期二等等是一種枚舉，那麼工作日和休息日，難道不也是一種枚舉嗎，我們能不能給Day的構造函數傳入一個工作日休息日的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提供了非常方便的方法來創建枚舉集合，下面這段代碼，感受一下

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方法，輕鬆創建了枚舉集合。

枚舉Map EnumMap的使用

假設對於香草（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;
    }
}

現在，假設我們有一個Herb數組，我們需要對這個Herb數組按照Type進行分類存放。

所以接下來，我們需要創建一個Map，value肯定是Herb的集合了，那麼用什麼作爲key呢？

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

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

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

下面讓我們看看怎麼使用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);

}

總結

和int枚舉相比，Enum枚舉的在類型安全和使用便利上的優勢是不言而喻的。

Enum爲枚舉提供了豐富的功能，如文章中提到的特定於常量的方法實現和策略枚舉。

EnumSet和EnumMap是兩個爲枚舉而設計的集合，在實際開發中，用到枚舉集合時，請優先考慮這兩個。

參考文獻

《Effective Java》第二版

Java枚舉 —— 很少被使用，或許是因爲真正瞭解它的人太少了

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

枚舉初探爲什麼要使用枚舉類型

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

枚舉集合 EnumSet的使用

枚舉Map EnumMap的使用

總結

參考文獻

lightdb hash index的性能和限制

華爲OJ 高級題（一）鐵路棧問題

Java靜態工廠方法 —— 有了它，你還需要工廠模式嗎

Java hashcode方法編寫技巧 —— 記住這3條約定

Java 設計方法的五條優秀實踐清單

Java 比繼承更好的一種機制 —— 複合

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結

Java枚舉 —— 很少被使用，或許是因爲真正瞭解它的人太少了

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

枚舉初探 爲什麼要使用枚舉類型

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

枚舉集合 EnumSet的使用

枚舉Map EnumMap的使用

總結

參考文獻

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

枚舉初探爲什麼要使用枚舉類型

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