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

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

运行结果

EnumTest类运行结果.png

2.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可以拥有自己的属性

3.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();
    }
}

执行结果

EnumTest类运行结果.png

4.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();
    }
}

执行结果

EnumTest类运行结果.png

作为一种长度固定，数据未定的一种存储数据集的数据类型，枚举类有如下方法可供参考。

普通类型的枚举类的创建

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 test;

public class Test {

    public static void main(String[] args) {
        System.out.println(WeekDay.FRIDAY.getInfo());
    }
}
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 String value;
    public String getValue() {
        return value;
    }

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

程序输出结果：

周五

小总结：

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

总结：
对于枚举类的使用，有普通类型，带有变化属性，带有构造器，带有抽象方法的枚举等等。各有各的特点，使用的时候视情况而定!还可以应用于单态模式，岂不快哉？

posted @ 2022-03-11 22:40 方东信阅读(8345) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· 【JVM类加载及字节码技术】编译期处理-语法糖-构造、泛型、拆装箱（一）

· Java常见的几种设计模式

· 10 | JAVA枚举类enum

· Java 枚举类的简单介绍

· 枚举、Math工具类、Random工具类常用用法

阅读排行：
· 25岁的心里话
· 闲置电脑爆改个人服务器（超详细） #公网映射 #Vmware虚拟网络编辑器
· 基于 Docker 搭建 FRP 内网穿透开源项目（很简单哒）
· 零经验选手，Compose 一天开发一款小游戏！
· 一起来玩mcp_server_sqlite，让AI帮你做增删改查！！

历史上的今天：
2018-03-11 windows 下OPENSSL 生成秘钥和公钥的方法

方东信

人无远虑必有近忧,生于忧患死于安乐
专业，专注，精益求精

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

enum(枚举)类介绍

1.enum类基本用法

2.enum类和static常量区别

3.enum类自定义属性

4.enum类高级玩法

公告

搜索

我的标签

随笔分类

C++

hotspot源码分析

大数据

阅读排行榜

最新评论

方东信

人无远虑 必有近忧,生于忧患死于安乐 专业，专注，精益求精

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

enum(枚举)类介绍

1.enum类基本用法

2.enum类和static常量区别

3.enum类自定义属性

4.enum类高级玩法

公告

搜索

我的标签

随笔分类

C++

hotspot源码分析

大数据

阅读排行榜

最新评论

人无远虑必有近忧,生于忧患死于安乐
专业，专注，精益求精