Java 枚举(enum)
目录
前言
一、枚举是什么？
二、枚举的定义
1.自定义枚举类
2.enum关键字创建枚举类
三、自定义枚举类
1、步骤
2、代码
3、使用
三、enum定义枚举类
1、定义
2、使用
3、 switch 中使用枚举类
4、有关构造函数
5、实现接口的枚举类
6、有抽象方法的枚举类
前言
本篇内容是对Java中的枚举类进行学习记录
一、枚举是什么？
Java 枚举是一个特殊的类，一般表示一组常量，比如一年的 4 个季节，一个年的 12 个月份，一个星期的 7 天，方向有东南西等等。对于值的数量是有限并且是确定的情况，我们推荐使用枚举类
二、枚举的定义
1.自定义枚举类
JDK1.5之前如果要使用枚举类，则需要我们自定定义
2.enum关键字创建枚举类
JDK1.5新增的enum关键字用于定义枚举类
三、自定义枚举类
1、步骤
(1)、定义成员变量,变量需要是私有的并且不可变
(2)、定义有参构造函数，并且为私用，这样就可以保证在其他类中无法创建该枚举类
(3)、提供枚举的多个对象，即该枚举所含有的值
2、代码
public class State {
//1、定义成员变量,变量需要是私有的并且不可变
private final String code;
private final String desc;
//2、定义有参构造函数，并且为私用，这样就可以保证在其他类中无法创建该枚举类
private State(String code,String desc){
this.code=code;
this.desc=desc;
}
//3、提供枚举的多个对象，即该枚举所含有的值
public static final State ADD = new State("0","新增");
public static final State UPDATE = new State("1","更新");
public static final State DEL = new State("2","删除");
//4、其他方法
//获取枚举对应的值
public String code(){
return code;
}
//获取枚举对应的值的说明
public String desc(){
return desc;
}
}
3、使用
public static void main(String[] args) {
//使用场景1，直接根据对象比较是否相同
MessageTest mt = new MessageTest();
mt.setBody("xxxxxx");
mt.setType("xml");
mt.setState(State.UPDATE);
if(State.ADD==mt.getState()){
System.out.println("业务逻辑");
}
//使用场景2，根据每个枚举值判断
if("0".equals(State.ADD.code())){
System.out.println("业务逻辑");
}
}如果直接根据对象进行比较的话，其实枚举类中就不需要定义成员变量了
public class State {
//2、定义有参构造函数，并且为私用，这样就可以保证在其他类中无法创建该枚举类
private State(){
}
//3、提供枚举的多个对象，即该枚举所含有的值
public static final State ADD = new State();
public static final State UPDATE = new State();
public static final State DEL = new State();
}
三、enum定义枚举类
1、定义
public enum Color
{
RED, GREEN, BLUE;
}public enum Action {
//枚举的定义需要在类中的第一行代码
ADD("0", "新增"),
UPDATE("1", "更新"),
DELETE("2", "取消/删除"),
ZERO("0", "零"),
ONE("1", "壹");
private String value;
private String label;
//如果枚举值中还有数据则必须要创建一个构造函数
Action(String value, String label) {
this.value = value;
this.label = label;
}
public String value() {
return value;
}
public String label() {
return label;
}
}如果需要的话可以为枚举类中添加构造函数，方法，字段，并且构造函数必须是私有的private， private修饰符对于构造器是可以省略的，但这不代表构造器的权限是默认权限。注意如果枚举值中含有值则必须要创建构造函数，以便枚举类创建的时候调用构造函数赋值。
2、使用
使用enum定义的枚举类默认继承了java.lang.Enum类，因此不能再继承其他类。
Enum类的主要方法：
| 方法修饰 | 方法名 | 说明 |
|---|---|---|
| public final String | name() | 得到此枚举常量的名称，建议优先使用toString方法而不是这个方法，因为 toString 方法可能会返回一个更友好的名称 |
| public final int | ordinal() | 得到此枚举常量的声明次序，从0开始 |
| public String | toString() | 得到此枚举常量的名称,子类可以覆盖 |
| public final boolean | equals(Object other) | 如果指定的对象等于此枚举常量，则返回 true,该方法不能重写，该方法内部实现是 return this==other |
| public final int | hashCode() | 返回此枚举常量的哈希码 |
| protected final Object | clone() | final这保证了枚举永远不会被克隆,该方法体中只是抛出了CloneNotSupportedException异常，其他没有做 |
| public final int | compareTo(E o) | 实现了Comparable接口，该方法比较两个枚举常量的大小（按照枚举常量的声明顺序即ordinal属性排序） |
| public final Class |
getDeclaringClass() | 返回与此枚举常量的枚举类型对应的 Class 对象 |
| public static |
valueOf(Class |
返回具有指定名称的指定枚举类型的枚举常量。 该名称必须与用于在此类型中声明枚举常量的标识符完全匹配 |
| valueOf(String name) | 根据传参返回指定的枚举常量，要求名字是对应的枚举常量名称，如果不是的话会报异常 | |
| values() | 返回枚举类的枚举常量的数组 |
方法演示
public static void main(String[] args) {
Action update = Action.UPDATE;
System.out.println(update.name()); //UPDATE
System.out.println(update.ordinal()); //1
System.out.println(update.toString());//UPDATE
//调用的也是toString
System.out.println(update);//UPDATE
Action update1 = Action.UPDATE;
Action add = Action.ADD;
System.out.println(update.equals(update1));//true
System.out.println(update.equals(add));//false
System.out.println(update.compareTo(update1));//0
System.out.println(update.compareTo(add));//1
System.out.println(update.getDeclaringClass());//class com.lcg.javabase.enumtest.Action
System.out.println(add.getDeclaringClass());//class com.lcg.javabase.enumtest.Action
Action delete = Action.valueOf(Action.class, "DELETE");
System.out.println(delete);//DELETE
Action zero = Action.valueOf("ZERO");
System.out.println(zero);//ZERO
Action[] values = Action.values();
for(Action action :values){
System.out.println(action);
}
/**
* ADD
* UPDATE
* DELETE
* ZERO
* ONE
*/
}3、 switch 中使用枚举类
enum Color
{
RED, GREEN, BLUE;
}
public class MyClass {
public static void main(String[] args) {
Color myVar = Color.BLUE;
switch(myVar) {
case RED:
System.out.println("红色");
break;
case GREEN:
System.out.println("绿色");
break;
case BLUE:
System.out.println("蓝色");
break;
}
}
}
//结果：蓝色4、有关构造函数
在枚举类创建的时候会调用构造函数，枚举类有几个枚举常量，就调用几次，也就是说针对枚举类，每个枚举常量其实就对应枚举类的一个对象
public enum Action {
ADD("0", "新增"),
UPDATE("1", "更新"),
DELETE("2", "取消/删除"),
ZERO("0", "零"),
ONE("1", "壹");
private String value;
private String label;
//如果枚举值中还有数据则必须要创建一个构造函数
private Action(String value, String label) {
System.out.println(value+":"+label);
this.value = value;
this.label = label;
}
public String value() {
return value;
}
public String label() {
return label;
}
}
public static void main(String[] args) {
Action update = Action.UPDATE;
/**
* 0:新增
* 1:更新
* 2:取消/删除
* 0:零
* 1:壹
*/
}
5、实现接口的枚举类
使用enum定义的枚举类默认继承了java.lang.Enum类，因此不能再继承其他类，但枚举类可以实现一个或多个接口
1、若每个枚举常量在调用实现的接口方法呈现相同的行为方式，则只要统一实现该方法即可。
public enum Action implements Info{
ADD("0", "新增"),
UPDATE("1", "更新"),
DELETE("2", "取消/删除"),
ZERO("0", "零"),
ONE("1", "壹");
private String value;
private String label;
//如果枚举值中还有数据则必须要创建一个构造函数
private Action(String value, String label) {
System.out.println(value+":"+label);
this.value = value;
this.label = label;
}
public String value() {
return value;
}
public String label() {
return label;
}
@Override
public void info() {
System.out.println("统一实现该方法");
}
}
interface Info{
void info();
}
public static void main(String[] args) {
Action update = Action.UPDATE;
update.info();
/**
* 0:新增
* 1:更新
* 2:取消/删除
* 0:零
* 1:壹
* 统一实现该方法
*/
}
2、若需要每个枚举常量在调用实现的接口方法呈现出不同的行为方式，则可以让每个枚举常量分别来实现该方法
public enum Action implements Info{
ADD("0", "新增"){
@Override
public void info() {
super.info();
System.out.println("每个枚举常量分别实现方法"+":"+this.label());
}
},
UPDATE("1", "更新"),
DELETE("2", "取消/删除"),
ZERO("0", "零"),
ONE("1", "壹");
private String value;
private String label;
//如果枚举值中还有数据则必须要创建一个构造函数
private Action(String value, String label) {
System.out.println(value+":"+label);
this.value = value;
this.label = label;
}
public String value() {
return value;
}
public String label() {
return label;
}
@Override
public void info() {
System.out.println("统一实现该方法");
}
}
interface Info{
void info();
}
public static void main(String[] args) {
Action add = Action.ADD;
add.info();
/**
* 0:新增
* 1:更新
* 2:取消/删除
* 0:零
* 1:壹
* 统一实现该方法
* 每个枚举常量分别实现方法:新增
*/
}6、有抽象方法的枚举类
枚举类中的抽象方法实现，需要枚举类中的每个枚举常量都对其进行实现
public enum Action implements Info{
ADD("0", "新增"){
@Override
public void info() {
super.info();
System.out.println("每个枚举常量分别实现方法"+":"+this.label());
}
@Override
public void msg() {
System.out.println("msg"+this.value()+":"+this.label());
}
},
UPDATE("1", "更新"){
@Override
public void msg() {
System.out.println("msg"+this.value()+":"+this.label());
}
},
DELETE("2", "取消/删除"){
@Override
public void msg() {
System.out.println("msg"+this.value()+":"+this.label());
}
},
ZERO("0", "零"){
@Override
public void msg() {
System.out.println("msg"+this.value()+":"+this.label());
}
},
ONE("1", "壹"){
@Override
public void msg() {
System.out.println("msg"+this.value()+":"+this.label());
}
};
private String value;
private String label;
//如果枚举值中还有数据则必须要创建一个构造函数
private Action(String value, String label) {
System.out.println(value+":"+label);
this.value = value;
this.label = label;
}
public String value() {
return value;
}
public String label() {
return label;
}
@Override
public void info() {
System.out.println("统一实现该方法");
}
public abstract void msg();
}
interface Info{
void info();
}
public static void main(String[] args) {
Action add = Action.ADD;
add.msg();
/**
* 0:新增
* 1:更新
* 2:取消/删除
* 0:零
* 1:壹
* msg0:新增
*/
}