系列文章目录

---

---

前言

类可以作为常量使用。

---

一、枚举

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

枚举的实现方式
自定义类实现枚举
使用 enum 关键字实现枚举

枚举使用细则
不需要提供setXxx方法，因为枚举对象值通常为只读
对枚举对象/属性使用final + static 共同修饰，实现底层优化
枚举对象通常使用全部大写，常量的命名规范
枚举对象根须需要也可以有多个属性

自定义类实现枚举
1.构造器私有化
2.本类内部创建一组对象[四个 春夏秋冬]
3.对外暴露对象（通过为对象添加 public final static 修饰符）
4.可以提供 get 方法， 但是不要提供 set

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 + '\'' +
		'}';
	}
	
}

enum 关键字实现枚举使用细则
1) 当我们使用 enum 关键字开发一个枚举类时， 默认会继承 Enum 类, 而且是一个 final 类[如何证明],老师使用 javap 工具来演示
2) 传统的 public static final Season2 SPRING = new Season2(“春天”, “温暖”); 简化成 SPRING(“春天”, “温暖”)， 这里必须知道， 它调用的是哪个构造器.
3) 如果使用无参构造器 创建 枚举对象， 则实参列表和小括号都可以省略
4) 当有多个枚举对象时， 使用逗号间隔， 最后有一个分号结尾
5) 枚举对象必须放在枚举类的行首.

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 + '\'' +
		'}';
	}
	
}

java编译与反编译
源文件编译成字节码文件：javac
字节码文件反编译成源文件：javap

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

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

enum常用方法	作用
toString	Enum类已经重写过了返回的是当前对象名，子类可以重写该方法， 用于返回对象的属性信息
name	返回当前对象名（常量名） ， 子类中不能重写
ordinal	返回当前对象的位置号， 默认从 0 开始
values	返回当前枚举类中所有的常量
valueOf	将字符串转换成枚举对象， 要求字符串必须为已有的常量名， 否则报异常
compareTo	比较两个枚举常量， 比较的就是编号，编号相减

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);
		// }
		
	}
}

enum实现接口
使用 enum 关键字后， 就不能再继承其它类了， 因为 enum 会隐式继承 Enum， 而 Java 是单继承机制
枚举类和普通类一样， 可以实现接口

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

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("播放好听的音乐...");
	}
}

---

总结

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