枚举类的使用

1.简介：

  类的对象只有有限个，确定的，我们称之为枚举类。

      例如  星期，线程状态，性别，季节等。

  当需要定义一组常量时，强烈建议使用枚举类

  如果枚举类中只有一个对象，则可以作为一个单例模式的实现方式

2.如何定义枚举类

方式一：jdk 1.5 之前，自定义枚举类

//自定义枚举类
    class Season{
        //1.声明Season对象的属性:private final 修饰
        private final String seasonName;
        private final String seasonDesc;

     //2.私有化类的构造器,并给对象属性赋值
     private Season(String seasonName,String seasonDesc){
         this.seasonName = seasonName;
         this.seasonDesc = seasonDesc;

     }

        public String getSeasonName() {
            return seasonName;
        }

        public String getSeasonDesc() {
            return seasonDesc;
        }

        @Override
        public String toString() {
            return "Season{" +
                    "seasonName='" + seasonName + '\'' +
                    ", seasonDesc='" + seasonDesc + '\'' +
                    '}';
        }

        //3.提供当前枚举类的多个对象    public static final 修饰的
        public static final Season SPRING = new Season("春天","春暖花开");
        public static final Season SUMMER = new Season("夏天","夏日炎炎");
        public static final Season AUTUMN = new Season("秋天","秋高气爽");
        public static final Season WINTER = new Season("冬天","冰天雪地");

    }

对定义的枚举类进行测试：

public class SeasonTest {

    public static  void main(String[] args){
        Season season = Season.AUTUMN;
        System.out.println(season);
        //Season{seasonName='秋天', seasonDesc='秋高气爽'}
    }
}

方式二：jdk1.5 以后，可以使用enum关键字定义枚举类

//使用enum关键字定义枚举类
  enum Season1  {
    //1.提供当前枚举类的对象   多个对象之间用","隔开,末尾对象用“;”结束
    SPRING ("春天", "春暖花开"),
    SUMMER ("夏天", "夏日炎炎"),
    AUTUMN ("秋天", "秋高气爽"),
    WINTER ("冬天", "冰天雪地");

    //2.声明Season对象的属性:private final 修饰
    private final String seasonName;
    private final String seasonDesc;

    //3.私有化类的构造器,并给对象属性赋值
    private Season1(String seasonName, String seasonDesc) {
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;

    }

    public String getSeasonName() {
        return seasonName;
    }

    public String getSeasonDesc() {
        return seasonDesc;
    }


  }

对使用enum关键字定义的枚举类进行测试：

public class SeasonTest2 {
    public static void main(String[] args) {
        Season2 summer=Season2.SUMMER;
        System.out.println(summer); //SUMMER
        
}　

3.Enum类中的常用方法

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

valueOf(String str)方法：可以把一个字符串转化为对应的枚举类对象，要求字符串必须是枚举类对象

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

public class SeasonTest1 {
    public static void main(String[] args) {
        Season1 summer=Season1.SUMMER;
        System.out.println(summer);
        //toString():
        System.out.println(summer.toString());
        /*
        打印结果为：
        SUMMER
        SUMMER
         */
        //values()
        System.out.println("******************");
        Season1[] values = Season1.values();
        for(int i=0;i<values.length;i++){
            System.out.println(values[i]);
            /*
            打印结果为：
            SPRING
            SUMMER
            AUTUMN
            WINTER
             */
        }
        System.out.println("******************");
        Thread.State[] values1 = Thread.State.values();
        for(int i=0;i<values1.length;i++){
            System.out.println(values1[i]);
               /*
               打印结果为：
                NEW
                RUNNABLE
                BLOCKED
                WAITING
                TIMED_WAITING
                TERMINATED
                */

        }
        //valueOf(String str) 返回枚举类中对象名为objName的对象，
        // 如果没有objName的枚举类对象，则抛异常
        System.out.println("*****************#");
        Season1 winter = Season1.valueOf("WINTER");
        System.out.println(winter);
        /*
        打印结果为:
         WINTER
         */


    }
}

4.使用enum关键字定义的枚举类实现接口的情况

1.实现接口，在enum类中实现抽象方法

2.让枚举类的对象分别实现接口中的抽象方法

 接口类MessageInfo：

interface MessageInfo{
    void show();
}　

定义的枚举类实现上述接口：

//使用enum关键字定义枚举类
enum Season2 implements MessageInfo {
    //1.提供当前枚举类的对象   多个对象之间用","隔开,末尾对象用“;”结束
     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("冬天");
         }
     };

    //2.声明Season对象的属性:private final 修饰
    private final String seasonName;
    private final String seasonDesc;

    //3.私有化类的构造器,并给对象属性赋值
    private Season2(String seasonName, String seasonDesc) {
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;

    }

    public String getSeasonName() {
        return seasonName;
    }

    public String getSeasonDesc() {
        return seasonDesc;
    }

}

对其进行测试：

public class SeasonTest2 {
    public static void main(String[] args) {
        Season2 summer=Season2.SUMMER;
        System.out.println(summer);
        /*
        打印结果为：
        SUMMER
         */
        //values()
        Season2[] values = Season2.values();
        for(int i=0;i<values.length;i++){
            System.out.println(values[i]);
            values[i].show();
            /*
            打印结果为：
            SPRING
            春天
            SUMMER
            夏天
            AUTUMN
            秋天
            WINTER
            冬天
             */
        }
       
        //valueOf(String str) 返回枚举类中对象名为objName的对象，
        // 如果没有objName的枚举类对象，则抛异常
        System.out.println("*****************#");
        Season2 winter = Season2.valueOf("WINTER");
        System.out.println(winter);
       winter.show(); 
        /*
        打印结果为:
         WINTER
         冬天
         */
    }
}