1. 首页
  2. 编程与技术

java中的枚举类型详细介绍

发布于 2016-07-06 06:59:01 | 110 次阅读 | 评论: 0 | 来源: 网友投递

这里有新鲜出炉的Java函数式编程，程序狗速度看过来！

Java程序设计语言

java 是一种可以撰写跨平台应用软件的面向对象的程序设计语言，是由Sun Microsystems公司于1995年5月推出的Java程序设计语言和Java平台（即JavaEE(j2ee), JavaME(j2me), JavaSE(j2se)）的总称。

枚举中有values方法用于按照枚举定义的顺序生成一个数组，可以用来历遍;接下来将详细介绍
枚举中有values方法用于按照枚举定义的顺序生成一个数组，可以用来历遍。我们自定义的枚举类都是继承自java.lang.Enum，拥有一下实例中的功能： 
 
//: enumerated/EnumClass.java 
// Capabilities of the Enum class 
import static net.mindview.util.Print.*; 
enum Shrubbery { GROUND, CRAWLING, HANGING } 
public class EnumClass { 
　　public static void main(String[] args) { 
　　　　for(Shrubbery s : Shrubbery.values()) { 
　　　　　　print(s + " ordinal: " + s.ordinal()); 
　　　　　　printnb(s.compareTo(Shrubbery.CRAWLING) + " "); 
　　　　　　printnb(s.equals(Shrubbery.CRAWLING) + " "); 
　　　　　　print(s == Shrubbery.CRAWLING); 
　　　　　　print(s.getDeclaringClass()); 
　　　　　　print(s.name()); 
　　　　　　print("----------------------"); 
　　　　} 
　　　　// Produce an enum value from a string name: 
　　　　for(String s : "HANGING CRAWLING GROUND".split(" ")) { 
　　　　　　Shrubbery shrub = Enum.valueOf(Shrubbery.class, s); 
　　　　　　print(shrub); 
　　　　} 
　　} 
} /* Output: 
GROUND ordinal: 0 
-1 false false 
class Shrubbery 
Joshua Bloch was extremely helpful in developing this chapter. 
GROUND 
---------------------- 
CRAWLING ordinal: 1 
true true 
class Shrubbery 
CRAWLING 
---------------------- 
HANGING ordinal: 2 
false false 
class Shrubbery 
HANGING 
---------------------- 
HANGING 
CRAWLING 
GROUND 
*///:~

我们还可以使用静态的枚举引用： 
 
//: enumerated/Spiciness.java 
package enumerated; 
public enum Spiciness {NOT, MILD, MEDIUM, HOT, FLAMING} ///:~ 
//: enumerated/Burrito.java 
package enumerated; 
import static enumerated.Spiciness.*; 
public class Burrito { 
　　Spiciness degree; 
　　public Burrito(Spiciness degree) { this.degree = degree;} 
　　public String toString() { return "Burrito is "+ degree;} 
　　public static void main(String[] args) { 
　　　　System.out.println(new Burrito(NOT)); 
　　　　System.out.println(new Burrito(MEDIUM)); 
　　　　System.out.println(new Burrito(HOT)); 
　　} 
} /* Output: 
Burrito is NOT 
Burrito is MEDIUM 
Burrito is HOT 
*///:~

向枚举添加方法
除了不能被继承之外，枚举可以当作一般的类来看待，这意味着可以向枚举添加方法，还可以在枚举中定义main方法： 
 
//: enumerated/OzWitch.java 
// The witches in the land of Oz. 
import static net.mindview.util.Print.*; 
public enum OzWitch { 
　　// Instances must be defined first, before methods: 
　　WEST("Miss Gulch, aka the Wicked Witch of the West"),NORTH("Glinda, the Good Witch of the North"),EAST("Wicked Witch of the East, wearer of the Ruby " + "Slippers, crushed by Dorothy's house"),SOUTH("Good by inference, but missing"); 
　　private String description; 
　　// Constructor must be package or private access: 
　　private OzWitch(String description) { 
　　　　this.description = description; 
　　} 
　　public String getDescription() { return description; } 
　　public static void main(String[] args) { 
　　　　for(OzWitch witch : OzWitch.values()) 
　　　　　　print(witch + ": " + witch.getDescription()); 
　　} 
} /* Output: 
WEST: Miss Gulch, aka the Wicked Witch of the West 
NORTH: Glinda, the Good Witch of the North 
EAST: Wicked Witch of the East, wearer of the Ruby Slippers, crushed by Dorothy's house 
SOUTH: Good by inference, but missing 
*///:~ 


 
//: enumerated/SpaceShip.java 
public enum SpaceShip { 
　　SCOUT, CARGO, TRANSPORT, CRUISER, BATTLESHIP, MOTHERSHIP; 
　　public String toString() { 
　　　　String id = name(); 
　　　　String lower = id.substring(1).toLowerCase(); 
　　　　return id.charAt(0) + lower; 
　　} 
　　public static void main(String[] args) { 
　　　　for(SpaceShip s : values()) { 
　　　　　　System.out.println(s); 
　　　　} 
　　} 
} /* Output: 
Scout 
Cargo 
Transport 
Cruiser 
Battleship 
Mothership 
*///:~

switch语句中的枚举
　　枚举的一种重要作用就是在switch语句中，通常switch语句仅对整型值起作用，但是枚举中有内置的整型顺序，因此实例的顺序可以通过某种方法获得，因此enums就可以在switch语句中使用： 
 
//: enumerated/TrafficLight.java 
// Enums in switch statements. 
import static net.mindview.util.Print.*; 
// Define an enum type: 
enum Signal { GREEN, YELLOW, RED, } 
　　public class TrafficLight { 
　　　　Signal color = Signal.RED; 
　　　　public void change() { 
　　　　switch(color) { 
　　　　　　// Note that you don't have to say Signal.RED 
　　　　　　// in the case statement: 
　　　　　　case RED: color = Signal.GREEN; 
　　　　　　　　　　　　break; 
　　　　　　case GREEN: color = Signal.YELLOW; 
　　　　　　　　　　　　break; 
　　　　　　case YELLOW: color = Signal.RED; 
　　　　　　　　　　　　break; 
　　　　} 
　　} 
　　public String toString() { 
　　　　return "The traffic light is " + color; 
　　} 
　　public static void main(String[] args) { 
　　　　TrafficLight t = new TrafficLight(); 
　　　　for(int i = 0; i < 7; i++) { 
　　　　　　print(t); 
　　　　　　t.change(); 
　　　　} 
　　} 
} /* Output: 
The traffic light is RED 
The traffic light is GREEN 
The traffic light is YELLOW 
The traffic light is RED 
The traffic light is GREEN 
The traffic light is YELLOW 
The traffic light is RED 
*///:~

values()的秘密
　　虽然我们之前使用了values方法，但是如果查看Enum，我们并没有发现values方法，那么是不是还有其他隐藏的方法呢？我们可以通过一个简单的反射代码来查看一下： 
 
//: enumerated/Reflection.java 
// Analyzing enums using reflection. 
import java.lang.reflect.*; 
import java.util.*; 
import net.mindview.util.*; 
import static net.mindview.util.Print.*; 
enum Explore { HERE, THERE } 
public class Reflection { 
　　public static Set<String> analyze(Class<?> enumClass) { 
　　　　print("----- Analyzing " + enumClass + " -----"); 
　　　　print("Interfaces:"); 
　　　　for(Type t : enumClass.getGenericInterfaces()) 
　　　　　　print(t); 
　　　　print("Base: " + enumClass.getSuperclass()); 
　　　　print("Methods: "); 
　　　　Set<String> methods = new TreeSet<String>(); 
　　　　for(Method m : enumClass.getMethods()) 
　　　　　　methods.add(m.getName()); 
　　　　print(methods); 
　　　　return methods; 
　　} 
　　public static void main(String[] args) { 
　　　　Set<String> exploreMethods = analyze(Explore.class); 
　　　　Set<String> enumMethods = analyze(Enum.class); 
　　　　print("Explore.containsAll(Enum)? " + 
　　　　exploreMethods.containsAll(enumMethods)); 
　　　　printnb("Explore.removeAll(Enum): "); 
　　　　exploreMethods.removeAll(enumMethods); 
　　　　print(exploreMethods); 
　　　　// Decompile the code for the enum: 
　　　　OSExecute.command("javap Explore"); 
　　} 
} /* Output: 
----- Analyzing class Explore ----- 
Interfaces: 
Base: class java.lang.Enum 
Methods: 
[compareTo, equals, getClass, getDeclaringClass, hashCode, name, notify, notifyAll, ordinal, toString, valueOf, values, wait] 
----- Analyzing class java.lang.Enum ----- 
Interfaces: 
java.lang.Comparable<E> 
interface java.io.Serializable 
Base: class java.lang.Object 
Methods: 
[compareTo, equals, getClass, getDeclaringClass, hashCode, name, notify, notifyAll, ordinal, toString, valueOf, wait] 
Explore.containsAll(Enum)? true 
Explore.removeAll(Enum): [values] 
Compiled from "Reflection.java" 
final class Explore extends java.lang.Enum{ 
public static final Explore HERE; 
public static final Explore THERE; 
public static final Explore[] values(); 
public static Explore valueOf(java.lang.String); 
static {}; 
} 
*///:~

我们可以看到values方法是被编译器添加的。valueOf方法也是在创建枚举的时候由编译器添加的，但是在Enum类中也有一个valueOf方法，但是这个方法有两个参数，而由编译器添加的valueOf方法只有一个参数。枚举被编译器解释为final，因此枚举不能被继承。因为values方法是被编译器添加的静态方法，因此如果你将枚举上塑造型到Enum的时候，values方法将会不可用，但是在Class中有getEnumConstants方法，因此虽然values方法在Enum中不可用，但是还是可以通过Class对象获取枚举的实例： 
 
//: enumerated/UpcastEnum.java 
// No values() method if you upcast an enum 
enum Search { HITHER, YON } 
public class UpcastEnum { 
　　public static void main(String[] args) { 
　　　　Search[] vals = Search.values(); 
　　　　Enum e = Search.HITHER; // Upcast 
　　　　// e.values(); // No values() in Enum 
　　　　for(Enum en : e.getClass().getEnumConstants()) 
　　　　　　System.out.println(en); 
　　} 
} /* Output: 
HITHER 
YON 
*///:~

实现而不继承
　　因为我们定义的枚举类型都继承自java.lang.Enum，而且Java又不支持多重继承，因此不同通过继承创建枚举，但是可以通过继承一个或多个接口创建枚举： 
 
//: enumerated/cartoons/EnumImplementation.java 
// An enum can implement an interface 
package enumerated.cartoons; 
import java.util.*; 
import net.mindview.util.*; 
enum CartoonCharacter implements Generator<CartoonCharacter> { 
　　SLAPPY, SPANKY, PUNCHY, SILLY, BOUNCY, NUTTY, BOB; 
　　private Random rand = new Random(47); 
　　public CartoonCharacter next() { 
　　　　return values()[rand.nextInt(values().length)]; 
　　} 
} 
public class EnumImplementation { 
　　public static <T> void printNext(Generator<T> rg) { 
　　　　System.out.print(rg.next() + ", "); 
　　} 
　　public static void main(String[] args) { 
　　　　// Choose any instance: 
　　　　CartoonCharacter cc = CartoonCharacter.BOB; 
　　　　for(int i = 0; i < 10; i++) 
　　　　　　printNext(cc); 
　　} 
} /* Output: 
BOB, PUNCHY, BOB, SPANKY, NUTTY, PUNCHY, SLAPPY, NUTTY, NUTTY, SLAPPY, 
*///:~

随机选取
　　后面我们很多例子中都会用到从枚举实例中随机选取对象，我们创建一个公用类来实现： 
 
//: net/mindview/util/Enums.java 
package net.mindview.util; 
import java.util.*; 
public class Enums { 
　　private static Random rand = new Random(47); 
　　public static <T extends Enum<T>> T random(Class<T> ec) { 
　　　　return random(ec.getEnumConstants()); 
　　} 
　　public static <T> T random(T[] values) { 
　　　　return values[rand.nextInt(values.length)]; 
　　} 
} ///:~ 


 
//: enumerated/RandomTest.java 
import net.mindview.util.*; 
enum Activity { SITTING, LYING, STANDING, HOPPING, RUNNING, DODGING, JUMPING, FALLING, FLYING } 
public class RandomTest { 
　　public static void main(String[] args) { 
　　　　for(int i = 0; i < 20; i++) 
　　　　　　System.out.print(Enums.random(Activity.class) + " "); 
　　} 
} /* Output: 
STANDING FLYING RUNNING STANDING RUNNING STANDING LYING DODGING SITTING RUNNING HOPPING HOPPING HOPPING RUNNING STANDING LYING FALLING RUNNING FLYING LYING 
*///:~

使用接口进行组织
　　枚举不能被继承，这一点有时候会给我们造成不方便，因为有些时候我们想要通过继承来扩展枚举的数量，有些时候我们需要对枚举进行分组。对于后者我们可以通过在接口内定义分组的枚举，然后在通过继承自这个接口来创建枚举，如下我们有不同的食物类需要创建为枚举，但是我们又需要将每个种类定义为Food的类型，如下： 
 
//: enumerated/menu/Food.java 
// Subcategorization of enums within interfaces. 
package enumerated.menu; 
public interface Food {enum Appetizer implements Food {SALAD, SOUP, SPRING_ROLLS;} 
　　enum MainCourse implements Food {LASAGNE, BURRITO, PAD_THAI,LENTILS, HUMMOUS, VINDALOO;} 
　　enum Dessert implements Food {TIRAMISU, GELATO, BLACK_FOREST_CAKE,FRUIT, CREME_CARAMEL;} 
　　enum Coffee implements Food {BLACK_COFFEE, DECAF_COFFEE, ESPRESSO,LATTE, CAPPUCCINO, TEA, HERB_TEA;} 
} ///:~

因为每个枚举都定义为接口的实现，因此每个枚举都是Food类型，如下： 
 
//: enumerated/menu/TypeOfFood.java 
package enumerated.menu; 
import static enumerated.menu.Food.*; 
public class TypeOfFood { 
　　public static void main(String[] args) { 
　　　　Food food = Appetizer.SALAD; 
　　　　food = MainCourse.LASAGNE; 
　　　　food = Dessert.GELATO; 
　　　　food = Coffee.CAPPUCCINO; 
　　} 
} ///:~

但是接口不能像枚举一样操作多种类型，因此如果你需要一个枚举的枚举，那么你可以在一个枚举里面封装每个枚举类型的一个实例： 
 
//: enumerated/menu/Course.java 
package enumerated.menu; 
import net.mindview.util.*; 
public enum Course { 
　　APPETIZER(Food.Appetizer.class),MAINCOURSE(Food.MainCourse.class),DESSERT(Food.Dessert.class),COFFEE(Food.Coffee.class); 
　　private Food[] values; 
　　private Course(Class<? extends Food> kind) { 
　　　　values = kind.getEnumConstants(); 
　　} 
　　public Food randomSelection() { 
　　　　return Enums.random(values); 
　　} 
} ///:~

每个枚举使用了Class对象作为对应的构造器参数，我们就可以从这个参数里面使用getEnumConstants来获得枚举实例，这个实例可以用在randomSelection方法中生成随机的餐点： 
 
//: enumerated/menu/Meal.java 
package enumerated.menu; 
public class Meal { 
　　public static void main(String[] args) { 
　　　　for(int i = 0; i < 5; i++) { 
　　　　　　for(Course course : Course.values()) { 
　　　　　　　　Food food = course.randomSelection(); 
　　　　　　　　System.out.println(food); 
　　　　　　} 
　　　　　　System.out.println("---"); 
　　　　} 
　　} 
} /* Output: 
SPRING_ROLLS 
VINDALOO 
FRUIT 
DECAF_COFFEE 
--- 
SOUP 
VINDALOO 
FRUIT 
TEA 
--- 
SALAD 
BURRITO 
FRUIT 
TEA 
--- 
SALAD 
BURRITO 
CREME_CARAMEL 
LATTE 
--- 
SOUP 
BURRITO 
TIRAMISU 
ESPRESSO 
--- 
*///:~

下面是一种更加紧凑的实现方法： 
 
//: enumerated/SecurityCategory.java 
// More succinct subcategorization of enums. 
import net.mindview.util.*; 
enum SecurityCategory { 
　　STOCK(Security.Stock.class), BOND(Security.Bond.class); 
　　Security[] values; 
　　SecurityCategory(Class<? extends Security> kind) { 
　　　　values = kind.getEnumConstants(); 
　　} 
　　interface Security { 
　　　　enum Stock implements Security { SHORT, LONG, MARGIN } 
　　　　enum Bond implements Security { MUNICIPAL, JUNK } 
　　} 
　　public Security randomSelection() { 
　　　　return Enums.random(values); 
　　} 
　　public static void main(String[] args) { 
　　　　for(int i = 0; i < 10; i++) { 
　　　　　　SecurityCategory category = Enums.random(SecurityCategory.class); 
　　　　　　System.out.println(category + ": " + 
　　　　　　category.randomSelection()); 
　　　　} 
　　} 
} /* Output: 
BOND: MUNICIPAL 
BOND: MUNICIPAL 
STOCK: MARGIN 
STOCK: MARGIN 
BOND: JUNK 
STOCK: SHORT 
STOCK: LONG 
STOCK: LONG 
BOND: MUNICIPAL 
BOND: JUNK 
*///:~ 


 
//: enumerated/menu/Meal2.java 
package enumerated.menu; 
import net.mindview.util.*; 
public enum Meal2 { 
　　APPETIZER(Food.Appetizer.class),MAINCOURSE(Food.MainCourse.class),DESSERT(Food.Dessert.class),COFFEE(Food.Coffee.class); 
　　private Food[] values; 
　　private Meal2(Class<? extends Food> kind) { 
　　　　values = kind.getEnumConstants(); 
　　} 
　　public interface Food { 
　　　　enum Appetizer implements Food {SALAD, SOUP, SPRING_ROLLS;} 
　　　　enum MainCourse implements Food {LASAGNE, BURRITO, PAD_THAI,LENTILS, HUMMOUS, VINDALOO;} 
　　　　enum Dessert implements Food {TIRAMISU, GELATO, BLACK_FOREST_CAKE,FRUIT, CREME_CARAMEL;} 
　　　　enum Coffee implements Food {BLACK_COFFEE, DECAF_COFFEE, ESPRESSO,LATTE, CAPPUCCINO, TEA, HERB_TEA;} 
　　} 
　　public Food randomSelection() { 
　　　　return Enums.random(values); 
　　} 
　　public static void main(String[] args) { 
　　　　for(int i = 0; i < 5; i++) { 
　　　　　　for(Meal2 meal : Meal2.values()) { 
　　　　　　　　Food food = meal.randomSelection(); 
　　　　　　　　System.out.println(food); 
　　　　　　} 
　　　　　　System.out.println("---"); 
　　　　} 
　　} 
} /* Same output as Meal.java *///:~

使用EnumSet而不是标志位
　　在Java SE5中添加了EnumSet来将枚举和Set组合用于替换基于整型的位标志。位标志通常用来指示某种信息的开关，但是在代码中是对位进行操作而不是有意义的概念，因此不容易理解。EnumSet的效率比位标志要快，在内部使用long性表示一个位向量，然后就可以使用更加概念化的语言来表示某个位的开关，而不用担心效率。EnumSet中的元素必须来自同一个枚举，下面定义一个报警器位置的枚举： 
 
//: enumerated/AlarmPoints.java 
package enumerated; 
public enum AlarmPoints {STAIR1, STAIR2, LOBBY, OFFICE1, OFFICE2, OFFICE3,OFFICE4, BATHROOM, UTILITY, KITCHEN} ///:~

然后使用EnumSet类跟踪报警的状态： 
 
//: enumerated/EnumSets.java 
// Operations on EnumSets 
package enumerated; 
import java.util.*; 
import static enumerated.AlarmPoints.*; 
import static net.mindview.util.Print.*; 
public class EnumSets { 
　　public static void main(String[] args) { 
　　　　EnumSet<AlarmPoints> points = EnumSet.noneOf(AlarmPoints.class); // Empty set 
　　　　points.add(BATHROOM); 
　　　　print(points); 
　　　　points.addAll(EnumSet.of(STAIR1, STAIR2, KITCHEN)); 
　　　　print(points); 
　　　　points = EnumSet.allOf(AlarmPoints.class); 
　　　　points.removeAll(EnumSet.of(STAIR1, STAIR2, KITCHEN)); 
　　　　print(points); 
　　　　points.removeAll(EnumSet.range(OFFICE1, OFFICE4)); 
　　　　print(points); 
　　　　points = EnumSet.complementOf(points); 
　　　　print(points); 
　　} 
} /* Output: 
[BATHROOM] 
[STAIR1, STAIR2, BATHROOM, KITCHEN] 
[LOBBY, OFFICE1, OFFICE2, OFFICE3, OFFICE4, BATHROOM, UTILITY] 
[LOBBY, BATHROOM, UTILITY] 
[STAIR1, STAIR2, OFFICE1, OFFICE2, OFFICE3, OFFICE4, KITCHEN] 
*///:~

EnumSet是建立在long型上的，有64位，那么如果我们的枚举类型超过了这个数字呢？ 
 
//: enumerated/BigEnumSet.java 
import java.util.*; 
public class BigEnumSet { 
　　enum Big { A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10,A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21,A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, 
A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43,A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54,A55, A56, A57, A58, A59, A60, A61, A62, A63, A64, A65, 
A66, A67, A68, A69, A70, A71, A72, A73, A74, A75 } 
　　public static void main(String[] args) { 
　　　　EnumSet<Big> bigEnumSet = EnumSet.allOf(Big.class); 
　　　　System.out.println(bigEnumSet); 
　　} 
} /* Output: 
[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64, A65, A66, A67, A68, A69, A70, A71, A72, A73, A74, A75] 
*///:~

我们可以看到程序正常运行，那么很有可能是内部又添加了一个long型来帮助容纳枚举类型
使用EnumMap
　　EnumMap是一种特殊类型的Map，他的键的值只能是同一个枚举中的类型，因为这一点在内部可以通过数组来实现EnumMap，效率非常高。 
 
//: enumerated/EnumMaps.java 
// Basics of EnumMaps. 
package enumerated; 
import java.util.*; 
import static enumerated.AlarmPoints.*; 
import static net.mindview.util.Print.*; 
interface Command { void action(); } 
public class EnumMaps { 
　　public static void main(String[] args) { 
　　　　EnumMap<AlarmPoints,Command> em = new EnumMap<AlarmPoints,Command>(AlarmPoints.class); 
　　　　em.put(KITCHEN, new Command() { 
　　　　　　public void action() { print("Kitchen fire!"); } 
　　　　}); 
　　　　em.put(BATHROOM, new Command() { 
　　　　　　public void action() { print("Bathroom alert!"); } 
　　　　}); 
　　　　for(Map.Entry<AlarmPoints,Command> e : em.entrySet()) { 
　　　　　　printnb(e.getKey() + ": "); 
　　　　　　e.getValue().action(); 
　　　　} 
　　　　try { // If there's no value for a particular key: 
　　　　　　em.get(UTILITY).action(); 
　　　　} catch(Exception e) { 
　　　　　　print(e); 
　　　　} 
　　} 
} /* Output: 
BATHROOM: Bathroom alert! 
KITCHEN: Kitchen fire! 
java.lang.NullPointerException 
*///:~

特定常量方法
　　Java的枚举有一个非常有趣的特性，那就是可以为每一个枚举实例定义不同的行为，为了实现这一点，我们定义一个或者多个抽象方法作为枚举的一部分，然后为每个枚举实例定义方法： 
 
//: enumerated/ConstantSpecificMethod.java 
import java.util.*; 
import java.text.*; 
public enum ConstantSpecificMethod { 
　　DATE_TIME {String getInfo() {return DateFormat.getDateInstance().format(new Date());}}, 
　　CLASSPATH {String getInfo() {return System.getenv("CLASSPATH");}}, 
VERSION {String getInfo() {return System.getProperty("java.version");}}; 
　　abstract String getInfo(); 
　　public static void main(String[] args) { 
　　　　for(ConstantSpecificMethod csm : values()) 
　　　　　　System.out.println(csm.getInfo()); 
　　} 
} /* (Execute to see output) *///:~

上面的代码卡起来似乎是每个枚举元素都是不同的元素，而所有的元素都继承自ConstantSpecificMethod基类，但是我们不能真的这样理解，因为我们不能将枚举元素当作类型来看待： 
 
//: enumerated/NotClasses.java 
// {Exec: javap -c LikeClasses} 
import static net.mindview.util.Print.*; 
enum LikeClasses {WINKEN { void behavior() { print("Behavior1"); } },BLINKEN { void behavior() { print("Behavior2"); } },NOD { void behavior() { print("Behavior3"); } }; 
　　abstract void behavior(); 
} 
public class NotClasses { 
　　// void f1(LikeClasses.WINKEN instance) {} // Nope 
} /* Output: 
Compiled from "NotClasses.java" 
abstract class LikeClasses extends java.lang.Enum{ 
public static final LikeClasses WINKEN; 
public static final LikeClasses BLINKEN; 
public static final LikeClasses NOD; 
... 
*///:~

考虑另外一个例子，有一个洗车的菜单，客户根据不同的菜单选择不同的服务，可以使用特定常量方法来将菜单与服务相关联，使用EnumSet来维护客户的选择，如下： 
 
//: enumerated/CarWash.java 
import java.util.*; 
import static net.mindview.util.Print.*; 
public class CarWash { 
　　public enum Cycle {UNDERBODY {void action() { print("Spraying the underbody"); }}, 
WHEELWASH {void action() { print("Washing the wheels"); }}, 
　　　　　　　　 PREWASH {void action() { print("Loosening the dirt"); }}, 
　　　　　　　　 BASIC {void action() { print("The basic wash"); }}, 
　　　　　　　　 HOTWAX {void action() { print("Applying hot wax"); }}, 
　　　　　　　　 RINSE {void action() { print("Rinsing"); }}, 
　　　　　　　　 BLOWDRY {void action() { print("Blowing dry"); }}; 
　　　　　　　　　abstract void action(); 
　　} 
　　EnumSet<Cycle> cycles = EnumSet.of(Cycle.BASIC, Cycle.RINSE); 
　　public void add(Cycle cycle) { cycles.add(cycle); } 
　　public void washCar() { 
　　　　for(Cycle c : cycles) 
　　　　　　c.action(); 
　　} 
　　public String toString() { return cycles.toString(); } 
　　public static void main(String[] args) { 
　　　　CarWash wash = new CarWash(); 
　　　　print(wash); 
　　　　wash.washCar(); 
　　　　// Order of addition is unimportant: 
　　　　wash.add(Cycle.BLOWDRY); 
　　　　wash.add(Cycle.BLOWDRY); // Duplicates ignored 
　　　　wash.add(Cycle.RINSE); 
　　　　wash.add(Cycle.HOTWAX); 
　　　　print(wash); 
　　　　wash.washCar(); 
　　} 
} /* Output: 
[BASIC, RINSE] 
The basic wash 
Rinsing 
[BASIC, HOTWAX, RINSE, BLOWDRY] 
The basic wash 
Applying hot wax 
Rinsing 
Blowing dry 
*///:~

我们还可以对默认的特定常量方法进行重写，而不是使用继承抽象方法，如下： 
 
//: enumerated/OverrideConstantSpecific.java 
import static net.mindview.util.Print.*; 
public enum OverrideConstantSpecific { 
　　NUT, BOLT,WASHER {void f() { print("Overridden method"); }}; 
　　void f() { print("default behavior"); } 
　　public static void main(String[] args) { 
　　　　for(OverrideConstantSpecific ocs : values()) { 
　　　　　　printnb(ocs + ": "); 
　　　　　　ocs.f(); 
　　　　} 
　　} 
} /* Output: 
NUT: default behavior 
BOLT: default behavior 
WASHER: Overridden method 
*///:~

有些时候我们希望对特定的请求在链条中进行传递，知道链条中的某个对象能够处理请求，使用特定常量方法可以很轻松的实现，如下是一个处理邮件的实例： 
 
//: enumerated/PostOffice.java 
// Modeling a post office. 
Enumerated Types 743 
import java.util.*; 
import net.mindview.util.*; 
import static net.mindview.util.Print.*; 
class Mail { 
　　// The NO's lower the probability of random selection: 
　　enum GeneralDelivery {YES,NO1,NO2,NO3,NO4,NO5} 
　　enum Scannability {UNSCANNABLE,YES1,YES2,YES3,YES4} 
　　enum Readability {ILLEGIBLE,YES1,YES2,YES3,YES4} 
　　enum Address {INCORRECT,OK1,OK2,OK3,OK4,OK5,OK6} 
　　enum ReturnAddress {MISSING,OK1,OK2,OK3,OK4,OK5} 
　　GeneralDelivery generalDelivery; 
　　Scannability scannability; 
　　Readability readability; 
　　Address address; 
　　ReturnAddress returnAddress; 
　　static long counter = 0; 
　　long id = counter++; 
　　public String toString() { return "Mail " + id; } 
　　public String details() { 
　　return toString() + ", General Delivery: " + generalDelivery + ", Address Scanability: " + scannability + ", Address Readability: " + readability + 
", Address Address: " + address + ", Return address: " + returnAddress; 
　　} 
　　// Generate test Mail: 
　　public static Mail randomMail() { 
　　　　Mail m = new Mail(); 
　　　　m.generalDelivery= Enums.random(GeneralDelivery.class); 
　　　　m.scannability = Enums.random(Scannability.class); 
　　　　m.readability = Enums.random(Readability.class); 
　　　　m.address = Enums.random(Address.class); 
　　　　m.returnAddress = Enums.random(ReturnAddress.class); 
　　　　return m; 
　　} 
　　public static Iterable<Mail> generator(final int count) { 
　　　　return new Iterable<Mail>() { 
　　　　　　int n = count; 
　　　　　　public Iterator<Mail> iterator() { 
　　　　　　　　return new Iterator<Mail>() { 
　　　　　　　　　　public boolean hasNext() { return n-- > 0; } 
　　　　　　　　　　public Mail next() { return randomMail(); } 
　　　　　　　　　　public void remove() { // Not implemented 
　　　　　　　　　　　　throw new UnsupportedOperationException(); 
　　　　　　　　　　} 
　　　　　　　　}; 
　　　　　　} 
　　　　}; 
　　} 
} 
public class PostOffice { 
　　enum MailHandler { 
　　　　GENERAL_DELIVERY { 
　　　　　　boolean handle(Mail m) { 
　　　　　　　　switch(m.generalDelivery) { 
　　　　　　　　　　case YES: 
　　　　　　　　　　　　print("Using general delivery for " + m); 
　　　　　　　　　　　　return true; 
　　　　　　　　　　default: return false; 
　　　　　　　　} 
　　　　　　} 
　　　　}, 
　　　　MACHINE_SCAN { 
　　　　　　boolean handle(Mail m) { 
　　　　　　　　switch(m.scannability) { 
　　　　　　　　　　case UNSCANNABLE: return false; 
　　　　　　　　　　default: 
　　　　　　　　　　　　switch(m.address) { 
　　　　　　　　　　　　　　case INCORRECT: return false; 
　　　　　　　　　　　　　　default: 
　　　　　　　　　　　　　　　　print("Delivering "+ m + " automatically"); 
　　　　　　　　　　　　　　return true; 
　　　　　　　　　　　　} 
　　　　　　　　} 
　　　　　　} 
　　　　}, 
　　　　VISUAL_INSPECTION { 
　　　　　　boolean handle(Mail m) { 
　　　　　　　　switch(m.readability) { 
　　　　　　　　　　case ILLEGIBLE: return false; 
　　　　　　　　　　default: 
　　　　　　　　　　　　switch(m.address) { 
　　　　　　　　　　　　　　case INCORRECT: return false; 
　　　　　　　　　　　　　　default: 
　　　　　　　　　　　　　　　　print("Delivering " + m + " normally"); 
　　　　　　　　　　　　　　return true; 
　　　　　　　　　　　　} 
　　　　　　　　} 
　　　　　　} 
　　　　}, 
　　　　RETURN_TO_SENDER { 
　　　　　　boolean handle(Mail m) { 
　　　　　　　　switch(m.returnAddress) { 
　　　　　　　　　　case MISSING: return false; 
　　　　　　　　　　default: 
　　　　　　　　　　　　print("Returning " + m + " to sender"); 
　　　　　　　　　　return true; 
　　　　　　　　} 
　　　　　　} 
　　　　}; 
　　　　abstract boolean handle(Mail m); 
　　} 
　　static void handle(Mail m) { 
　　　　for(MailHandler handler : MailHandler.values()) 
　　　　　　if(handler.handle(m)) 
　　　　　　　　return; 
　　　　print(m + " is a dead letter"); 
　　} 
　　public static void main(String[] args) { 
　　　　for(Mail mail : Mail.generator(10)) { 
　　　　　　print(mail.details()); 
　　　　　　handle(mail); 
　　　　　　print("*****"); 
　　　　} 
　　} 
} /* Output: 
Mail 0, General Delivery: NO2, Address Scanability: UNSCANNABLE, Address Readability: YES3, Address Address: OK1, Return address: OK1 
Delivering Mail 0 normally 
***** 
Mail 1, General Delivery: NO5, Address Scanability: YES3, Address Readability: ILLEGIBLE, Address Address: OK5, Return address: OK1 
Delivering Mail 1 automatically 
***** 
Mail 2, General Delivery: YES, Address Scanability: YES3, Address Readability: YES1, Address Address: OK1, Return address: OK5 
Using general delivery for Mail 2 
***** 
Mail 3, General Delivery: NO4, Address Scanability: YES3, Address Readability: YES1, Address Address: INCORRECT, Return address: OK4 
Returning Mail 3 to sender 
***** 
Mail 4, General Delivery: NO4, Address Scanability: UNSCANNABLE, Address Readability: YES1, Address Address: INCORRECT, Return address: OK2 
Returning Mail 4 to sender 
***** 
Mail 5, General Delivery: NO3, Address Scanability: YES1, Address Readability: ILLEGIBLE, Address Address: OK4, Return address: OK2 
Delivering Mail 5 automatically 
***** 
Mail 6, General Delivery: YES, Address Scanability: YES4, Address Readability: ILLEGIBLE, Address Address: OK4, Return address: OK4 
Using general delivery for Mail 6 
***** 
Mail 7, General Delivery: YES, Address Scanability: YES3, Address Readability: YES4, Address Address: OK2, Return address: MISSING 
Using general delivery for Mail 7 
***** 
Mail 8, General Delivery: NO3, Address Scanability: YES1, Address Readability: YES3, Address Address: INCORRECT, Return address: MISSING 
Mail 8 is a dead letter 
***** 
Mail 9, General Delivery: NO1, Address Scanability: UNSCANNABLE, Address Readability: YES2, Address Address: OK1, Return address: OK4 
Delivering Mail 9 normally 
***** 
*///:~

枚举类型还是创建状态机的理想类型，一个状态机可以根据输入在有限个状态之间移动，然后在满足某种状态之后结束工作，另外每个状态都会有相应的输出，一个售货机器是一个典型的状态机的实例，我们在枚举内定义不同的输入： 
 
//: enumerated/Input.java 
package enumerated; 
import java.util.*; 
public enum Input { 
　　NICKEL(5), DIME(10), QUARTER(25), DOLLAR(100),TOOTHPASTE(200), CHIPS(75), SODA(100), SOAP(50),ABORT_TRANSACTION { 
　　　　public int amount() { // Disallow 
　　　　　　throw new RuntimeException("ABORT.amount()"); 
　　　　} 
　　}, 
　　STOP { // This must be the last instance. 
　　　　public int amount() { // Disallow 
　　　　　　throw new RuntimeException("SHUT_DOWN.amount()"); 
　　　　} 
　　}; 
　　int value; // In cents 
　　Input(int value) { this.value = value; } 
　　Input() {} 
　　int amount() { return value; }; // In cents 
　　static Random rand = new Random(47); 
　　public static Input randomSelection() { 
　　　　// Don't include STOP: 
　　　　return values()[rand.nextInt(values().length - 1)]; 
　　} 
} ///:~

VendingMachine用来对输入进行相应，首先通过Category枚举归类输入，然后使用switch语句： 
 
//: enumerated/VendingMachine.java 
// {Args: VendingMachineInput.txt} 
package enumerated; 
import java.util.*; 
import net.mindview.util.*; 
import static enumerated.Input.*; 
import static net.mindview.util.Print.*; 
enum Category { 
　　MONEY(NICKEL, DIME, QUARTER, DOLLAR),ITEM_SELECTION(TOOTHPASTE, CHIPS, SODA, SOAP),QUIT_TRANSACTION(ABORT_TRANSACTION),SHUT_DOWN(STOP); 
　　private Input[] values; 
　　Category(Input... types) { values = types; } 
　　private static EnumMap<Input,Category> categories = new EnumMap<Input,Category>(Input.class); 
　　static { 
　　　　for(Category c : Category.class.getEnumConstants()) 
　　　　　　for(Input type : c.values) 
　　　　　　　　categories.put(type, c); 
　　} 
　　public static Category categorize(Input input) { 
　　　　return categories.get(input); 
　　} 
} 
public class VendingMachine { 
　　private static State state = State.RESTING; 
　　private static int amount = 0; 
　　private static Input selection = null; 
　　enum StateDuration { TRANSIENT } // Tagging enum 
　　enum State { 
　　　　RESTING { 
　　　　　　void next(Input input) { 
　　　　　　　　switch(Category.categorize(input)) { 
　　　　　　　　　　case MONEY: 
　　　　　　　　　　　　amount += input.amount(); 
　　　　　　　　　　　　state = ADDING_MONEY; 
　　　　　　　　　　　　break; 
　　　　　　　　　　case SHUT_DOWN: 
　　　　　　　　　　　　state = TERMINAL; 
　　　　　　　　　　default: 
　　　　　　　　} 
　　　　　　} 
　　　　}, 
　　　　ADDING_MONEY { 
　　　　　　void next(Input input) { 
　　　　　　　　switch(Category.categorize(input)) { 
　　　　　　　　　　case MONEY: 
　　　　　　　　　　　　amount += input.amount(); 
　　　　　　　　　　　　break; 
　　　　　　　　　　case ITEM_SELECTION: 
　　　　　　　　　　　　selection = input; 
　　　　　　　　　　　　if(amount < selection.amount()) 
　　　　　　　　　　　　　　print("Insufficient money for " + selection); 
　　　　　　　　　　　　else state = DISPENSING; 
　　　　　　　　　　　　　　break; 
　　　　　　　　　　case QUIT_TRANSACTION: 
　　　　　　　　　　　　state = GIVING_CHANGE; 
　　　　　　　　　　　　break; 
　　　　　　　　　　case SHUT_DOWN: 
　　　　　　　　　　　　state = TERMINAL; 
　　　　　　　　　　　　default: 
　　　　　　　　} 
　　　　　　} 
　　　　}, 
　　　　DISPENSING(StateDuration.TRANSIENT) { 
　　　　　　void next() { 
　　　　　　　　print("here is your " + selection); 
　　　　　　　　amount -= selection.amount(); 
　　　　　　　　state = GIVING_CHANGE; 
　　　　　　} 
　　　　}, 
　　　　GIVING_CHANGE(StateDuration.TRANSIENT) { 
　　　　　　void next() { 
　　　　　　　　if(amount > 0) { 
　　　　　　　　　　print("Your change: " + amount); 
　　　　　　　　　　amount = 0; 
　　　　　　　　} 
　　　　　　　　state = RESTING; 
　　　　　　} 
　　　　}, 
　　　　TERMINAL { void output() { print("Halted"); } }; 
　　　　private boolean isTransient = false; 
　　　　State() {} 
　　　　State(StateDuration trans) { isTransient = true; } 
　　　　void next(Input input) { 
　　　　　　throw new RuntimeException("Only call " + "next(Input input) for non-transient states"); 
　　　　} 
　　　　void next() { 
　　　　　　throw new RuntimeException("Only call next() for " + "StateDuration.TRANSIENT states"); 
　　　　} 
　　　　void output() { print(amount); } 
　　} 
　　static void run(Generator<Input> gen) { 
　　　　while(state != State.TERMINAL) { 
　　　　　　state.next(gen.next()); 
　　　　　　while(state.isTransient) 
　　　　　　　　state.next(); 
　　　　　　state.output(); 
　　　　} 
　　} 
　　public static void main(String[] args) { 
　　　　Generator<Input> gen = new RandomInputGenerator(); 
　　　　if(args.length == 1) 
　　　　　　gen = new FileInputGenerator(args[0]); 
　　　　run(gen); 
　　} 
} 
// For a basic sanity check: 
class RandomInputGenerator implements Generator<Input> { 
　　public Input next() { return Input.randomSelection(); } 
} 
// Create Inputs from a file of ‘;'-separated strings: 
class FileInputGenerator implements Generator<Input> { 
　　private Iterator<String> input; 
　　public FileInputGenerator(String fileName) { 
　　　　input = new TextFile(fileName, ";").iterator(); 
　　} 
　　public Input next() { 
　　　　if(!input.hasNext()) 
　　　　　　return null; 
　　　　return Enum.valueOf(Input.class, input.next().trim()); 
　　} 
} /* Output: 
here is your CHIPS 
here is your TOOTHPASTE 
Your change: 35 
Insufficient money for SODA 

Insufficient money for SODA 
Your change: 75 
Halted 
*///:~

下面是用来生成上面输出的测试数据： 
 
QUARTER; QUARTER; QUARTER; CHIPS; 
DOLLAR; DOLLAR; TOOTHPASTE; 
QUARTER; DIME; ABORT_TRANSACTION; 
QUARTER; DIME; SODA; 
QUARTER; DIME; NICKEL; SODA; 
ABORT_TRANSACTION; 
STOP; 
///:~

多重拆封
　　当处理多个类型之间的交互的时候代码很有可能变得杂乱，例如Number.plush(Number),Number.mutiply(Number)等，Number仅仅是个家族的基类，那么当你调用a.plus(b)的时候，你既不知道a的类型也不知道b的类型，那么如何保证他们之间的交互正确呢？Java只能执行单重拆封，也就是如果在执行多个未知类型的一个或者多个操作的时候，Java只能对其中的一个类型执行动态绑定机制，这样不能解决我们上面谈到的问题，因此不得不手动书写动态绑定的代码。
　　解决方案是使用多重绑定。多态只能在调用方法的时候发生，因此如果你需要多重拆封，必须调用多个方法。通过多重拆封，你必须有一个虚方法来调用每个类型的方法来进行拆封。下面的例子是一个剪刀石头布的实例： 
 
//: enumerated/Outcome.java 
package enumerated; 
public enum Outcome { WIN, LOSE, DRAW } ///:~ 
//: enumerated/RoShamBo1.java 
// Demonstration of multiple dispatching. 
package enumerated; 
import java.util.*; 
import static enumerated.Outcome.*; 
interface Item { 
　　Outcome compete(Item it); 
　　Outcome eval(Paper p); 
　　Outcome eval(Scissors s); 
　　Outcome eval(Rock r); 
} 
class Paper implements Item { 
　　public Outcome compete(Item it) { return it.eval(this); } 
　　public Outcome eval(Paper p) { return DRAW; } 
　　public Outcome eval(Scissors s) { return WIN; } 
　　public Outcome eval(Rock r) { return LOSE; } 
　　public String toString() { return "Paper"; } 
} 
class Scissors implements Item { 
　　public Outcome compete(Item it) { return it.eval(this); } 
　　public Outcome eval(Paper p) { return LOSE; } 
　　public Outcome eval(Scissors s) { return DRAW; } 
　　public Outcome eval(Rock r) { return WIN; } 
　　public String toString() { return "Scissors"; } 
} 
class Rock implements Item { 
　　public Outcome compete(Item it) { return it.eval(this); } 
　　public Outcome eval(Paper p) { return WIN; } 
　　public Outcome eval(Scissors s) { return LOSE; } 
　　public Outcome eval(Rock r) { return DRAW; } 
　　public String toString() { return "Rock"; } 
} 
public class RoShamBo1 { 
　　static final int SIZE = 20; 
　　private static Random rand = new Random(47); 
　　public static Item newItem() { 
　　　　switch(rand.nextInt(3)) { 
　　　　　　default: 
　　　　　　case 0: return new Scissors(); 
　　　　　　case 1: return new Paper(); 
　　　　　　case 2: return new Rock(); 
　　　　} 
　　} 
　　public static void match(Item a, Item b) { 
　　　　System.out.println(a + " vs. " + b + ": " + a.compete(b)); 
　　} 
　　public static void main(String[] args) { 
　　　　for(int i = 0; i < SIZE; i++) 
　　　　　　match(newItem(), newItem()); 
　　} 
} /* Output: 
Rock vs. Rock: DRAW 
Paper vs. Rock: WIN 
Paper vs. Rock: WIN 
Paper vs. Rock: WIN 
Scissors vs. Paper: WIN 
Scissors vs. Scissors: DRAW 
Scissors vs. Paper: WIN 
Rock vs. Paper: LOSE 
Paper vs. Paper: DRAW 
Rock vs. Paper: LOSE 
Paper vs. Scissors: LOSE 
Paper vs. Scissors: LOSE 
Rock vs. Scissors: WIN 
Rock vs. Paper: LOSE 
Paper vs. Rock: WIN 
Scissors vs. Paper: WIN 
Paper vs. Scissors: LOSE 
Paper vs. Scissors: LOSE 
Paper vs. Scissors: LOSE 
Paper vs. Scissors: LOSE 
*///:~

我们使用了很多手段来实现多重拆封，但是获得的是良好的代码结构。使用枚举的解决方案来实现上面的代码的时候最大的问题就是枚举实例不是类型，因此不能使用枚举实例来作为参数类型。但是我们还是可以有其他的方法绕狗这个障碍，一种方法就是使用构造器来初始化每个枚举类型，然后将输出组织称一个查找表： 
 
//: enumerated/RoShamBo2.java 
// Switching one enum on another. 
package enumerated; 
import static enumerated.Outcome.*; 
public enum RoShamBo2 implements Competitor<RoShamBo2> { 
　　PAPER(DRAW, LOSE, WIN),SCISSORS(WIN, DRAW, LOSE),ROCK(LOSE, WIN, DRAW); 
　　private Outcome vPAPER, vSCISSORS, vROCK; 
　　RoShamBo2(Outcome paper,Outcome scissors,Outcome rock) { 
　　　　this.vPAPER = paper; 
　　　　this.vSCISSORS = scissors; 
　　　　this.vROCK = rock; 
　　} 
　　public Outcome compete(RoShamBo2 it) { 
　　　　switch(it) { 
　　　　　　default: 
　　　　　　case PAPER: return vPAPER; 
　　　　　　case SCISSORS: return vSCISSORS; 
　　　　　　case ROCK: return vROCK; 
　　　　} 
　　} 
　　public static void main(String[] args) { 
　　　　RoShamBo.play(RoShamBo2.class, 20); 
　　} 
} /* Output: 
ROCK vs. ROCK: DRAW 
SCISSORS vs. ROCK: LOSE 
SCISSORS vs. ROCK: LOSE 
Enumerated Types 753 
SCISSORS vs. ROCK: LOSE 
PAPER vs. SCISSORS: LOSE 
PAPER vs. PAPER: DRAW 
PAPER vs. SCISSORS: LOSE 
ROCK vs. SCISSORS: WIN 
SCISSORS vs. SCISSORS: DRAW 
ROCK vs. SCISSORS: WIN 
SCISSORS vs. PAPER: WIN 
SCISSORS vs. PAPER: WIN 
ROCK vs. PAPER: LOSE 
ROCK vs. SCISSORS: WIN 
SCISSORS vs. ROCK: LOSE 
PAPER vs. SCISSORS: LOSE 
SCISSORS vs. PAPER: WIN 
SCISSORS vs. PAPER: WIN 
SCISSORS vs. PAPER: WIN 
SCISSORS vs. PAPER: WIN 
*///:~ 


 
//: enumerated/Competitor.java 
// Switching one enum on another. 
package enumerated; 
public interface Competitor<T extends Competitor<T>> { 
　　Outcome compete(T competitor); 
} ///:~ 


 
//: enumerated/RoShamBo.java 
// Common tools for RoShamBo examples. 
package enumerated; 
import net.mindview.util.*; 
public class RoShamBo { 
　　public static <T extends Competitor<T>>　void match(T a, T b) { 
　　　　System.out.println(a + " vs. " + b + ": " + a.compete(b)); 
　　} 
　　public static <T extends Enum<T> & Competitor<T>> void play(Class<T> rsbClass, int size) { 
　　　　for(int i = 0; i < size; i++) 
　　　　　　match(Enums.random(rsbClass),Enums.random(rsbClass)); 
　　} 
} ///:~

因为制定静态方法可以为每个枚举类型提供不同的方法，看起来是一个实现多重拆封的好解决办法，但是还是面临着枚举实例不是类型的问题，于是我们能做的就是添加一个switch语句： 
 
//: enumerated/RoShamBo3.java 
// Using constant-specific methods. 
package enumerated; 
import static enumerated.Outcome.*; 
public enum RoShamBo3 implements Competitor<RoShamBo3> { 
　　PAPER { 
　　　　public Outcome compete(RoShamBo3 it) { 
　　　　　　switch(it) { 
　　　　　　　　default: // To placate the compiler 
　　　　　　　　case PAPER: return DRAW; 
　　　　　　　　case SCISSORS: return LOSE; 
　　　　　　　　case ROCK: return WIN; 
　　　　　　} 
　　　　} 
　　}, 
　　SCISSORS { 
　　　　public Outcome compete(RoShamBo3 it) { 
　　　　　　switch(it) { 
　　　　　　　　default: 
　　　　　　　　case PAPER: return WIN; 
　　　　　　　　case SCISSORS: return DRAW; 
　　　　　　　　case ROCK: return LOSE; 
　　　　　　} 
　　　　} 
　　}, 
　　ROCK { 
　　　　public Outcome compete(RoShamBo3 it) { 
　　　　　　switch(it) { 
　　　　　　　　default: 
　　　　　　　　case PAPER: return LOSE; 
　　　　　　　　case SCISSORS: return WIN; 
　　　　　　　　case ROCK: return DRAW; 
　　　　　　} 
　　　　} 
　　}; 
　　public abstract Outcome compete(RoShamBo3 it); 
　　public static void main(String[] args) { 
　　　　RoShamBo.play(RoShamBo3.class, 20); 
　　} 
} /* Same output as RoShamBo2.java *///:~

下面的代码是一种更加简洁的实现方法： 
 
//: enumerated/RoShamBo4.java 
package enumerated; 
public enum RoShamBo4 implements Competitor<RoShamBo4> { 
　　ROCK { 
　　　　public Outcome compete(RoShamBo4 opponent) { 
　　　　　　return compete(SCISSORS, opponent); 
　　　　} 
　　}, 
　　SCISSORS { 
　　　　public Outcome compete(RoShamBo4 opponent) { 
　　　　　　return compete(PAPER, opponent); 
　　　　} 
　　}, 
　　PAPER { 
　　　　public Outcome compete(RoShamBo4 opponent) { 
　　　　　　return compete(ROCK, opponent); 
　　　　} 
　　}; 
　　Outcome compete(RoShamBo4 loser, RoShamBo4 opponent) { 
　　　　return ((opponent == this) ? Outcome.DRAW: ((opponent == loser) ? Outcome.WIN: Outcome.LOSE)); 
　　} 
　　public static void main(String[] args) { 
　　　　RoShamBo.play(RoShamBo4.class, 20); 
　　} 
} /* Same output as RoShamBo2.java *///:~

EnumMap类似乎是一个可以真正实现多重拆封的好办发： 
 
//: enumerated/RoShamBo5.java 
// Multiple dispatching using an EnumMap of EnumMaps. 
package enumerated; 
import java.util.*; 
import static enumerated.Outcome.*; 
enum RoShamBo5 implements Competitor<RoShamBo5> { 
　　PAPER, SCISSORS, ROCK; 
　　static EnumMap<RoShamBo5,EnumMap<RoShamBo5,Outcome>>　table = new EnumMap<RoShamBo5,EnumMap<RoShamBo5,Outcome>>(RoShamBo5.class); 
　　static { 
　　　　for(RoShamBo5 it : RoShamBo5.values()) 
　　　　　　table.put(it, new EnumMap<RoShamBo5,Outcome>(RoShamBo5.class)); 
　　　　initRow(PAPER, DRAW, LOSE, WIN); 
　　　　initRow(SCISSORS, WIN, DRAW, LOSE); 
　　　　initRow(ROCK, LOSE, WIN, DRAW); 
　　} 
　　static void initRow(RoShamBo5 it, Outcome vPAPER, Outcome vSCISSORS, Outcome vROCK) { 
　　　　EnumMap<RoShamBo5,Outcome> row = RoShamBo5.table.get(it); 
　　　　row.put(RoShamBo5.PAPER, vPAPER); 
　　　　row.put(RoShamBo5.SCISSORS, vSCISSORS); 
　　　　row.put(RoShamBo5.ROCK, vROCK); 
　　} 
　　public Outcome compete(RoShamBo5 it) { 
　　　　return table.get(this).get(it); 
　　} 
　　public static void main(String[] args) { 
　　　　RoShamBo.play(RoShamBo5.class, 20); 
　　} 
} /* Same output as RoShamBo2.java *///:~

我们还可以使用枚举实例具有固定值的特点来使用数据进行最简单的实现方法，这里使用一个二维数组进行映射来实现： 
 
//: enumerated/RoShamBo6.java 
// Enums using "tables" instead of multiple dispatch. 
package enumerated; 
import static enumerated.Outcome.*; 
enum RoShamBo6 implements Competitor<RoShamBo6> { 
　　PAPER, SCISSORS, ROCK; 
　　private static Outcome[][] table = { 
　　　　{ DRAW, LOSE, WIN }, // PAPER 
　　　　{ WIN, DRAW, LOSE }, // SCISSORS 
　　　　{ LOSE, WIN, DRAW }, // ROCK 
　　}; 
　　public Outcome compete(RoShamBo6 other) { 
　　　　return table[this.ordinal()][other.ordinal()]; 
　　} 
　　public static void main(String[] args) { 
　　　　RoShamBo.play(RoShamBo6.class, 20); 
　　} 
} ///:~


最新网友评论  共有(0)条评论 发布评论 返回顶部
推荐阅读
  • 终极炫富——2016 年 iOS 开发者收入调查报告
  • 年度大片：Stack Overflow 2017 开发者调查报告发布！
  • 开发者需要大学学位吗？
  • 程序员多大年纪算高龄，届时该何去何从？
  • 2017 年高薪编程语言排行榜，你的语言上榜没？
  • 各编程语言开发者最常使用的按键，中了没?
  • 伤不起的三十岁，干不动的程序员要何去何从？
  • 2016年中国加班最狠IT公司排行
  • 一句话"面试"漫画：黑了苹果、谷歌、三星
  • 拿代码量算 KPI ……跟程序员们来这套？
  • 程序员遇到 Bug 时的 30 个反应，你是哪一种？
  • 2016年收入最高的5个编程语言 Java和C没在前五?
  • 为什么很少见人傻钱多的程序员炫富？
  • 阿里月薪两万是什么体验？
  • 代码缩进时 程序员更喜欢空格键还是Tab键？
    • 最新资讯
  • Python获取系统所有进程PID及进程名称的方法示例
  • Python简单获取网卡名称及其IP地址的方法【基于psutil模块】
  • Python实现的根据IP地址计算子网掩码位数功能示例
  • 好的Python培训机构应该具备哪些条件
  • 详解Pytorch 使用Pytorch拟合多项式(多项式回归)
  • Python加载带有注释的Json文件实例
  • 对python的文件内注释 help注释方法
  • Python实现判断一行代码是否为注释的方法
  • Oracle数据库表中字段顺序的修改方法
  • ASP.NET MVC 4使用PagedList.Mvc分页的实现代码
  • Oracle实例启动时报错：ORA-32004的解决方法
  • 解读ASP.NET 5 & MVC6系列教程（7）：依赖注入
  • 详解IDEA用maven创建springMVC项目和配置
  • ASP.NET MVC5网站开发之展示层架构（五）
  • SpringBoot创建maven多模块项目实战代码
    • 后端技术
    前端技术
    数据库
    热门框架
    常用IDE
    其他
    Copyright © 2007-2017 PHPERZ.COM All Rights Reserved   冀ICP备14009818号  版权声明  广告服务