Java枚举详解

一.枚举

  1.为什么有枚举？

如果我们的程序需要表示固定的几个值：

比如季节：spring (春)，summer(夏)，autumn(秋)，winter(冬)

用常量表示：

        public static final int SEASON_SPRING = 1;
        public static final int SEASON_SUMMER = 2;
        public static final int SEASON_AUTUMN = 3;
        public static final int SEASON_WINTER = 4;

用常量表示季节的弊端

 1.代码不够简洁

 2.不同类型的数据是通过名字区分的

 3.不安全，由于是数字类型，就有可能使用这几个值做一些运算操作；比如：

SEASON_SPRING + SEASON_SUMMER

为了间接的表示一些固定的值，Java就给我们提供了枚举。

2.枚举的格式

概念：

       枚举：是指将变量的值一一列出来，变量的值只限于列举出来的值的范围内。

格式：

      public  enum  s {

                       枚举项1,枚举项2,枚举项3;

       }

定义枚举类要用关键字enum

练习：

   定义一个枚举类，用来表示春，夏，秋，冬这四个固定值

package com.gch.d5_enum.demo1;

/**
   定义枚举类
 */
public enum Season {
    SPRING,SUMMER,AUTUMN,WINTER;
}

3.枚举的特点

   1.所有枚举类都是Enum的子类
   2.我们可以通过"枚举类名.枚举项名称"去访问指定的枚举项
   3.每一个枚举项其实就是该枚举的一个对象
   4.枚举也是一个类,也可以去定义成员变量
   5.枚举类的第一行上必须是枚举项,最后一个枚举项后的分号是可以省略的,
      但是如果枚举类有其他的东西,这个分号就不能省略。建议不要省略
   6.枚举类可以有构造器,但必须是private的,它默认也是private的。
      枚举项的用法比较特殊:枚举("");
   7.枚举类也可以有抽象方法,但是枚举项必须重写该方法。

   8.如果枚举项的后面什么都不写,那么此时它就默认调用枚举项的空参构造，如果想让它不        报错,只有让每一个枚举项去调用有参构造:枚举项(参数1,参数2){}

package com.gch.d5_enum.demo2;

/**
   定义枚举类
 */
public enum Season {
    // 5.枚举类的第一行上必须是枚举项,最后一个枚举项后的分号是可以省略的,
    //   但是如果枚举类有其他的东西,这个分号就不能省略。建议不要省略

    // 如果枚举项的后面什么都不写,那么此时它就默认调用枚举项的空参构造
    // 如果想让它不报错,只有让每一个枚举项去调用有参构造:枚举项(参数1,参数2){}
    SPRING("春"){
        // 如果枚举类中有抽象方法
        // 那么在枚举项中必须要全部重写
        @Override
        public void show() {
            System.out.println(this.name);
        }
    },
    SUMMER("夏"){
        @Override
        public void show() {
            System.out.println(this.name);
        }
    },
    AUTUMN("秋"){
        @Override
        public void show() {
            System.out.println(this.name);

        }
    },
    WINTER("冬"){
        @Override
        public void show() {
            System.out.println(this.name);
        }
    };

//    4.枚举也是一个类,也可以去定义成员变量
    public String name;

    // 空参构造
//    private Season(){}

    // 有参构造
    private Season(String name){
        this.name = name;
    }

    // 抽象方法
    public abstract void show();
}

package com.gch.d5_enum.demo2;

public class EnumDemo {
    public static void main(String[] args) {
        // 第二个特点的演示
        // 2.我们可以通过"枚举类名.枚举项名称"去访问指定的枚举项
        System.out.println(Season.SPRING);
        System.out.println(Season.SUMMER);
        System.out.println(Season.AUTUMN);
        System.out.println(Season.WINTER);

        // 第三个特点的演示
        //  3.每一个枚举项其实就是该枚举的一个对象
         Season spring = Season.SPRING;
    }
}

 4.枚举的方法

1. String name() 获取枚举项的名称
2. int ordinal() 返回枚举项在枚举类中的索引值， 枚举项在枚举类中它也是有索引的
3. int compareTo(E o) 比较两个枚举项,返回的是索引值的差值
4. String toString() 返回枚举常量的名称
5. static <T> T valueOf(Class<T> type,String name)

                                          字节码文件对象  枚举项的名称
           ，它是一个静态方法,获取指定枚举类中的指定名称的枚举值

     6. values()  获得所有的枚举项

package com.gch.d5_enum.demo3;

/**
   定义枚举类
 */
public enum Season {
    SPRING,SUMMER,AUTUMN,WINTER;
}

package com.gch.d5_enum.demo3;

public class EnumDemo {
    public static void main(String[] args) {
        // String name() 获取枚举项的名称
         String name = Season.SPRING.name();
         System.out.println(name); // SPRING
        System.out.println("---------------------");

        // int ordinal() 返回枚举项在枚举类中的索引值
         int index1 = Season.SPRING.ordinal();
         int index2 = Season.SUMMER.ordinal();
         int index3 = Season.AUTUMN.ordinal();
        int index4 = Season.WINTER.ordinal();
        // 枚举项在枚举类中它也是有索引的
        System.out.println(index1); // 0
        System.out.println(index2); // 1
        System.out.println(index3); // 2
        System.out.println(index4); // 3
        System.out.println("----------------------");

        // int compareTo(E o) 比较两个枚举项,返回的是索引值的差值
        int result = Season.SPRING.compareTo(Season.WINTER);
        System.out.println(result); // 0 - 3 = -3
        System.out.println("-----------------------");

        // String toString() 返回枚举常量的名称
        String s = Season.SPRING.toString();
        System.out.println(s); // SPRING
        System.out.println("------------------");

        // static <T> T valueOf(Class<T> type,String name)
        //                      字节码文件对象  枚举项的名称
        // 它是一个静态方法,获取指定枚举类中的指定名称的枚举值
        Season spring = Enum.valueOf(Season.class, "SPRING");
        System.out.println(spring); // SPRING
        System.out.println(Season.SPRING == spring); // true
        System.out.println("--------------------------");

        // values()  获得所有的枚举项
        Season[] values = Season.values();
        for (int i = 0; i < values.length; i++) {
            System.out.println(values[i]);
        }
    }
}