什么是枚举?java中枚举如何定义
枚举是将变量的值一一列举出来,变量的值只限定于列举出来的值,java中的枚举是jdk1.5后引入的,以前通常会在接口中定义静态常量的方式来表示枚举.我们只讨论1.5以后引入的枚举类.下面的例子定义了一个简单的枚举类用于表示四季.定义枚举使用关键字enum
1 public enum Season {
2 SPRING,SUMMER,AUTUMN,WINTER;
3 }
可以看出,定义一个枚举类是非常容易的,只需要将枚举常量的名称一一列举出来,并用逗号分隔如果不添加任何方法,枚举的默认值是从0开始的有序数值,也就是说Season的枚举常量依次是SPRING:0,SUMMER:1,AUTUMN:2,WINTER:3.
使用枚举类
1 public class TestEunm {
2 public static void main(String[] args) {
3 // 0. 不能创建枚举类的对象
4 //Season season = new Season(); //编译报错
5
6
7 // 1.直接使用类名.枚举常量名
8 System.out.println(Season.SPRING); //SPRING
9 System.out.println(Season.SUMMER); //SUMMER
10 System.out.println(Season.AUTUMN); //AUTUMN
11 System.out.println(Season.WINTER); //WINTER
12 //System.out.println(Season.NULL); //不能使用不存在的枚举常量名
13
14 // 2.可以使用==或equals方法比较两个枚举变量的值是否相等,这两种效果是一样的
15 Season spring = Season.SPRING;
16 Season spring2 = Season.SPRING;
17 Season summer = Season.SUMMER;
18 System.out.println(spring == summer); //fasle
19 System.out.println(spring == spring2); //true
20 System.out.println(spring.equals(spring2)); //true
21 System.out.println(spring.equals(summer)); //false
22
23 }
24 }
为什么不能构造枚举类的对象呢?为什么可以使用类名.枚举常量名的方式调用枚举常量呢?使用反编译工具可以看出枚举类都是默认继承java.lang.Enum类的.这是一个泛型的抽象类
我们先分析下Enum类的源码,再来分析我们自己定义的枚举类
Enum类
Enum是java中所有枚举类型的基类.是一个泛型的抽象类,它的类型参数限定为Enum本身或它的子类,同时它还实现了Comparable<E>接口和Serializable接口.(在Enum中其实还有两个私有方法与反序列化有关)
1 public abstract class Enum<E extends Enum<E>> implements Comparable<E>, Serializable {
2
3 // 枚举常量的名称.如Season中声明的SPRING,SUMMER等
4 private final String name;
5
6 // 枚举常量在声明时的位置序号(默认从0开始),这个值通常在EnumSet和EnumMap中使用
7 private final int ordinal;
8
9
10 // 返回此枚举常量的名称
11 public final String name() {
12 return name;
13 }
14
15 // 最终方法,不允许子类重写,返回枚举常量在声明时的序号
16 public final int ordinal() {
17 return ordinal;
18 }
19
20 // 构造器,我们定义的子类将使用这个方法初始化枚举值
21 protected Enum(String name, int ordinal) {
22 this.name = name;
23 this.ordinal = ordinal;
24 }
25 // 返回枚举常量的名称,子类可以重写它的方法,当没有重写时调用效果和调用name()方法效果一样
26 public String toString() {
27 return name;
28 }
29
30 // 如果指定对象等于此对象时返回true
31 public final boolean equals(Object other) {
32 return this == other;
33 }
34
35 // 返回枚举常量的哈希码
36 public final int hashCode() {
37 return super.hashCode();
38 }
39
40 // 获得该枚举对象的一个个拷贝.当调用此方法时,将抛出一个异常,枚举对象应该是单例的,不允许拷贝
41 protected final Object clone() throws CloneNotSupportedException {
42 throw new CloneNotSupportedException();
43 }
44
45 // 比较此枚举常量与指定枚举的顺序,比较的是枚举声明时产生的序号
46 public final int compareTo(E o) {
47 Enum<?> other = (Enum<?>) o;
48 Enum<E> self = this;
49 if (self.getClass() != other.getClass() && self.getDeclaringClass() != other.getDeclaringClass())
50 throw new ClassCastException();
51 return self.ordinal - other.ordinal;
52 }
53
54 // 返回此枚举类型相对应的Class对象
55 @SuppressWarnings("unchecked")
56 public final Class<E> getDeclaringClass() {
57 Class<?> clazz = getClass();
58 Class<?> zuper = clazz.getSuperclass();
59 return (zuper == Enum.class) ? (Class<E>) clazz : (Class<E>) zuper;
60 }
61
62 // 返回带指定名称的枚举常量
63 public static <T extends Enum<T>> T valueOf(Class<T> enumType, String name) {
64 T result = enumType.enumConstantDirectory().get(name);
65 if (result != null)
66 return result;
67 if (name == null) //如果name为空,抛出一个异常
68 throw new NullPointerException("Name is null");
69 // 如果上面的都执行了,抛出一个IllegalArgumentException异常(不合法的参数)
70 throw new IllegalArgumentException("No enum constant " + enumType.getCanonicalName() + "." + name);
71 }
72 // 从Object继承的方法,但是枚举类不应该有该方法
73 protected final void finalize() {
74 }
75
76 }
自定义的Season类
1 // 反编译后的Season类
2 public final class Season extends Enum
3 {
4
5 public static final Season SPRING;
6 public static final Season SUMMER;
7 public static final Season AUTUMN;
8 public static final Season WINTER;
9 private static final Season ENUM$VALUES[];
10
11 private Season(String s, int i)
12 {
13 super(s, i);
14 }
15
16 public static Season[] values()
17 {
18 Season aseason[];
19 int i;
20 Season aseason1[];
21 System.arraycopy(aseason = ENUM$VALUES, 0, aseason1 = new Season[i = aseason.length], 0, i);
22 return aseason1;
23 }
24
25 public static Season valueOf(String s)
26 {
27 return (Season)Enum.valueOf(enums/Season, s);
28 }
29
30 static
31 {
32 SPRING = new Season("SPRING", 0);
33 SUMMER = new Season("SUMMER", 1);
34 AUTUMN = new Season("AUTUMN", 2);
35 WINTER = new Season("WINTER", 3);
36 ENUM$VALUES = (new Season[] {
37 SPRING, SUMMER, AUTUMN, WINTER
38 });
39 }
40 }
通过反编译工具可以看出,枚举也是一个类,但这个类比较特殊,它没有无参构造器,并且构造器都是私有的.我们声明的枚举常量其实就是一个该类的对象,并用static final修饰(这样保证了枚举常量是单例的,且不可修改)因此可以通过类名.枚举常量名的方式来调用.
枚举类内部还维护了一个该类的数组,用于保存我们声明的枚举常量.编译器还会为我们生成一个values方法,它可以返回一个包含全部枚举值的数组.下面使用下我们提到的方法看看效果.
1 public class TestEunm {
2 public static void main(String[] args) {
3 Season spring = Season.SPRING;
4
5 // 0.返回此枚举常量的名称
6 String name = spring.name();
7 // 或
8 String name2 = spring.toString();
9 System.out.println(name); // 输出: SPRING
10 System.out.println(name2); // 输出: SPRING
11
12 // 1.返回包含全部枚举值的数组
13 Season[] values = Season.values();
14 for (Season season : values) {
15
16 // 2.返回枚举常量声明时的位置序号
17 System.out.print(season+"="+season.ordinal()+"; "); // 输出: SPRING=0; SUMMER=1; AUTUMN=2; WINTER=3;
18 }
19
20 // 3.获取该类型相应的Class对象
21 System.out.println(Season.SPRING.getDeclaringClass()); // 输出: class enums.Season
22 System.out.println(Season.SPRING.getClass()); // 输出: class enums.Season
23
24 // 4. 按声明序号比较两个枚举常量
25 System.out.println(Season.SPRING.compareTo(Season.SUMMER)); // -1
26 System.out.println(Season.AUTUMN.compareTo(Season.SUMMER)); // 1
27
28 // 5. 返回指定名称的枚举常量
29 // 通过Enum类
30 Season name3 = Enum.valueOf(Season.class, "SUMMER");
31 System.out.println(name3); // 输出:SUMMER
32 Season name4 = Enum.valueOf(Season.class, "P");
33 System.out.println(name4); // 抛出异常: java.lang.IllegalArgumentException
34 // 通过本类
35 System.out.println(Season.valueOf("WINTER")); //输出: WINTER
36 System.out.println(Season.valueOf("P")); // 抛出异常: java.lang.IllegalArgumentException
37
38
39 // 6. 多态引用
40 Enum<Season> p = Season.SPRING;
41 System.out.println(p.getClass()); // 输出 : class enums.Season
42 System.out.println(p.getDeclaringClass()); // 输出 : class enums.Season
43 }// 输出 : class enums.Season
44 }
注意:在获取一个枚举对象所属的Class对象时,应该使用getDeclaringClass()方法,而不是getClass方法,因为有时候getClass方法返回的类型并不准确
enum Week {
WEEKDAY {
@Override
public void fun() {
System.out.println("工作日");
}
},
WEEKEND {
@Override
public void fun() {
System.out.println("休息日");
}
};
public abstract void fun();
}
public class WeekTest {
public static void main(String[] args) {
String name = Week.WEEKDAY.getClass().getName();
String name2 = Week.WEEKEND.getClass().getName();
System.out.println(name); // enums.Week$1
System.out.println(name2); // enums.Week$2
String name3 = Week.WEEKDAY.getDeclaringClass().getName();
String name4 = Week.WEEKEND.getDeclaringClass().getName();
System.out.println(name3); // enums.Week
System.out.println(name4); // enums.Week
}
}
高级用法
枚举类中也可以定义属性,构造函数,和方法,定义构造函数时比较特殊,必须是私有的.一旦定义了有参的构造函数,声明枚举常量时,就必须使用这个构造函数.
1 public enum Season {
2 SPRING("春天"),SUMMER("夏天"),AUTUMN("秋天"),WINTER("冬天");
3
4 private String name;
5
6 private Season(String name) {
7 this.name = name;
8 }
9 public String getName() {
10 return name;
11 }
12 }
由于自定义的枚举类是final修饰的,所以不能拓展其他的类,但是可以在枚举类中定义抽象方法,这个抽象方法在声明枚举常量时必须被实现
1 public enum Season {
2 SPRING {
3 @Override
4 public void fun() {
5 System.out.println("这是春天");
6 }
7 },SUMMER {
8 @Override
9 public void fun() {
10 System.out.println("这是夏天");
11
12 }
13 },AUTUMN {
14 @Override
15 public void fun() {
16 System.out.println("这是秋天");
17
18 }
19 },WINTER {
20 @Override
21 public void fun() {
22 System.out.println("这是冬天");
23 }
24 };
25
26 public abstract void fun();
27 }
枚举类也可以实现接口
1 interface Maxable<T> {
2 public T getMax();
3 }
4
5 public enum Season implements Maxable<Season> {
6 SPRING, SUMMER, AUTUMN, WINTER;
7
8 @Override
9 public Season getMax() {
10 int maxIndex = Season.values().length - 1;
11 return values()[maxIndex];
12 }
13 }
另一种实现接口的方式
1 enum Sortord implements Comparator<Integer> {
2 BIG_TO_SMALL("从大到小") {
3 @Override
4 public int compare(Integer o1, Integer o2) {
5 return -o1.compareTo(o2);
6 }
7 },
8 SMALL_TO_BIG("从小到大") {
9 @Override
10 public int compare(Integer o1, Integer o2) {
11 return o1.compareTo(o2);
12 }
13 };
14
15 private String way;
16 private Sortord(String way) {
17 this.way = way;
18 }
19 }
20
21 public class TestSortord {
22 public static void main(String[] args) {
23 Integer[] arr = new Integer[10];
24 for (int i = 0; i < arr.length; i++) {
25 arr[i] = new Integer((int) (Math.random() * 20));
26 }
27 System.out.println("原数组为:" + Arrays.toString(arr));
28 // 从大到小排序
29 Arrays.parallelSort(arr, Sortord.BIG_TO_SMALL);
30 System.out.println("从大到小排序为:" + Arrays.toString(arr));
31
32 // 从小到大排序
33 Arrays.parallelSort(arr, Sortord.SMALL_TO_BIG);
34 System.out.println("从小到大排序为:" + Arrays.toString(arr));
35 }
36 }
枚举类还可以作为内部类使用,也就是说它可以嵌套在类中,接口中,甚至枚举类还可以嵌套在枚举类内.注意枚举类作为内部类都是静态内部类.
由于在接口中的变量和方法都是public修饰的,所以接口中的枚举类都是public修饰的
1 public interface Week{
2 enum WeekDay{
3 Monday, Tuesday, Wednesday, Thursday;
4 }
5 enum WeekEnd{
6 Friday,Saturday;
7 }
8 }
嵌套在类中或枚举类中的枚举类可以使用public,protected,默认修饰符,private修饰
1 public class Week{
2 enum WeekDay{
3 Monday, Tuesday, Wednesday, Thursday;
4 }
5 enum WeekEnd{
6 Friday,Saturday;
7 }
8 }
1 public enum Week{
2 HOLiDAY;
3
4 public enum WeekDay{
5 Monday, Tuesday, Wednesday, Thursday;
6 }
7 protected enum WeekEnd{
8 Friday,Saturday;
9 }
10 }
EnumSet和EnumMap
EnumSet是一个存储同一枚举类型元素的高效集合,它的底层是用位序列实现的,(这里不讨论它的底层实现细节,只是简单的学习一下它的用法(主要是看不懂,哭唧唧)),它的继承结构如图
JumboEnumSet使用long数组实现,RegularEnumSet使用long实现.从图中我们可以看出,EnumSet是一个抽象类,无法通过new创建实例,而JumboEnumSet和RegularEnumSet两个类都是包可见的.我们也不能使用.但是可以通过EnumSet的静态工厂方法来得到一个EnumSet的实现类对象,我们并不关心具体的类型是属于JumboEnumSet还是属于RegularEnumSet类型的.下面我们来使用一下EnumSet
1 public class EnumSetDemo {
2 public static void main(String[] args) {
3 // 0. 使用枚举类创建一个EnumSet
4 EnumSet<Season> allOf = EnumSet.allOf(Season.class);
5 System.out.println(allOf); // [SPRING, SUMMER, AUTUMN, WINTER]
6
7 // 1. 创建指定枚举类型的空EnumSet
8 EnumSet<Season> noneOf = EnumSet.noneOf(Season.class);
9 System.out.println(noneOf); // []
10 // 添加元素
11 noneOf.add(Season.SPRING);
12 noneOf.add(Season.SUMMER);
13 noneOf.add(Season.AUTUMN);
14 System.out.println(noneOf); // [SPRING, SUMMER, AUTUMN]
15 // 移除元素
16 noneOf.remove(Season.SPRING);
17 System.out.println(noneOf); // [SUMMER, AUTUMN]
18
19 // 2. 创建一个包含指定元素类型,使用EnumSet.of方法,这个方法有六个重载方法
20 EnumSet<Season> of = EnumSet.of(Season.SPRING,Season.AUTUMN,Season.SUMMER);
21 System.out.println(of); // [SPRING, SUMMER, AUTUMN]
22
23 // 3. 创建一个从指定枚举常量到指定枚举常量范围内所有元素的EnumSet
24 EnumSet<Season> range = EnumSet.range(Season.SUMMER, Season.WINTER);
25 System.out.println(range); // [SUMMER, AUTUMN, WINTER]
26
27 // 4. 创建一个和其他EnumSet具有相同枚举类型的EnumSet
28 EnumSet<Season> copyOf = EnumSet.copyOf(range);
29 EnumSet<Season> complementOf = EnumSet.complementOf(noneOf);
30 System.out.println(complementOf); // [SPRING, WINTER]
31 System.out.println(copyOf); //[SUMMER, AUTUMN, WINTER]
32 }
33 }
EnumMap是一个键类型为同一枚举类型的映射,底层使用值数组高效实现的.枚举映射根据键的自然顺序(即枚举声明时的顺序)来维护的.下面来使用一下EnumMap
1 public class EnumMapDemo {
2 public static void main(String[] args) {
3 // 0. 使用指定枚举类型作为键创建一个空EnumMap
4 EnumMap<Season, String> enumMap = new EnumMap<Season, String>(Season.class);
5 System.out.println(enumMap); // {}
6
7 // 1.添加
8 enumMap.put(Season.SPRING, "春天");
9 enumMap.put(Season.SUMMER, "夏天");
10 enumMap.put(Season.AUTUMN, "秋天");
11 enumMap.put(Season.WINTER, "冬天");
12
13 // 2. 获取键的Set视图
14 Set<Season> keySet = enumMap.keySet();
15
16 // 3.获取值的Set视图
17 Collection<String> values = enumMap.values();
18
19 // 4. 获取映射中包含的映射关系的Set视图
20 Set<Entry<Season, String>> entrySet = enumMap.entrySet();
21 for (Entry<Season, String> entry : entrySet) {
22 System.out.print(entry.getKey()+"="+entry.getValue()+", ");
23 // SPRING=春天, SUMMER=夏天, AUTUMN=秋天, WINTER=冬天,
24 }
25
26 // 5.移除键指定的映射关系
27 enumMap.remove(Season.SPRING);
28 System.out.println(enumMap); //{SUMMER=夏天, AUTUMN=秋天, WINTER=冬天}
29
30 // 6. 创建一个和指定EnumMap键类型相同的EnumMap,它包含指定EnumMap中的映射关系
31 EnumMap<Season, String> enumMap2 = new EnumMap<Season, String>(enumMap);
32 System.out.println(enumMap2); // {SUMMER=夏天, AUTUMN=秋天, WINTER=冬天}
33
34
35 Map<Season, String> map = new HashMap<Season, String>();
36 map.put(Season.SPRING,"哈哈");
37 // 7.使用指定的Map创建并初始化一个EnumMap,指定Map的键类型必须是枚举类型
38 EnumMap<Season, String> enumMap3 = new EnumMap<Season, String>(map);
39 System.out.println(enumMap3); // {SPRING=哈哈}
40 }
41 }