Java枚举类

一、枚举类

1、使用场景

  • 当类的对象只有有限个，如：
    • 周一到周五：Monday，……，Sunday
    • 一年的四个季节：Spring，Summer，Autumn，Winter
    • 订单状态：未付款，已付款，已配送，已发货，退货，已确认
    • 线程状态：创建，就绪，销毁，运行，阻塞，死亡
  • 当需要定义一组常量时，建议使用枚举类。

2、枚举类的定义

  • JDk5.0以后，可以使用enum关键字定义枚举类。

    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
    public enum Season {
        //定义枚举类对象，中间用","隔开
        SPRING("春天","很温暖"),
        SUMMER("夏天","很炎热"),
        AUTUMN("秋天","很凉爽"),
        WINTER("冬天","很寒冷");

        //声明Season属性
        private final String name;
        private final String desc;

        //构造方法只能是私有
        private Season(String name,String desc){
            this.name = name;
            this.desc = desc;
        }

        public String getName() {
            return name;
        }

        public String getDesc() {
            return desc;
        }
    }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    //使用枚举类
    @Test
    public void test1() {
        Season spring = Season.SPRING;
        System.out.println(spring); 
        //输出：SPRING，并没有输出地址，说明父类不是Object

        System.out.println(Season.class.getSuperclass());//父类是：java.lang.Enum
    }

  • 父类Enum类的常用方法：

    • values()：返回枚举类的对象数组，该方法可以很方便遍历所有枚举值

    • valueOf(String str)：可以把一个字符串转为对应的枚举类对象。要求字符串必须是枚举对象名字，否则会有异常：IllegalArgumentException.

    • toString()：返回当前枚举类对象常量的名称。

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      @Test
      public void test2() {
          Season spring = Season.SPRING;
          //toString()方法
          System.out.println(spring.toString()); //SPRING
          
          //values()方法
          Season[] values = Season.values();
          for (Season value : values) {
              System.out.println(value);
          }
          /* SPRING
             SUMMER
             AUTUMN
             WINTER*/
          
          //valueOf()方法
          Season winter = Season.valueOf("WINTER");//如果没找到会有异常IllegalArgumentException
          System.out.println(winter);//WINTER
      }

3、枚举类实现接口

  • 情况一：和普通类没区别。

    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
    //一个接口
    interface Info{
        void show();
    }
    //枚举类实现接口
    public enum Season implements Info{
        SPRING("春天","很温暖"),
        SUMMER("夏天","很炎热"),
        AUTUMN("秋天","很凉爽"),
        WINTER("冬天","很寒冷");

        private final String name;
        private final String desc;

        private Season(String name,String desc){
            this.name = name;
            this.desc = desc;
        }

        public String getName() {
            return name;
        }

        public String getDesc() {
            return desc;
        }
    	//实现接口方法
        @Override
        public void show() {
            System.out.println("一个季节");
        }
    }
    1
    2
    3
    4
    5
    @Test
    public void test2() {
        Season spring = Season.SPRING;
        spring.show(); //一个季节
    }

  • 情况二：针对每个对象，都各自实现接口的方法

    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
    49
    //一个接口
    interface Info{
        void show();
    }
    //枚举类实现接口
    public enum Season implements Info{
        
        //每个枚举对象各自实现接口方法
        SPRING("春天","很温暖"){
            @Override
            public void show() {
                System.out.println("这是春天");
            }
        },
        SUMMER("夏天","很炎热"){
            @Override
            public void show() {
                System.out.println("这是夏天");
            }
        },
        AUTUMN("秋天","很凉爽"){
            @Override
            public void show() {
                System.out.println("这是秋天");
            }
        },
        WINTER("冬天","很寒冷"){
            @Override
            public void show() {
                System.out.println("这是冬天");
            }
        };

        private final String name;
        private final String desc;

        private Season(String name,String desc){
            this.name = name;
            this.desc = desc;
        }

        public String getName() {
            return name;
        }

        public String getDesc() {
            return desc;
        }   
    }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    @Test
    public void test2() {
        Season[] values = Season.values();
        for (Season value : values) {
            value.show();
        }
    }
    /*
    这是春天
    这是夏天
    这是秋天
    这是冬天
    */

二、注解

  • 注解的常见作用：

    1. 生成相关的文档。
    2. 在编译时进行格式检查，如：
      • @Override：限定重写父类的方法，该注解只可用于方法；
      • @Deprecated：用于表示修饰的类或方法已过时；
      • @SuppressWarnings：抑制编译器警告；
    3. 跟踪代码依赖性，实现替代配置文件的效果（框架常用）。

  • 自定义注解

    1. 注解声明为@interface。
    2. 内部定义成员，通常是value。
    3. 可以指定默认值，使用default定义默认值。
    4. 如果注解里面没有成员，说明只是起到标记作用。
    5. 如果注解有成员，使用时现需要指明其值。
    6. 自定义注解必须配上注解的信息处理流（使用反射）才有意义。
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    //注解定义(暂无意义)
    public @interface MyAnnotation {
        //内部成员
        String value();
    }

    //注解使用
    @MyAnnotation(value = "hello")
    class MyClass{
        
    }