javaSE 枚举类型

枚举类型可以取代以往常量的定义方式，就是将常量封装在类或接口中。
枚举类型还提供了安全检查功能。枚举类型本质上是以类的形式存在的

枚举类型

(1)使用枚举类型设置常量

将常量放置在接口中，该常量不能被修改，因为在接口中定义常量时，该常量的修饰符为final与static

 在接口中定义常量
 
public interface Constants{
		public static final double PI=3.14;
		public static final int X=1;
}

使用枚举类型定义常量
public enum Constants{
		PI,         //注意之间用逗号  
		X             
		//最后没有符号
}

当程序使用常量时，就用Constants.PI来使用

package com.ENUM;

import com.sun.xml.internal.bind.v2.model.core.EnumConstant;

interface InterfaceConstants{
    public static int c1=1;
    public static int c2=2;
}


public class Demo {
    enum EnumConstants{
        c1,c2
    }
    public static void doitInterface(int c){
        switch (c){
            case InterfaceConstants.c1:
                System.out.println("doitInterface()  c1");
                break;
            case InterfaceConstants.c2:
                System.out.println("doitInterface()  c2");
                break;
        }
    }

    public static void doitEnum(EnumConstants e){
        switch (e){
            case c1 :
                System.out.println("doitEnum() c1");
                break;
            case c2:
                System.out.println("doitEnum() c2");
                break;
        }
    }

    public static void main(String[] args) {
        Demo.doitInterface(InterfaceConstants.c1);
        Demo.doitEnum(EnumConstants.c1);
        Demo.doitEnum(EnumConstants.c2);
    }
}

可以看出在接口中定义的常量需要具体的值，而在枚举类型中定义的常量不需要具体的值
当调用doitInterface()方法中传入参数时，不一定传入接口中的常量，因为这个方法的参数是int类型。当调用doitEnum()方法传入参数时，必须传入的是枚举类型中的常量

(2)枚举类型

1.操作枚举类型的方法
枚举类型可以被看作成一个类，它继承与java.lang.Enum类，枚举类型的每一个成员都可以看作是一个枚举类型的实例，它们都被public static final修饰，所以当调用枚举类型成员时可以直接用枚举类型名称调用

方法	说明	使用
values()	将枚举类型成员以数组类型返回	枚举类型名称.values()
valueOf()	该方法可以实现将普通字符串转换为枚举类型实例	枚举类型名称.valuesOf(“abc”) （字符串为枚举成员里面的，它只是将将其转换成实例）
compareTo(E o)	该方法用于比较两个枚举对象在定义时的顺序	枚举成员.compareTo(枚举成员)
ordinal()	该方法用于得到枚举成员的位置索引	枚举成员.ordinal()

使用values()方法

public class Demo {
    enum EnumConstants{
        c1,c2
    }
    public static void main(String[] args) {
        for(int i=0;i<EnumConstants.values().length;i++){
            System.out.println("枚举成员"+(i+1)+":"+EnumConstants.values()[i]);
        }
    }
}
输出结果：
枚举成员1:c1
枚举成员2:c2

使用valueOf(),compareTo()方法

public class Demo {
    enum EnumConstants{
        c1,c2
    }
    public static  void compare(EnumConstants e){
        for(int i=0;i<EnumConstants.values().length;i++){
            System.out.println(e+"与"+EnumConstants.values()[i]+"的比较结果为"+e.compareTo(EnumConstants.values()[i]));       //使用compareTo()比较
        }
    }
    public static void main(String[] args) {
        compare(EnumConstants.valueOf("c2"));      //valueOf转换为实例
    }
}
输出结果：
c2与c1的比较结果为1
c2与c2的比较结果为0

compareTo()的结果为正，说明方法中的参数在其之前。结果为负，说明方法中的参数在其之前。结果为0，说明位置相同

使用ordinal()方法

public class Demo {
    enum EnumConstants{
        c1,c2
    }
    public static void main(String[] args) {
          System.out.println(EnumConstants.c2+"的位置"+EnumConstants.c2.ordinal());
    }
}
输出结果：
c2的位置1

2.枚举类型的构造方法
枚举类型中可以定义构造方法，并且这个构造方法必须是private的
并且在定义构造方法后枚举类型成员都必须相应的使用构造方法。

enum EnumConstants{
    c1("枚举成员c1"),
    c2(1);
    private String s;
    private int i;
    private EnumConstants(){
    }
    private  EnumConstants(String s){
        this.s=s;
    }
    private EnumConstants(int i){
        this.i=i;
    }
}

定义了构造方法就可以在枚举类型里定义get方法，用来返回构造方法设置的操作，使用private修饰符，防止用户实例化一个枚举对象

enum EnumConstants{
    c1("枚举成员c1"),
    c2(1);
    private String s;
    private int i;
    private EnumConstants(){
    }
    private  EnumConstants(String s){
        this.s=s;
    }
    private EnumConstants(int i){
        this.i=i;
    }
    public String getS() {
        return s;
    }
    public int getI() {
        return i;
    }
}

public class Demo {
       public static void main(String[] args) {
        for(int i=0;i<EnumConstants.values().length;i++){
            System.out.println(EnumConstants.values()[i]+"调用getI():"+EnumConstants.values()[i].getI()+" 调用getS():"+EnumConstants.values()[i].getS());
        }
        System.out.println(EnumConstants.c1+"调用getS():"+EnumConstants.c1.getS()+" "+EnumConstants.c2+"调用getI():"+EnumConstants.c2.getI());
    }
}
输出结果：
c1调用getI():0 调用getS():枚举成员c1
c2调用getI():1 调用getS():null
c1调用getS():枚举成员c1 c2调用getI():1

除了可以在枚举类型中用getxxx()方法获得枚举成员的描述外，还可以通过将getxxx()方法放在接口里，通过实现接口来获得描述。
每个枚举成员都要实现接口中的方法

package com.ENUM;

import com.sun.xml.internal.bind.v2.model.core.EnumConstant;

interface description{
    public String getS();
    public int getI();
}
enum EnumConstants implements description{
    c1{
        @Override
        public String getS() {
            return "枚举成员c1";
        }

        @Override
        public int getI() {
            return i;
        }
    },
    c2{
        @Override
        public String getS() {
            return "枚举成员c2";
        }

        @Override
        public int getI() {
            return i;
        }
    },
    c3{
        @Override
        public String getS() {
            return "枚举成员c3";
        }

        @Override
        public int getI() {
            return i;
        }
    };
    private static int i=11;

    public static void main(String[] args) {
        for (int i=0;i<EnumConstants.values().length;i++){
            System.out.println(EnumConstants.values()[i]+" getS()方法："+EnumConstants.values()[i].getS()+"  getI()方法:"+EnumConstants.values()[i].getI());
        }
    }
}
输出结果：
c1 getS()方法：枚举成员c1  getI()方法:11
c2 getS()方法：枚举成员c2  getI()方法:11
c3 getS()方法：枚举成员c3  getI()方法:11

3.枚举类型的优势
枚举类型声明了一种很好的变量定义方法，枚举了某种数据类型所有可能出现的值
枚举类型的特点：类型安全，紧凑有效的数据定义，可以和程序其他部分完美交互，运行效率高