第八章：枚举

系列文章目录

---

---

前言

类可以作为常量使用。

---

一、枚举

枚举是一组常量的集合。可以这里理解： 枚举属于一种特殊的类， 里面只包含一组有限的特定的对象。

public class Enumeration02 {
	public static void main(String[] args) {
		System.out.println(Season.AUTUMN);
		System.out.println(Season.SPRING);
	}
} 
//演示字定义枚举实现
class Season {//类
	private String name;
	private String desc;//描述

	//定义了四个对象, 固定.
	public static final Season SPRING = new Season("春天", "温暖");
	public static final Season WINTER = new Season("冬天", "寒冷");
	public static final Season AUTUMN = new Season("秋天", "凉爽");
	public static final Season SUMMER = new Season("夏天", "炎热");

	//1. 将构造器私有化,目的防止 直接 new
	//2. 去掉 setXxx 方法, 防止属性被修改
	//3. 在 Season 内部， 直接创建固定的对象
	//4. 优化， 可以加入 final 修饰符
	private Season(String name, String desc) {
		this.name = name;
		this.desc = desc;
	}
	
	public String getName() {
		return name;
	} 
	
	public String getDesc() {
		return desc;
	} 
	
	@Override
	public String toString() {
		return "Season{" +
		"name='" + name + '\'' +
		", desc='" + desc + '\'' +
		'}';
	}
	
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

public class Enumeration03 {
	public static void main(String[] args) {
		System.out.println(Season2.AUTUMN);
		System.out.println(Season2.SUMMER);
	}
} 

//演示使用 enum 关键字来实现枚举类
enum Season2 {//类
	//定义了四个对象, 固定.
	// public static final Season SPRING = new Season("春天", "温暖");
	// public static final Season WINTER = new Season("冬天", "寒冷");
	// public static final Season AUTUMN = new Season("秋天", "凉爽");
	// public static final Season SUMMER = new Season("夏天", "炎热");
	//如果使用了 enum 来实现枚举类
	//1. 使用关键字 enum 替代 class
	//2. public static final Season SPRING = new Season("春天", "温暖") 直接使用
	// SPRING("春天", "温暖") 解读 常量名(实参列表)
	//3. 如果有多个常量(对象)， 使用 ,号间隔即可
	//4. 如果使用 enum 来实现枚举， 要求将定义常量对象， 写在前面
	//5. 如果我们使用的是无参构造器， 创建常量对象， 则可以省略 ()
	SPRING("春天", "温暖"), WINTER("冬天", "寒冷"), AUTUMN("秋天", "凉爽"),
	SUMMER("夏天", "炎热"),//调用有参构造器
	WAHT()/WAHT;//调用无参构造器
	private String name;
	private String desc;//描述
	
	private Season2()//无参构造器
	{
	
	} 
	
	private Season2(String name, String desc) {
		this.name = name;
		this.desc = desc;
	}
	
	public String getName() {
		return name;
	} 
	
	public String getDesc() {
		return desc;
	} 
	
	@Override
	public String toString() {
		return "Season{" +
		"name='" + name + '\'' +
		", desc='" + desc + '\'' +
		'}';
	}
	
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

使用关键字 enum 时， 会隐式继承 Enum 类, 这样我们就可以使用 Enum 类相关的方法。

public abstract class Enum<E extends Enum<E>>
	implements Comparable<E>, Serializable {
}
1
2
3

public class EnumMethod {
	public static void main(String[] args) {
	
		//使用 Season2 枚举类， 来演示各种方法
		Season2 autumn = Season2.AUTUMN;
		
		//输出枚举对象的名字
		System.out.println(autumn.name());
		
		//ordinal() 输出的是该枚举对象的次序/编号， 从 0 开始编号
		//AUTUMN 枚举对象是第三个， 因此输出 2
		System.out.println(autumn.ordinal());
		
		//从反编译可以看出 values 方法， 返回 Season2[]
		//含有定义的所有枚举对象
		Season2[] values = Season2.values();
		System.out.println("===遍历取出枚举对象(增强 for)====");
		for (Season2 season: values) {//增强 for 循环
			System.out.println(season);
		} 
		
		//valueOf：将字符串转换成枚举对象， 要求字符串必须为已有的常量名， 否则报异常
		//执行流程
		//1. 根据你输入的 "AUTUMN" 到 Season2 的枚举对象去查找
		//2. 如果找到了， 就返回， 如果没有找到， 就报错
		Season2 autumn1 = Season2.valueOf("AUTUMN");
		System.out.println("autumn1=" + autumn1);
		System.out.println(autumn == autumn1);
		
		//compareTo： 比较两个枚举常量， 比较的就是编号
		//老韩解读
		//1. 就是把 Season2.AUTUMN 枚举对象的编号 和 Season2.SUMMER 枚举对象的编号比较
		//2. 看看结果
		/*
		public final int compareTo(E o) {
			return self.ordinal - other.ordinal;
		} 
		Season2.AUTUMN 的编号[2] - Season2.SUMMER 的编号[3]
		*/
		
		System.out.println(Season2.AUTUMN.compareTo(Season2.SUMMER));


		
		//普通的 for 循环
		// System.out.println("=====普通的 for=====");
		// for (int i = 0; i < nums.length; i++) {
		// 		System.out.println(nums[i]);
		// }
		//增强的 for 循环
		
		// System.out.println("=====增强的 for=====");
		// //执行流程是 依次从 nums 数组中取出数据， 赋给 i, 如果取出完毕， 则退出 for
		// for(int i : nums) {
		// 		System.out.println("i=" + i);
		// }
		
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

enum 类名 implements 接口 1， 接口 2{}

1
2
3

public class EnumDetail {

	public static void main(String[] args) {
		Music.CLASSICMUSIC.playing();
	}
} 
class A 
{
	
} 
//1.使用 enum 关键字后， 就不能再继承其它类了， 因为 enum 会隐式继承 Enum， 而 Java 是单继承机制
//enum Season3 extends A {
//
//}
//2.enum 实现的枚举类， 仍然是一个类， 所以还是可以实现接口的.

interface IPlaying {
	public void playing();
} 

enum Music implements IPlaying {
	CLASSICMUSIC;
	
	@Override
	public void playing() {
		System.out.println("播放好听的音乐...");
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

---

总结

枚举对象就是类作为常量的方式。