java - enum

最新推荐文章于 2023-07-15 14:17:23 发布

从零开始的JAVA世界

最新推荐文章于 2023-07-15 14:17:23 发布

阅读量971

点赞数

分类专栏： JAVA # j 文章标签：其他 java 开发语言

本文链接：https://blog.csdn.net/ZHHX666/article/details/123753596

版权

JAVA # j 专栏收录该内容

32 篇文章 3 订阅

订阅专栏

文章目录

第一章枚举类型的定义
第二章枚举类型的理解
第三章枚举的方法
第四章枚举类型和普通常量的区别
第四章参考资料

第一章枚举类型的定义

public enum 枚举类名{
	枚举项常量1,枚举项常量2,枚举项常量3;
	
	字段...;
	私有构造器...;
	方法...;
	...
}

//定义一个红绿灯的枚举类
public enum MyEnum {
    RED("red", "停止"),
    //RED常量     等价于 public static final RED = new MyEnum("red","停止");
    
    GREEN("green", "通行"),
    //GREEN常量   等价于 public static final GREEN = new MyEnum("green", "通行");
    
    YELLOW("yellow", "等一等");
    //YELLOW常量  等价于 public static final YELLOW = new MyEnum("yellow", "等一等");

    private String name;
    private String msg;

    private MyEnum() {
    }

    private MyEnum(String name, String msg) {
        this.name = name;
        this.msg = msg;
    }

    @Override
    public String toString() {
        return "当前是" + name + "灯" + "请" + msg;
    }
}

第二章枚举类型的理解

枚举类是一个普通类 + 枚举项常量。隐式直接继承Enum类
枚举类构造器必须都是private的，且必须写在枚举项常量的后面
枚举项常量：
- 枚举项其实是该枚举类型的静态实例对象。
- 枚举项常量命名遵循常量命名规则。
- 隐式修饰符为public static final (不需要自己写,也不能写)

    RED("red", "停止"),
	//等价于 public static final RED = new MyEnum("red","停止");

第三章枚举的方法

自定义的枚举类都隐式直接继承Enum抽象类

非静态方法
public final String name(); 获取该枚举项
public final int ordinal(); 获取该枚举项的索引
静态方法 jvm自动添加的两个方法
public static 枚举类[] values(); 获取枚举项数组
public static 枚举类 valueOf(String str);获取特定枚举项

package enum_test;

import java.util.Arrays;

public class Demo07 {
    public static void main(String[] args) {
        SingleEnum instance = SingleEnum.INSTANCE1;

        System.out.println(instance.name());  // INSTANCE1
        
        System.out.println(instance.ordinal());// 0

        SingleEnum[] values = SingleEnum.values();
        System.out.println(Arrays.toString(values));//[INSTANCE1, INSTANCE2]

        SingleEnum instacne = SingleEnum.valueOf("INSTANCE1");
        System.out.println(instacne);// INSTANCE1

    }
}

enum SingleEnum {
    INSTANCE1,
    INSTANCE2;
}

在这里插入图片描述

第四章枚举类型和普通常量的区别

先来看两个需求：

1. 需求一：根据当前是星期几调用不同的功能。比如商家，周末时会发放大额优惠券.

1.1 静态常量写法

因为我们明确知道一周只有星期一、星期二、… 星期日这七个。因此可以将这七个变量抽取到一个专门类中保存，提高代码的复用性。

package enum_test;
public class Demo03 {
    public static void main(String[] args) {
        //调用
        method("星期一");
    }

    //实现需求
    public static void method(String day) {
        switch (day) {
            case DayOfWeek.MONDAY:
                //星期一独特的代码
                break;
            case DayOfWeek.TUESDAY:
                //星期二独特的代码
                break;
            case DayOfWeek.WEDNESDAY:
                //星期三独特的代码
                break;
            case DayOfWeek.THURSDAY:
                //星期四独特的代码
                break;
            case DayOfWeek.FRIDAY:
                //星期五独特的代码
                break;
            case DayOfWeek.SATURDAY:
                //星期六独特的代码
                break;
            case DayOfWeek.SUNDAY:
                //星期天独特的代码
                break;
        }
    }
}
//专门保存静态常量
class DayOfWeek {
    public static final String MONDAY = "星期一";
    public static final String TUESDAY = "星期二";
    public static final String WEDNESDAY = "星期三";
    public static final String THURSDAY = "星期四";
    public static final String FRIDAY = "星期五";
    public static final String SATURDAY = "星期六";
    public static final String SUNDAY = "星期七";
}

1.2 枚举写法

package enum_test;
public class Demo02 {
    public static void main(String[] args) {
   		//调用
        method(EnumDayOfWeek.SUNDAY);
    }
    
	//实现需求
    public static void method(EnumDayOfWeek day) {
        switch (day) {
            case MONDAY:
                //星期一独特的代码
                break;
            case TUESDAY:
                //星期二独特的代码
                break;
            case WEDNESDAY:
                //星期三独特的代码
                break;
            case THURSDAY:
                //星期四独特的代码
                break;
            case FRIDAY:
                //星期五独特的代码
                break;
            case SATURDAY:
                //星期六独特的代码
                break;
            case SUNDAY:
                //星期天独特的代码
                break;
        }
    }
}
//自定义的星期枚举类型
enum EnumDayOfWeek {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY;
}

看需求一，用常量写和用枚举写好像没什么区别？

在这里插入图片描述

2. 需求二：访问网页会有状态码和对应的描述，怎么用程序实现呢？

/*
200 - 请求成功
301 - 资源（网页等）被永久转移到其它URL
404 - 请求的资源（网页等）不存在
500 - 内部服务器错误
*/

2.1 静态常量写法

package enum_test;

public class Demo05 {
    public static void main(String[] args) {
        //调用
        method(200);
    }
    //实现需求
    public static void method(int statusCode) {
        switch (statusCode){
            case StatusCode.STATUS_CODE_200:
                System.out.println(StatusCode.STATUS_CODE_200 + StatusCode.STATUS_MSG_200);
                break;
            case StatusCode.STATUS_CODE_301:
                System.out.println(StatusCode.STATUS_CODE_301 + StatusCode.STATUS_MSG_301);
                break;
            case StatusCode.STATUS_CODE_404:
                System.out.println(StatusCode.STATUS_CODE_404 + StatusCode.STATUS_MSG_404);
                break;
            case StatusCode.STATUS_CODE_500:
                System.out.println(StatusCode.STATUS_CODE_500 + StatusCode.STATUS_MSG_500);
                break;
        }
    }
}

class StatusCode {
    public static final int STATUS_CODE_200 = 200;
    public static final String STATUS_MSG_200 = "请求成功";

    public static final int STATUS_CODE_301 = 301;
    public static final String STATUS_MSG_301 = "资源（网页等）被永久转移到其它URL";

    public static final int STATUS_CODE_404 = 404;
    public static final String STATUS_MSG_404 = "请求的资源（网页等）不存在";

    public static final int STATUS_CODE_500 = 500;
    public static final String STATUS_MSG_500 = "内部服务器错误";
}

2.2 枚举写法

package enum_test;

public class Demo06 {
    public static void main(String[] args) {
        //调用
        method(EnumStatusCode.STATUS_CODE_500);
    }

    //实现需求
    public static void method(EnumStatusCode statusCode) {
        switch (statusCode) {
            case STATUS_CODE_200:
                System.out.println(EnumStatusCode.STATUS_CODE_200);
                break;
            case STATUS_CODE_301:
                System.out.println(EnumStatusCode.STATUS_CODE_301);
                break;
            case STATUS_CODE_404:
                System.out.println(EnumStatusCode.STATUS_CODE_404);
                break;
            case STATUS_CODE_500:
                System.out.println(EnumStatusCode.STATUS_CODE_500);
                break;
        }
    }
}

enum EnumStatusCode {
    STATUS_CODE_200(200, "请求成功"),

    STATUS_CODE_301(301, "资源（网页等）被永久转移到其它URL"),

    STATUS_CODE_404(404, "请求的资源（网页等）不存在"),

    STATUS_CODE_500(500, "内部服务器错误");

    private int code;
    private String msg;

    EnumStatusCode() {
    }

    EnumStatusCode(int code, String msg) {
        this.code = code;
        this.msg = msg;
    }

    public int getCode() {
        return code;
    }

    public String getMsg() {
        return msg;
    }

    @Override
    public String toString() {
        return "状态码:" + code + " msg:" + msg;
    }
}

从需求二我们可以看出，枚举类型的常量更加灵活，可以附带信息和行为，封装性好方便使用。

3. 什么时候使用枚举呢？

首先，枚举不是必须的，要根据情况来定。不是定义枚举类型就一定比定义一组常量好，不是绝对的。
用枚举实现单例

public enum Singleton {
    INSTANCE
    
    //单例其他方法
    ....
}

第四章参考资料

B站视频

为什么我喜欢枚举（1）–语法糖而已

百度百科

为什么建议你使用枚举？

整明白枚举单例模式

从零开始的JAVA世界

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
java - enum

文章目录第一章枚举类型的定义第一章枚举类型的作用1.1 先来写个小需求1.1.1 局部变量写法1.1.2 静态常量写法1.1.3 枚举写法1.2 我们再来写个小需求1.2.1 静态常量写法1.2.2 枚举写法第二章自定义枚举类型枚举类的定义第二章枚举实现原理第一章什么时候用枚举？1 枚举概述2 枚举的定义3 枚举的使用参考资料第一章枚举类型的定义public enum 枚举名{ 枚举项常量1,枚举项常量2,枚举项常量3; 字段...; 私有构造器...; 方法...; ...
复制链接

扫一扫