​
​

活动地址：CSDN21天学习挑战赛

一. 什么是枚举

1.概念

枚举就是用于表示一些固定的值，可以用枚举项来进行表示

2.定义枚举类的语法：

	访问修饰符  enum  枚举类的名称
		{
			枚举项	
		}
1
2
3
4

3. 例子：
   public enum Color
   {
   RED,
   BLUE,
   YELLOW
   }

3.枚举的特点：

1.每一个枚举类都是enum的子类
2.枚举类中可以定义成员变量
3.枚举类中只能有私有的构造,默认就是私有的构造
4.枚举类中可以有抽象方法，但是每一个枚举项都必须重写这个抽象方法
5.枚举项可以通过枚举类.枚举项进行获取
6.枚举项，一般写在枚举类的第一行,多个的话以逗号分割

4.案例一：定义一个颜色枚举类

public enum Color {
    BLUE {
        @Override
        public String getColor() {
            return "蓝色";
        }
    }, RED {
        @Override
        public String getColor() {
            return "红色";
        }
    }, YELLOW {
        @Override
        public String getColor() {
            return "黄色";
        }
    };
    private String name;
    //私有的构造方法
     Color(){}
    //抽象方法
    public abstract String getColor();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

5 枚举的方法

6.案例二:枚举类方法使用

public class Test01 {
    public static void main(String[] args) {
        Color blue = Color.BLUE;
        System.out.println(blue.name());
        Color red = Color.RED;
        //比较red与blue的次序
        System.out.println("比较red与blue的次序"+red.compareTo(blue));
        //返回red的枚举常量的序数
        System.out.println("返回red的枚举常量的序数"+red.ordinal());
        //返回red枚举常量的名称
        System.out.println("返回red枚举常量的名称"+red.toString());
        //获取colors对象的所有枚举常量
        Color[] colors=Color.values();
        
        //遍历所有的枚举类的常量
        for (Color c: Color.values()) {
            System.out.println(c.name());
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

测试的结果如下

7. 案例三：使用switch与枚举结合表示一周中的菜品

注意：首先我们要明白的是，一定是根据日期去选择菜品的，而日期怎么处理？
定义成为我们的枚举类即可。
其次我们要用Switch来根据周几来选择我们几天吃什么菜。

定义自己的枚举类

public enum week {
    星期一,星期二,星期三,星期四,星期五,星期六,星期日;
}
1
2
3

再去定义我们的测试类

public class Test01 {
    public static void main(String[] args) {
        week day = week.星期六;
        switch (day){
            case 星期一:
                System.out.println("隆江猪脚饭");
                break;
            case 星期二:
                System.out.println("黄宇黄焖鸡");
                break;
            case 星期三:
                System.out.println("韭菜炒鸡蛋");
                break;
            case 星期四:
                System.out.println("生蚝人参汤");
                break;
            case 星期五:
                System.out.println("十全大补汤");
                break;
            case 星期六:
                System.out.println("六味地黄丸");
                break;
            case 星期日:
                System.out.println("飘香西北风");
                break;
        }

    }
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

8. 案例四：实战案例—报错工具类

我们项目中，写接口的时候总是要传值json给前端，但是有的需求或者当我们需要打印结果测试这个端口是否有问题的时候就需要，200,500这种信息，那么我们如何通过枚举来封装好一个工具来更便捷的处理这些问题？

首先来封装我们的枚举类ResponseCode

/*这里是一个lombok的注解，为了让这里不能set只能get，
限制死了数据只能由我们自己定义
*/
@Getter
public enum ResponseCode {
	/*
	常见枚举类定义，就是我们需要什么就怎么去定义，
	按照规范来``大写``
	*/
    SUCCESS(200,"success"),
    ERROR(500,"error"),
    SYS_BUSY_ERROR(505,"Abnormal network connection"),
    TRANSACTION_ERROR(506,"Transaction is failed to execute"),
    ERROR_PASSWORD(500,"密码错误");

    private int status;
    private String msg;

	/*
		枚举的构造函数，默认私有
	*/
    ResponseCode(int status, String msg) {
        this.status = status;
        this.msg = msg;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

再来定义我们的操作类 ResponseResult
注意：

说到底，这个类还是在枚举类上的进一步的封装， 为了更便捷的去使用这个轮子

@Data
//是泛型，相当于Object基类
public class ResponseResult<T> {
    //属性
    private Integer status;
    private String msg;
    private T data;

    public static <T>ResponseResult<T> success(ResponseCode responseCode, T data){
        return common(responseCode,data);
    }
    public static <T>ResponseResult<T> success(ResponseCode responseCode){
        return common(responseCode,null);
    }
    public static <T>ResponseResult<T> success(T data){
        return common(ResponseCode.SUCCESS,data);
    }
    public static <T>ResponseResult<T> error(ResponseCode responseCode, T data){
        return common(responseCode,data);
    }
    public static <T>ResponseResult<T> error(ResponseCode responseCode){
        return common(responseCode,null);
    }
    public static <T>ResponseResult<T> error(T data){
        return common(ResponseCode.ERROR,data);
    }
    public static <T>ResponseResult<T> systemBusyError(T data){
        return common(ResponseCode.SYS_BUSY_ERROR,data);
    }


    /**静态的方法，当调用这个方法的时候肯定要返回值吧？返回什么值肯定要我们来规定（需求规定）吧？
     * 我们先创建这个方法来当在接口里面每次调用的时候，肯定都要 new 一个对象、要返回状态值、要返回数据、有时候还要返回我们想打印的语句
     * 这里一次性解决
     */
    private static <T> ResponseResult<T> common(ResponseCode responseCode, T data) {
        //创建一个新的对象
        ResponseResult<T> responseResult = new ResponseResult<>();
        //从ResponseCode中get我们想要的状态
        responseResult.setStatus(responseCode.getStatus());
        //从ResponseCode中get我们想要的打印的语句
        responseResult.setMsg(responseCode.getMsg());
        //从ResponseCode中get我们想要的数据
        responseResult.setData(data);
        return responseResult;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

​