枚举概念
Java的枚举是一个类，一个用enum修饰的类，可以在其中定义方法，可以定义成员变量，可以重写构造方法，但是必须定义枚举成员。
枚举与普通类
1、枚举必须创建枚举成员，枚举成员间用,分隔，最后一个枚举成员用;与其他成员分隔
2、每个枚举成员都是所定义的枚举类的类型，因此通过枚举类获取的枚举值的类型
3、枚举成员可以带参数，如同enumMember(Object args)，但是必须重载枚举类构造方法，构造方法参数与枚举成员参数类型相同
4、枚举成员传递的参数需要有成员变量接收，此成员变量可以如同普通类的成员变量一样被定义在类中
5、枚举成员不能被修饰，即static、final、public、protected不能修饰枚举成员，而private对于枚举成员是多余的，即枚举成员默认是private
6、枚举类不能继承其它类，因为所有枚举类都默认继承java.lang.Enum类，而Java不支持多继承
7、枚举类不能被实现，不能被实例化，枚举类的构造方法都是私有的private，要定义一个枚举类变量，可以通过EnumClass var = EnumClass.EnumMember来实现，即指向一个枚举成员
枚举类的方法
枚举类Enum实现了Comparable和Serializable接口，因此是可以比较和序列化的
String name()
name()方法返回当前枚举成员的名称
public enum SimpleEnumUse {
Mon("Monday"),
Tue("Tuesday"),
Wed("Wednesday"),
Thu("Thursday"),
Fri("Friday"),
Sat("Saturday"),
Sun("Sunday");
}
public class EnumTest {
public static void main(String[] args) {
SimpleEnumUse mon = SimpleEnumUse.Mon;
System.out.println(mon.name());
}
}
执行结果
Mon
int ordinal()
ordinal()方法返回当前枚举成员在枚举类中的索引坐标
public enum SimpleEnumUse {
Mon("Monday"),
Tue("Tuesday"),
Wed("Wednesday"),
Thu("Thursday"),
Fri("Friday"),
Sat("Saturday"),
Sun("Sunday");
}
public class EnumTest {
public static void main(String[] args) {
SimpleEnumUse mon = SimpleEnumUse.Mon;
System.out.println(mon.name());
System.out.println(mon.ordinal());
}
}
Mon
0
String toString()
toString()方法默认返回枚举类的名称，与name()相同
boolean equals(Object other)
equals()方法可以比较当前类型与参数类型是否相同
Enum类中的实现如下
public final boolean equals(Object other) {
return this==other;
}
int compareTo(E o)
compareTo()方法可以比较两个枚举成员的ordinal值，但是所比较的参数必须属于同一类型，返回值为索引的差值
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;
}
Object valueOf(String name)
通过名字获取指定的枚举成员，name即定义枚举成员时所写的名称
valueOf(String name)方法不是Enum类本来包含的，而是Java编译时新增的static方法，Enum原来包含的valueOf方法是valueOf(Class enumType, String name)
public static void main(String[] args) {
SimpleEnumUse fri = SimpleEnumUse.valueOf("Fri");
System.out.println(fri.name());
}
fri name: Fri
Object[] values()
返回包含所有枚举成员的枚举类数组，可以用来遍历所有枚举成员
values()方法并不是Enum类本身所包含的，它是Java编译枚举类时生成的static方法
枚举类自定义方法
枚举类的构造方法
枚举类的构造方法都是私有的，枚举类可以重载构造方法以实现在实例化枚举成员时执行某些代码
public enum SimpleEnumUse {
Mon("Monday"),
Tue("Tuesday"),
Wed("Wednesday"),
Thu("Thursday"),
Fri("Friday"),
Sat("Saturday"),
Sun("Sunday");
private final String day;
SimpleEnumUse(String day) {
this.day = day;
}
public String getDay() {
return this.day;
}
}
public class EnumTest {
public static void main(String[] args) {
SimpleEnumUse mon = SimpleEnumUse.Mon;
System.out.println("SimpleEnumUse.Mon.getDay(): " + mon.getDay());
}
}
SimpleEnumUse.Mon.getDay(): Monday
可以重载多个构造函数
public enum SimpleEnumUse {
Mon("Monday"),
Tue("Tuesday", "Alan"),
Wed("Wednesday"),
Thu("Thursday"),
Fri("Friday"),
Sat("Saturday"),
Sun("Sunday");
private final String day;
String name;
SimpleEnumUse(String day) {
this.day = day;
}
SimpleEnumUse(String day, String name) {
this.day = day;
this.name = name;
}
public String getDay() {
return this.day;
}
public String getDayAndName() {
return day + ", " + name;
}
}
public class EnumTest {
public static void main(String[] args) {
SimpleEnumUse mon = SimpleEnumUse.Mon;
System.out.println("SimpleEnumUse.Mon.getDay(): " + mon.getDay());
System.out.println("SimpleEnumUse.Mon.getDayAndName(): " + mon.getDayAndName());
SimpleEnumUse tue = SimpleEnumUse.Tue;
System.out.println("SimpleEnumUse.Tue.getDay(): " + tue.getDay());
System.out.println("SimpleEnumUse.Tue.getDayAndName(): " + tue.getDayAndName());
}
}
SimpleEnumUse.Mon.getDay(): Monday
SimpleEnumUse.Mon.getDayAndName(): Monday, null
SimpleEnumUse.Tue.getDay(): Tuesday
SimpleEnumUse.Tue.getDayAndName(): Tuesday, Alan
在枚举类中定义方法
枚举类中可以定义方法，每个枚举对象都可以调用枚举类的非私有方法，枚举类和枚举对象的关系类似基类和子类的关系，枚举对象可以调用枚举类的非私有成员变量和方法
枚举对象内部可以直接定义方法，但是只能在定义的枚举对象内部访问，无法在外部和其它枚举成员中调用
枚举类实现接口
枚举类可以和普通类一样实现接口，并实现接口的方法，接口方法的实现有两种方式
1、枚举类中实现，实现后，每一个枚举成员都可以调用该方法，也可以重写实现方法
public interface EnumInterface {
public void show();
}
public enum SimpleEnumUse implements EnumInterface {
Mon, Tue, Wed, Thu, Fri, Sat, Sun;
@Override
public void show() {
System.out.println("SimpleEnumUse show");
}
}
public class EnumTest {
public static void main(String[] args) {
SimpleEnumUse mon = SimpleEnumUse.Mon;
mon.show();
}
}
2、不在枚举类中实现，但是必须在每一个枚举成员中实现
public interface EnumInterface {
void info();
}
public enum SimpleEnumUse implements EnumInterface {
Mon("Monday") {
public void info() {
System.out.println("Monday info");
}
},
Tue("Tuesday", "Alan") {
public void info() {
System.out.println("Tuesday info");
}
},
Wed("Wednesday") {
public void info() {
System.out.println("Wednesday info");
}
},
Thu("Thursday") {
public void info() {
System.out.println("Thursday info");
}
},
Fri("Friday") {
public void info() {
System.out.println("Friday info");
}
},
Sat("Saturday") {
public void info() {
System.out.println("Saturday info");
}
},
Sun("Sunday") {
public void info() {
System.out.println("Sunday info");
}
};
}
多层枚举的实现
枚举类无法继承其它类，自然一个枚举就不能像普通类一样，继承父类并对其功能进行扩展，因此需要一些其它方式来实现枚举类的扩展
1、通过接口组织枚举
可以在一个接口的内部定义枚举类型，这样定义的所有枚举类型都属于接口类型的
public interface Food {
enum Appetizer implements Food {
SALAD, SOUP, SPRING_ROLLS;
};
enum MainCourse implements Food {
LASAGNE, BURRITO, PAD_THAI;
};
enum Dessert implements Food {
TIRAMISU, GELATO, BLACK_FOREST_CAKE;
}
}
public class SubEnumTest {
public static void main(String[] args) {
Food food = Food.Appetizer.SALAD;
Food.Appetizer salad = Food.Appetizer.SALAD;
}
}
2、通过包含在其它枚举类型中
当需要与一大堆类型打交道时，接口不如enum好用，可以创建“枚举的枚举”，创建一个新的枚举，然后用实例包装其它枚举
例如将刚才的Food中的枚举包装进新的枚举Course中
public enum Course {
APPETIZER(Food.Appetizer.class),
MAINCOURSE(Food.MainCourse.class),
DESSERT(Food.Dessert.class);
private Food[] values;
Course(Class<? extends Food> kind) {
values = kind.getEnumConstants();
}
public Food randomSelection() {
return values[new Random().nextInt(values.length)];
}
}
如上，通过重载构造方法，将Food中枚举类的Class对象传入构造函数，并通过getEnumConstants()方法获取枚举的实例，此后即可通过其它方法获取枚举的数据，如通过randomSelection方法随机输出食物
public class SubEnumTest {
public static void main(String[] args) {
for (int i = 0; i < 3; i++) {
for (Course course : Course.values()) {
Food food1 = course.randomSelection();
System.out.println(food1);
}
System.out.println("---");
}
}
}
输出结果如下
SALAD
LASAGNE
GELATO
---
SOUP
PAD_THAI
TIRAMISU
---
SALAD
PAD_THAI
GELATO
---
3、通过嵌套方式实现
将枚举嵌套在另一个枚举中，其实是方式1和方式2的结合，即将接口的定义也放在枚举类中
public enum Meal {
APPETIZER(Food2.Appetizer.class),
MAINCOURSE(Food2.MainCourse.class),
DESSERT(Food2.Dessert.class);
private Food2[] values;
Meal(Class<? extends Food2> kind) {
values = kind.getEnumConstants();
}
public interface Food2 {
enum Appetizer implements Food2 {
SALAD, SOUP, SPRING_ROLLS;
};
enum MainCourse implements Food2 {
LASAGNE, BURRITO, PAD_THAI;
};
enum Dessert implements Food2 {
TIRAMISU, GELATO, BLACK_FOREST_CAKE;
}
}
public Food2 randomSelection() {
return values[new Random().nextInt(values.length)];
}
public static void main(String[] args) {
for (int i = 0; i < 3; i++) {
for (Meal meal : Meal.values()) {
Food2 food1 = meal.randomSelection();
System.out.println(food1);
}
System.out.println("---");
}
}
}
EnumSet
EnumMap
常量和枚举
常量类和枚举都可以用来定义有限的值供其它方法调用，但是枚举和常量类还是有区别的，一般而言，枚举的功能比常量类更强大，推荐使用枚举
枚举的优势
1、枚举的约束性强。例如通过传递常量参数来控制系统后续流程，可能出现传递了未在常量类中定义的值，例如常量类中有两个常量0、1，分别表示性别男、女，此时传递参数2，参数传递时不会报错，但是后续程序无法处理这个参数；通过枚举可以有效限制参数的传递，而且枚举类型也方便程序员编写程序
2、枚举的扩展性强。因为枚举类和枚举对象的关系类似基类和导出类的关系，所以可以很方便地对每个枚举类型定义自己的规则
3、枚举的使用比较方便。枚举类自带变量方法和取值方法，并且内部是自动排序的，可以获取枚举成员的坐标索引，并且实现了Comparable接口，可以通过==进行比较
4、枚举的定义比常量类简单方便
5、switch语句天生支持枚举类
枚举常量相关方法
枚举成员可以根据实际需求，赋予各自不同的方法，只需要在枚举类中实现抽象方法，即可在枚举对象中实现抽象方法
通过EnumMap实现状态机
《Java编程思想》中，利用枚举的常量相关方法和EnumMap实现了售货机的状态机，状态机可以具有有限个特定的状态，根据输入转换到下个状态，同时状态机存在瞬时状态，瞬时状态与一般状态的处理逻辑不同，瞬时任务执行结束离开瞬时状态
Input类，用于表示用户输入到售货机的数据，定义了随机生成input对象的方法
public enum Input {
NICKEL(5), DIME(10), QUARTER(25), DOLLAR(100),
TOOTHPASTE(200), CHIPS(75), SODA(100), SOAP(50),
ABORT_TRANSACTION {
public int amount() {
throw new RuntimeException("ABORT.amount()");
}
},
STOP {
public int amount() {
throw new RuntimeException("STOP_DOWN.amount()");
}
};
int value;
Input(int value) {
this.value = value;
}
Input() {}
int amount() {
return value;
}
static Random random = new Random(47);
public static Input randomSelection() {
return values()[random.nextInt(values().length - 1)];
}
}
Category类，对用户输入的数据进行分类
import static com.myProject.enumTest.VendingMachineTest.Input.*;
public 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);
}
}
State类，用于控制和改变售货机的状态，每种状态都重写了next方法，用于切换到下一个状态
非瞬时状态的next方法接收Input类型的参数，根据传入参数的Category切换状态，瞬时状态的next方法不接收参数，固定切换到对应状态
public enum State {
RESTING {
@Override
void next(Input input) {
switch (Category.categorize(input)) {
case MONEY:
amount += input.amount();
state = ADDING_MONEY;
break;
case SHUT_DOWN:
state = TERMINAL;
break;
default:
}
}
},
ADDING_MONEY {
@Override
void next(Input input) {
switch (Category.categorize(input)) {
case MONEY:
amount += input.amount();
break;
case ITEM_SELECTION:
selection = input;
if (amount < selection.amount()) {
System.out.println("Insufficient money for " + selection);
}
else {
state = DISPENSING;
}
break;
case QUIT_TRANSACTION:
break;
case SHUT_DOWN:
state = TERMINAL;
break;
default:
}
}
},
DISPENSING(StateDuration.TRANSIENT) {
@Override
void next() {
System.out.println("here is your " + selection);
amount -= selection.amount();
state = GIVING_CHANGE;
}
},
GIVING_CHANGE(StateDuration.TRANSIENT) {
@Override
void next() {
if (amount > 0) {
System.out.println("Your change: " + amount);
amount = 0;
}
state = RESTING;
}
},
TERMINAL {
@Override
void output() {
System.out.println("Halted");
}
};
enum StateDuration {TRANSIENT}
public boolean isTransient = false;
public static State state = State.RESTING;
private static int amount = 0;
private static Input selection = null;
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() {
System.out.println(amount);
}
}
VendingMachine类，售货机启动类，其中run方法接收main方法中生成的Input类型的Generator对象，用于生成新的input对象
public class VendingMachine {
static void run(Generator<Input> gen) {
while (State.state != State.TERMINAL) {
State.state.next(gen.next());
while (State.state.isTransient) {
State.state.next();
}
State.state.output();
}
}
public static void main(String[] args) {
Generator<Input> gen = new RandomInputGenerator();
run(gen);
}
}
RandomInputGenerator类，调用Input的随机方法生成input对象
public class RandomInputGenerator implements Generator<Input> {
@Override
public Input next() {
return Input.randomSelection();
}
}
多路分发
Java只支持单路分发，即根据传递的对象，执行其所包含的方法，当传递的参数包含不止一个类型未知的对象时，需要程序员自己判断类型并动态绑定，解决这类问题的办法就是多路分发，即创建一个接口，再由多个类去实现接口，并实现各自的方法逻辑，在参数传递时，只需要将参数类型定义为接口类型的即可
下面将介绍四种方式实现多路分发，实现一个返回石头、剪刀、布比赛结果的程序
通过泛型和枚举实现多路分发
通过构造器初始化每个enum实例，将“一组”结果作为参数传递到构造器中，此时只需要通过switch语句返回结果即可
首先定义返回结果的枚举类Outcome
public enum Outcome {
WIN, LOSE, DRAW
}
定义比较接口Competitor，可以与另一个Competitor竞争
public interface Competitor<T extends Competitor<T>> {
Outcome compete(T competitor);
}
定义两个方法，接收泛型参数，match()方法为一个Competitor对象调用compate()方法与另一个Competitor对象比较
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));
}
}
}
最后定义枚举类，枚举对象的参数是一组比较结果，实现Competitor接口的compete()方法只需要通过switch返回对应结果即可
import static com.myProject.enumTest.VendingMachineTest.roShamBoTest.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;
}
@Override
public Outcome compete(RoShamBo2 competitor) {
switch (competitor) {
default:
case PAPER:
return vPAPER;
case SCISSORS:
return vSCISSORS;
case ROCK:
return vROCK;
}
}
public static void main(String[] args) {
RoShamBo.play(RoShamBo2.class, 20);
}
}
使用常量相关的方法
常量相关的方法允许为每个枚举成员定义不同的代码逻辑，理论上是最完善的多路分发实现方式，由于enum不能实例化，所以使用switch语句来分发处理
import static com.myProject.enumTest.VendingMachineTest.roShamBoTest.Outcome.*;
public enum RoShamBo3 implements Competitor<RoShamBo3> {
PAPER {
public Outcome compete(RoShamBo3 competitor) {
switch (competitor) {
default:
case PAPER:
return DRAW;
case SCISSORS:
return LOSE;
case ROCK:
return WIN;
}
}
},
SCISSORS {
@Override
public Outcome compete(RoShamBo3 competitor) {
switch (competitor) {
default:
case PAPER:
return WIN;
case SCISSORS:
return DRAW;
case ROCK:
return LOSE;
}
}
},
ROCK {
@Override
public Outcome compete(RoShamBo3 competitor) {
switch (competitor) {
default:
case PAPER:
return LOSE;
case SCISSORS:
return WIN;
case ROCK:
return DRAW;
}
}
};
@Override
public abstract Outcome compete(RoShamBo3 competitor);
public static void main(String[] args) {
RoShamBo.play(RoShamBo3.class, 20);
}
}
这种写法导致如果增加一个新的类型，要修改的代码会非常多
使用EnumMap分发
对于两路分发，可以用一个EnumMap的EnumMap来实现
使用二维数组
因为每一个枚举成员的索引坐标是确定的，并且可以通过ordinal()方法获取，因此可以通过二维数组将竞争者映射到竞争结果，如同RoShamBo2中定义枚举成员时传递参数的形式
private static Outcome[][] table = {
{DRAW, LOSE, WIN},
{WIN, DRAW, LOSE},
{LOSE, WIN, DEAW}
};
public Outcome compete(RoShamBo6 other) {
return table[this.ordinal()][other.ordinal()];
}
2429
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
