java enum枚举类的用法以及高级玩法

yangzhe19931117

已于 2022-11-23 17:24:03 修改

阅读量1.6k

点赞数 2

分类专栏： java 文章标签： java jvm 开发语言

于 2022-11-23 16:18:00 首次发布

本文链接：https://blog.csdn.net/yangzhe19931117/article/details/127995763

版权

java 专栏收录该内容

31 篇文章 1 订阅

订阅专栏

enum(枚举)类介绍

java枚举类是一组预定义常量的集合，使用enum关键字声明这个类，常量名称官方建议大写
1.enum类基本用法
举一个常见的例子，例如星期就可以描述为一个枚举类，如下
public enum Day {

SUNDAY, MONDAY, TUESDAY, WEDNESDAY,THURSDAY, FRIDAY, SATURDAY

}
怎么调用呢，Java switch语句参数就支持enum类

public class EnumTest {

Day day;

public EnumTest(Day day) {
    this.day = day;
}

public void tellItLikeItIs() {
    switch (day) {
        case MONDAY:
            System.out.println("周一各种不在状态");
            break;
                
        case FRIDAY:
            System.out.println("周五感觉还不错");
            break;
        
        //switch的新用法             
        case SATURDAY: case SUNDAY:
            System.out.println("周末给人的感觉是最棒的");
            break;
                    
        default:
            System.out.println("周内感觉就那样吧。。。");
            break;
    }
}

public static void main(String[] args) {
    EnumTest firstDay = new EnumTest(Day.MONDAY);
    firstDay.tellItLikeItIs();
    EnumTest thirdDay = new EnumTest(Day.WEDNESDAY);
    thirdDay.tellItLikeItIs();
    EnumTest fifthDay = new EnumTest(Day.FRIDAY);
    fifthDay.tellItLikeItIs();
    EnumTest sixthDay = new EnumTest(Day.SATURDAY);
    sixthDay.tellItLikeItIs();
    EnumTest seventhDay = new EnumTest(Day.SUNDAY);
    seventhDay.tellItLikeItIs();
}

}
运行结果
在这里插入图片描述

enum类和static常量区别

看了上面的例子，有些小伙伴就嗤之以鼻孔了，这没什么嘛，java静态常量也一样可以办到
public class EnumTest2 {

public static final int MONDAY= 1;
public static final int WEDNESDAY= 3;
public static final int FRIDAY= 5;
public static final int SATURDAY= 6;
public static final int SUNDAY= 7;

public void tellItLikeItIs(int day) {
    switch (day) {
        case 1:
            System.out.println("周一各种不在状态");
            break;

        case 5:
            System.out.println("周五感觉还不错");
            break;

        case 6: case 7:
            System.out.println("周末给人的感觉是最棒的");
            break;

        default:
            System.out.println("周内感觉就那样吧。。。");
            break;
    }
}

public static void main(String[] args) {
    EnumTest2 firstDay = new EnumTest2();
    firstDay.tellItLikeItIs(MONDAY);
    EnumTest2 thirdDay = new EnumTest2();
    thirdDay.tellItLikeItIs(WEDNESDAY);
    EnumTest2 fifthDay = new EnumTest2();
    fifthDay.tellItLikeItIs(FRIDAY);
    EnumTest2 sixthDay = new EnumTest2();
    sixthDay .tellItLikeItIs(SATURDAY);
    EnumTest2 seventhDay = new EnumTest2();
    seventhDay.tellItLikeItIs(SUNDAY);
}

}
在这个使用方式效果上来看是没有区别的，其实enum类的每一个枚举值也是 static final的，但是我们为什么要选择使用enum枚举类呢
1.static方式的静态变量类型不安全，我们可以在调用的时候传入其他值，导致错误
例如： seventhDay.tellItLikeItIs(999);
2.static方式的静态变量不支持属性扩展，每一个key对应一个值，而enum的每一个key可以拥有自己的属性

enum类自定义属性

这就是enum比static静态变量好用的地方了，可以赋予每一个枚举值若干个属性，例如
public enum Day {

MONDAY(1, "星期一", "星期一各种不在状态"),
TUESDAY(2, "星期二", "星期二依旧犯困"),
WEDNESDAY(3, "星期三", "星期三感觉半周终于过去了"),
THURSDAY(4, "星期四", "星期四期待这星期五"),
FRIDAY(5, "星期五", "星期五感觉还不错"),
SATURDAY(6, "星期六", "星期六感觉非常好"),
SUNDAY(7, "星期日", "星期日感觉周末还没过够。。。");

Day(int index, String name, String value) {
    this.index = index;
    this.name = name;
    this.value = value;
}

private int index;
private String name;
private String value;

public int getIndex() {
    return index;
}

public void setIndex(int index) {
    this.index = index;
}

public String getName() {
    return name;
}

public void setName(String name) {
    this.name = name;
}

public String getValue() {
    return value;
}

public void setValue(String value) {
    this.value = value;
}

}
这次测试类就有些些变化了，更灵活了
public class EnumTest {

Day day;

public EnumTest(Day day) {
    this.day = day;
}

public void tellItLikeItIs() {
    switch (day) {
        case MONDAY:
            System.out.println(day.getName()+day.getValue());
            break;

        case FRIDAY:
            System.out.println(day.getName()+day.getValue());
            break;

        case SATURDAY: case SUNDAY:
            System.out.println(day.getName()+day.getValue());
            break;

        default:
            System.out.println(day.getName()+day.getValue());
            break;
    }
}

public static void main(String[] args) {
    EnumTest firstDay = new EnumTest(Day.MONDAY);
    firstDay.tellItLikeItIs();
    EnumTest thirdDay = new EnumTest(Day.WEDNESDAY);
    thirdDay.tellItLikeItIs();
    EnumTest fifthDay = new EnumTest(Day.FRIDAY);
    fifthDay.tellItLikeItIs();
    EnumTest sixthDay = new EnumTest(Day.SATURDAY);
    sixthDay.tellItLikeItIs();
    EnumTest seventhDay = new EnumTest(Day.SUNDAY);
    seventhDay.tellItLikeItIs();
}

}
执行结果
在这里插入图片描述

enum类高级玩法

你以为enum这样就完了么，还有更好玩的东西，每一个enum枚举值还可以拥有各自的内部方法！二话不说，上栗子
public enum Day {

MONDAY(1, "星期一", "各种不在状态"){
    @Override
    public Day getNext() {
        return TUESDAY;
    }
},
TUESDAY(2, "星期二", "依旧犯困"){
    @Override
    public Day getNext() {
        return WEDNESDAY;
    }
},
WEDNESDAY(3, "星期三", "感觉半周终于过去了"){
    @Override
    public Day getNext() {
        return THURSDAY;
    }
},
THURSDAY(4, "星期四", "期待这星期五"){
    @Override
    public Day getNext() {
        return FRIDAY;
    }
},
FRIDAY(5, "星期五", "感觉还不错"){
    @Override
    public Day getNext() {
        return SATURDAY;
    }
},
SATURDAY(6, "星期六", "感觉非常好"){
    @Override
    public Day getNext() {
        return SUNDAY;
    }
},
SUNDAY(7, "星期日", "感觉周末还没过够。。。"){
    @Override
    public Day getNext() {
        return MONDAY;
    }
};

Day(int index, String name, String value) {
    this.index = index;
    this.name = name;
    this.value = value;
}

private int index;
private String name;
private String value;
public abstract Day getNext();

public int getIndex() {
    return index;
}

public void setIndex(int index) {
    this.index = index;
}

public String getName() {
    return name;
}

public void setName(String name) {
    this.name = name;
}

public String getValue() {
    return value;
}

public void setValue(String value) {
    this.value = value;
}

}
调用下看看
public class EnumTest {

Day day;

public EnumTest(Day day) {
    this.day = day;
}

public void tellItLikeItIs() {
    switch (day) {
        case MONDAY:
            System.out.println(day.getName()+day.getValue());
            System.out.println(day.getName()+"的下一天是"+day.getNext().getName());
            break;

        case FRIDAY:
            System.out.println(day.getName()+day.getValue());
            System.out.println(day.getName()+"的下一天是"+day.getNext().getName());
            break;

        case SATURDAY: case SUNDAY:
            System.out.println(day.getName()+day.getValue());
            System.out.println(day.getName()+"的下一天是"+day.getNext().getName());
            break;

        default:
            System.out.println(day.getName()+day.getValue());
            System.out.println(day.getName()+"的下一天是"+day.getNext().getName());
            break;
    }
}

public static void main(String[] args) {
    EnumTest firstDay = new EnumTest(Day.MONDAY);
    firstDay.tellItLikeItIs();
    EnumTest thirdDay = new EnumTest(Day.WEDNESDAY);
    thirdDay.tellItLikeItIs();
    EnumTest fifthDay = new EnumTest(Day.FRIDAY);
    fifthDay.tellItLikeItIs();
    EnumTest sixthDay = new EnumTest(Day.SATURDAY);
    sixthDay.tellItLikeItIs();
    EnumTest seventhDay = new EnumTest(Day.SUNDAY);
    seventhDay.tellItLikeItIs();
}

}

执行结果
在这里插入图片描述
作为一种长度固定，数据未定的一种存储数据集的数据类型，枚举类有如下方法可供参考

普通类型的枚举类的创建

protected enum ColorEnum{

    red,orange,yellow,green,blue,purple;

}

非普通类型的枚举类的创建

public enum SeasonEnum{

    spring,summer,fall,winter;
    private final static String position="test";
    
    public static SeasonEnum getSeason(){
        if(position.equals("test")){
            return summer;
        }else{
            return winter;
        }
    }

}
其中作为属性的position便是外界对此枚举类操作的一个“算子”，当然也可以用普通的枚举方式来对枚举进行处理

然后是带有构造器的枚举类的使用

需要注意的是，在使用构造器的时候，要带参数就都带，否则就都不带，因为声明了带参数的构造器后，默认的无参的构造器将不再起作用
public enum GenderEnum{

    MAN("MAN"),WOMAN("WOMAN");
    
    //代表一个成员变量，便于赋值和获取数据
    private String value;
    
    GenderEnum(String gender){
        this.value=gender;
    }
    //成员变量值的get方法
    public String getValue(){
        return value;
    }

}

带有抽象方法的枚举类的使用

public enum PersonInfo{

    NAME{
    public String getName()
      {
        return "S**";
      }
    },
    AGE{
    public String  getName()
      {
        return "**";
      }
    },
    ADDRESS{
    public String getName()
      { 
        return "*南省**市**县";
      }
    },
    E_MAIL{
    public String getName()
      {
        return "1064*****2@qq.com";
      }
    };
    //这个方法就是一个抽象的方法
    public abstract String getName();

}
下面是一个具体的小例子：

package Enum;

public enum WeekDay {

MONDAY("周一") {

    @Override
    public String getInfo() {
        // TODO Auto-generated method stub
        return this.getValue();
    }

},
TWESDAY("周二") {

    @Override
    public String getInfo() {
        // TODO Auto-generated method stub
        return this.getValue();
    }

},
WENDESDAY("周三") {

    @Override
    public String getInfo() {
        // TODO Auto-generated method stub
        return this.getValue();
    }

},
YHURSDAY("周四") {

    @Override
    public String getInfo() {
        // TODO Auto-generated method stub
        return this.getValue();
    }

},
FRIDAY("周五") {

    @Override
    public String getInfo() {
        // TODO Auto-generated method stub
        return this.getValue();
    }

},
SATASDAY("周六") {

    @Override
    public String getInfo() {
        // TODO Auto-generated method stub
        return this.getValue();
    }

},
SUNDAY("周日") {

    @Override
    public String getInfo() {
        // TODO Auto-generated method stub
        return this.getValue();
    }
};

private final String value;

public String getValue() {
    return value;
}

private WeekDay(String value) {
    this.value = value;
}

public static WeekDay getValueOf(String value) {

    for (WeekDay day : WeekDay.values()) {
        if (day.getValue().equals(value)) {
            return day;
        }
    }
    throw new IllegalArgumentException("No matching for [" + value + "]");
}

public abstract String getInfo();

public static void main(String[] args) {
    System.out.println(WeekDay.FRIDAY.getInfo());
    System.out.println(getValueOf("周三"));
}

}

程序输出结果：

周五
WENDESDAY

总结：

其实枚举也就是一个特殊的类，其中的实例就是其对象，其中的成员变量和成员函数也都是属于每一个实例。
通过这样的方式，我们就可以使枚举类拥有更多的信息（如果只设置一个实例，那么这就是一个单例模式的较好的体现，可以保证在内存中只有一个这样的对象存在！
对每一个实例都实现了抽象的方法的目的就是让每一个对象携带自身具备的唯一的信息。