乐趣区

关于java:Java枚举

概念

enum 的全称为 enumeration,是 JDK 1.5 中引入的新个性。

在 Java 中,被 enum 关键字润饰的类型就是枚举类型。模式如下:

enum Color {RED, GREEN, BLUE}

如果枚举不增加任何办法,枚举值默认为从 0 开始的有序数值。以 Color 枚举类型举例,它的枚举常量顺次为 RED`:0,GREEN:1,BLUE:2`。

枚举的益处:能够将常量组织起来,对立进行治理。

枚举的典型利用场景:错误码、状态机等。

枚举类型的实质

只管 enum 看起来像是一种新的数据类型,事实上,enum是一种受限制的类,并且具备本人的办法

创立 enum 时,编译器会为你生成一个相干的类,这个类继承自 java.lang.Enum

java.lang.Enum类申明

public abstract class Enum<E extends Enum<E>>

implements Comparable<E>, Serializable {...}

枚举的办法

在 enum 中,提供了一些根本办法:

values():返回 enum 实例的数组,而且该数组中的元素严格放弃在 enum 中申明时的程序。

name():返回实例名。

ordinal():返回实例申明时的秩序,从 0 开始。

getDeclaringClass():返回实例所属的 enum 类型。

equals():判断是否为同一个对象。

能够应用 == 来比拟 enum 实例。

此外,java.lang.Enum实现了 ComparableSerializable 接口,所以也提供 compareTo() 办法。

例:展现 enum 的根本办法

public class EnumMethodDemo {

 enum Color `{RED, GREEN, BLUE;}`
 enum Size `{BIG, MIDDLE, SMALL;}`
 public static void main(String args[]) `{`
 `System.out.println(`"=========== Print all Color ==========="`);`
 for `(Color c : Color.values()) {`
 `System.out.println(c +` "ordinal:" `+ c.ordinal());`
 }
 `System.out.println(`"=========== Print all Size ==========="`);`
 for `(Size s : Size.values()) {`
 `System.out.println(s +` "ordinal:" `+ s.ordinal());`
 }
 Color green = Color.GREEN;
 `System.out.println(`"green name():" `+ green.name());`
 `System.out.println(`"green getDeclaringClass():" `+ green.getDeclaringClass());`
 `System.out.println(`"green hashCode():" `+ green.hashCode());`
 `System.out.println(`"green compareTo Color.GREEN:" `+ green.compareTo(Color.GREEN));`
 `System.out.println(`"green equals Color.GREEN:" `+ green.equals(Color.GREEN));`
 `System.out.println(`"green equals Size.MIDDLE:" `+ green.equals(Size.MIDDLE));`
 `System.out.println(`"green equals 1:" `+ green.equals(`1`));`
 `System.out.format(`"green == Color.BLUE: %bn"`, green == Color.BLUE);`
 }
}

输入

=========== Print all Color ===========

RED ordinal: 0

GREEN ordinal: 1

BLUE ordinal: 2

=========== Print all Size ===========

BIG ordinal: 0

MIDDLE ordinal: 1

SMALL ordinal: 2

green name(): GREEN

green getDeclaringClass(): class org.zp.javase.enumeration.EnumDemo$Color

green hashCode(): 460141958

green compareTo Color.GREEN: 0

green equals Color.GREEN: true

green equals Size.MIDDLE: false

green equals 1: false

green == Color.BLUE: false

枚举的个性

枚举的个性,归纳起来就是一句话:

除了不能继承,基本上能够将 enum 看做一个惯例的类

然而这句话须要拆分去了解,让咱们细细道来。

枚举能够增加办法

在概念章节提到了,枚举值默认为从 0 开始的有序数值。那么问题来了:如何为枚举显示的赋值。

Java 不容许应用 = 为枚举常量赋值

如果你接触过 C /C++,你必定会很天然的想到赋值符号 =。在 C /C++ 语言中的 enum,能够用赋值符号 = 显示的为枚举常量赋值;然而,很遗憾,Java 语法中却不容许应用赋值符号 = 为枚举常量赋值

例:C/C++ 语言中的枚举申明

typedef enum{

 `ONE =` 1`,`
 TWO,
 `THREE =` 3`,`
 `TEN =` 10
} Number;

枚举能够增加一般办法、静态方法、形象办法、构造方法

Java 尽管不能间接为实例赋值,然而它有更优良的解决方案:为 enum 增加办法来间接实现显示赋值

创立 enum 时,能够为其增加多种办法,甚至能够为其增加构造方法。

留神一个细节:如果要为 enum 定义方法,那么必须在 enum 的最初一个实例尾部增加一个分号。此外,在 enum 中,必须先定义实例,不能将字段或办法定义在实例后面。否则,编译器会报错。

例:全面展现如何在枚举中定义一般办法、静态方法、形象办法、构造方法

public enum ErrorCode {

 `OK(`0`) {`
 public String getDescription() `{`
 return "胜利"`;`
 }
 },
 `ERROR_A(`100`) {`
 public String getDescription() `{`
 return "谬误 A"`;`
 }
 },
 `ERROR_B(`200`) {`
 public String getDescription() `{`
 return "谬误 B"`;`
 }
 };
 private int `code;`
 // 构造方法:enum 的构造方法只能被申明为 private 权限或不申明权限
 private ErrorCode(int number) `{` // 构造方法
 this`.code = number;`
 }
 public int getCode() `{` // 一般办法
 return `code;`
 `}` // 一般办法
 public abstract String getDescription()`;` // 形象办法
 public static void main(String args[]) `{` // 静态方法
 for `(ErrorCode s : ErrorCode.values()) {`
 `System.out.println(`"code:" `+ s.getCode() +` ", description:" `+ s.getDescription());`
 }
 }
}

注:下面的例子并不可取,仅仅是为了展现枚举反对定义各种办法。上面是一个简化的例子

例:一个错误码枚举类型的定义

本例和上例的执行后果完全相同。

public enum ErrorCodeEn {

 `OK(`0`,` "胜利"`),`
 `ERROR_A(`100`,` "谬误 A"`),`
 `ERROR_B(`200`,` "谬误 B"`);`
 `ErrorCodeEn(`int `number, String description) {`
 this`.code = number;`
 this`.description = description;`
 }
 private int `code;`
 private `String description;`
 public int getCode() `{`
 return `code;`
 }
 public String getDescription() `{`
 return `description;`
 }
 public static void main(String args[]) `{` // 静态方法
 for `(ErrorCodeEn s : ErrorCodeEn.values()) {`
 `System.out.println(`"code:" `+ s.getCode() +` ", description:" `+ s.getDescription());`
 }
 }
}

枚举能够实现接口

enum 能够像个别类一样实现接口。

同样是实现上一节中的错误码枚举类,通过实现接口,能够束缚它的办法。

public interface INumberEnum {

 int getCode()`;`
 String getDescription()`;`
}

public enum ErrorCodeEn2 implements INumberEnum {

 `OK(`0`,` "胜利"`),`
 `ERROR_A(`100`,` "谬误 A"`),`
 `ERROR_B(`200`,` "谬误 B"`);`
 `ErrorCodeEn2(`int `number, String description) {`
 this`.code = number;`
 this`.description = description;`
 }
 private int `code;`
 private `String description;`
 @Override
 public int getCode() `{`
 return `code;`
 }
 @Override
 public String getDescription() `{`
 return `description;`
 }
}

枚举不能够继承

enum 不能够继承另外一个类,当然,也不能继承另一个 enum。

因为 enum 实际上都继承自 java.lang.Enum 类,而 Java 不反对多重继承,所以 enum 不能再继承其余类,当然也不能继承另一个 enum

枚举的利用场景

组织常量

在 JDK1.5 之前,在 Java 中定义常量都是public static final TYPE a; 这样的模式。有了枚举,你能够将有关联关系的常量组织起来,使代码更加易读、平安,并且还能够应用枚举提供的办法。

枚举申明的格局

注:如果枚举中没有定义方法,也能够在最初一个实例前面加逗号、分号或什么都不加。

上面三种申明形式是等价的:

enum Color {RED, GREEN, BLUE}

enum Color {RED, GREEN, BLUE,}

enum Color {RED, GREEN, BLUE;}

switch 状态机

咱们常常应用 switch 语句来写状态机。JDK7 当前,switch 曾经反对 intcharStringenum 类型的参数。这几种类型的参数比拟起来,应用枚举的 switch 代码更具备可读性。

enum Signal {RED, YELLOW, GREEN}

public static String getTrafficInstruct(Signal signal) {

 `String instruct =` "信号灯故障"`;`
 switch `(signal) {`
 case `RED:`
 `instruct =` "红灯停"`;`
 break`;`
 case `YELLOW:`
 `instruct =` "黄灯请留神"`;`
 break`;`
 case `GREEN:`
 `instruct =` "绿灯行"`;`
 break`;`
 default`:`
 break`;`
 }
 return `instruct;`
}

组织枚举

能够将类型相近的枚举通过接口或类组织起来。

然而个别用接口方式进行组织。

起因是:Java 接口在编译时会主动为 enum 类型加上 public static 修饰符;Java 类在编译时会主动为 enum 类型加上 static 修饰符。看出差别了吗?没错,就是说,在类中组织站长博客enum,如果你不给它润饰为 public,那么只能在本包中进行拜访。

例:在接口中组织 enum

public interface Plant {

 enum Vegetable implements INumberEnum `{`
 `POTATO(`0`,` "土豆"`),`
 `TOMATO(`0`,` "西红柿"`);`
 `Vegetable(`int `number, String description) {`
 this`.code = number;`
 this`.description = description;`
 }
 private int `code;`
 private `String description;`
 @Override
 public int getCode() `{`
 return 0`;`
 }
 @Override
 public String getDescription() `{`
 return null`;`
 }
 }
 enum Fruit implements INumberEnum `{`
 `APPLE(`0`,` "苹果"`),`
 `ORANGE(`0`,` "桔子"`),`
 `BANANA(`0`,` "香蕉"`);`
 `Fruit(`int `number, String description) {`
 this`.code = number;`
 this`.description = description;`
 }
 private int `code;`
 private `String description;`
 @Override
 public int getCode() `{`
 return 0`;`
 }
 @Override
 public String getDescription() `{`
 return null`;`
 }
 }
}

例:在类中组织 enum

本例和上例成果雷同。

public class Plant2 {

 public enum Vegetable implements INumberEnum `{...}` // 省略代码
 public enum Fruit implements INumberEnum `{...}` // 省略代码
}

策略枚举

EffectiveJava 中展现了一种策略枚举。这种枚举通过枚举嵌套枚举的形式,将枚举常量分类解决。

这种做法尽管没有 switch 语句简洁,然而更加平安、灵便。

例:EffectvieJava 中的策略枚举范例

enum PayrollDay {

 MONDAY(PayType.WEEKDAY), TUESDAY(PayType.WEEKDAY), WEDNESDAY(
 PayType.WEEKDAY), THURSDAY(PayType.WEEKDAY), FRIDAY(PayType.WEEKDAY), SATURDAY(
 PayType.WEEKEND), SUNDAY(PayType.WEEKEND);
 private final `PayType payType;`
 PayrollDay(PayType payType) {
 this`.payType = payType;`
 }
 double pay(double hoursWorked, double payRate) `{`
 return `payType.pay(hoursWorked, payRate);`
 }
 // 策略枚举
 private enum PayType `{`
 WEEKDAY {
 double overtimePay(double hours, double payRate) `{`
 return `hours <= HOURS_PER_SHIFT ?` 0 `: (hours - HOURS_PER_SHIFT)`
 `* payRate /` 2`;`
 }
 },
 WEEKEND {
 double overtimePay(double hours, double payRate) `{`
 return `hours * payRate /` 2`;`
 }
 };
 private static final int `HOURS_PER_SHIFT =` 8`;`
 abstract double overtimePay(double hrs, double payRate)`;`
 double pay(double hoursWorked, double payRate) `{`
 double `basePay = hoursWorked * payRate;`
 return `basePay + overtimePay(hoursWorked, payRate);`
 }
 }
}

测试

`System.out.println(`"时薪 100 的人在周五工作 8 小时的支出:" `+ PayrollDay.FRIDAY.pay(`8.0`,` 100`));`
`System.out.println(`"时薪 100 的人在周六工作 8 小时的支出:" `+ PayrollDay.SATURDAY.pay(`8.0`,` 100`));`

EnumSet 和 EnumMap

Java 中提供了两个不便操作 enum 的工具类——EnumSet 和 EnumMap。

EnumSet 是枚举类型的高性能 Set 实现。它要求放入它的枚举常量必须属于同一枚举类型。EnumMap 是专门为枚举类型量身定做的 Map 实现。尽管应用其它的 Map 实现(如 HashMap)也能实现枚举类型实例到值得映射,然而应用 EnumMap 会更加高效:它只能接管同一枚举类型的实例作为键值,并且因为枚举类型实例的数量绝对固定并且无限,所以 EnumMap 应用数组来寄存与枚举类型对应的值。这使得 EnumMap 的效率十分高。

// EnumSet 的应用

`System.out.println(`"EnumSet 展现"`);`
EnumSet<ErrorCodeEn> errSet = EnumSet.allOf(ErrorCodeEn.class);

for (ErrorCodeEn e : errSet) {

 `System.out.println(e.name() +` ":" `+ e.ordinal());`
}

// EnumMap 的应用

`System.out.println(`"EnumMap 展现"`);`
`EnumMap<StateMachine.Signal, String> errMap =` new `EnumMap(StateMachine.Signal.class);`
`errMap.put(StateMachine.Signal.RED,` "红灯"`);`
`errMap.put(StateMachine.Signal.YELLOW,` "黄灯"`);`
`errMap.put(StateMachine.Signal.GREEN,` "绿灯"`);`

for (Iterator<Map.Entry<StateMachine.Signal, String>> iter = errMap.entrySet().iterator(); iter.hasNext();) {

 Map.Entry<StateMachine.Signal, String> entry = iter.next();
 `System.out.println(entry.getKey().name() +` ":" `+ entry.getVal`
退出移动版