枚举类型

Class Enum<E extends Enum <E> >
java.lang.Object
java.lang.Enum <E>

枚举是一种特殊的数据类型，也是常量的集合

优点：

• 类型安全
• 紧凑有效的数据定义
• 可以和程序其他部分完美交交互
• 运行效率高

枚举类型设置常量

当定义枚举类型时，每个枚举类型的成员都可以看做实例，类型默认修饰为 final、public、static ，当使用时直接调用对应的名称即可

public enum Constants{
    
    //Constants枚举名称
    Constants_A,
    Constants_B,
      ····
    Constants_N
}

例子：接口、枚举定义常量的方式且使用

public class Demo {
    
    
    
    //接口类型
    interface Lesson{
    
    
        public static final int Mathematics  = 1;
        public static final int Chinese  = 2;
        public static final int English  = 3;
        public static final int Physical  = 4;
        public static final int Biological = 5;
        public static final int Chemistry = 6;
    }
    
    //枚举类型
    public enum Lesson2 {
    
    
        //数学
        Mathematics ,
        // 语文
        Chinese ,
        // 英语
        English ,
        // 物理
        Physical ,
        // 生物
        Biological ,
        // 化学
        Chemistry
    }
    
    public static void doit(int s){
    
    
        switch(s){
    
    
            case Lesson.Mathematics:
                System.out.println("数学课");
                break;
            case Lesson.Chinese:
                System.out.println("语文课");
                break;
            case Lesson.English:
                System.out.println("英语课");
                break;
            case Lesson.Physical:
                System.out.println("物理课");
                break;
            case Lesson.Biological:
                System.out.println("生物课");
                break;
            case Lesson.Chemistry:
                System.out.println("化学课");
                break;
            default:
                System.out.println("错误");
                break;
        }
    }
    
    public static void doit2(Lesson2 s){
    
    
        switch(s){
    
    
            case Mathematics:
                System.out.println("数学课");
                break;
            case Chinese:
                System.out.println("语文课");
                break;
            case English:
                System.out.println("英语课");
                break;
            case Physical:
                System.out.println("物理课");
                break;
            case Biological:
                System.out.println("生物课");
                break;
            case Chemistry:
                System.out.println("化学课");
                break;
            default:
                System.out.println("错误");
                break;
        }
    }
    
    public static void main(String[] args) {
    
    
        System.out.println("(0)接口中定义的");
        doit(Lesson.English);
        doit(2);
        System.out.println("(1)枚举中定义的");
        doit2(Lesson2.Chemistry);
        //doit2(3);
    }
}

运行结果

(0)接口中定义的
英语课
语文课
(1)枚举中定义的
化学课

枚举操作方法

修饰符	方法	说明
Object[]	enumname.values（）	将枚举成员以数组返回
enum<E>	enumname.valueOf（String str）	str名称获取枚举成员
int	enum<E>.compareTo（enum<E>）	比较两个枚举对象定义时的顺序（有距离返回）
int	enum<E>.ordinal（）	返回枚举对象定义时的索引位置

enumname： 枚举名称
enum<E>： 枚举对象

例子：

public class Demo2 {
    
    
    public enum Lesson {
    
    
        //数学
        Mathematics ,
        // 语文
        Chinese ,
        // 英语
        English ,
        // 物理
        Physical ,
        // 生物
        Biological ,
        // 化学
        Chemistry
    }
    
    public static void main(String[] args) {
    
    
        Lesson[] array = Lesson.values();
    
        System.out.println("遍历枚举类型：");
        for(Lesson tmp : array){
    
    
            System.out.println(tmp);
        }
        //效果一样
//        for(Object tmp : array){
    
    
//            System.out.println(tmp);
//        }
        
        
        System.out.println("\n获取枚举类型值且比较（English）：");
        Lesson L1 = Lesson.English;
        Lesson L2 = Lesson.valueOf("English");
//        Lesson L3 = Lesson.valueOf("eec"); 抛出异常（“ecc”不存在）
    
        System.out.println("L1 == L2？"+(L1==L2));
        System.out.println("L1.equals(L2)？"+(L1.equals(L2)));
    
        
        /*
        *
        * L1.compareTo(L2)方法
        *   返回值说明：
        *       正数。L2在L1的前面（有距离返回）
        *       负数。L2在L1的后面（有距离返回）
        *       0。L1位置和L2位置相同
        *
        * */
        System.out.println("\n判断顺序位置：");
        Lesson L3 = Lesson.Mathematics;
        Lesson L4 = Lesson.Chemistry;
    
        System.out.println("L1比L3："+L1.compareTo(L3));
        System.out.println("L1比L4："+L1.compareTo(L4));
        System.out.println("L1比L1："+L1.compareTo(L1));
    
        
        System.out.println("\n获取所有枚举成员的索引：");
        for(Lesson tmp : array){
    
    
            System.out.println(tmp+"索引位置："+tmp.ordinal());
        }
        
    }
}

运行结果

遍历枚举类型：
Mathematics
Chinese
English
Physical
Biological
Chemistry

获取枚举类型值且比较（English）：
L1 == L2？true
L1.equals(L2)？true

判断顺序位置：
L1比L3：2
L1比L4：-3
L1比L1：0

获取所有枚举成员的索引：
Mathematics索引位置：0
Chinese索引位置：1
English索引位置：2
Physical索引位置：3
Biological索引位置：4
Chemistry索引位置：5

枚举中的构造方法

在枚举类型中添加构造方法前提该构造方法必须为private权限修饰符

public enum Constants{
    
    //Constants枚举名称
    Constants_A,
    Constants_B,
    private String name;
    private Constants(){
    
     }
    private Constants(String name){
    
    
        name.this = name;
    }
}

例子：（枚举类型 的 构造方法 、方法的使用 、接口引用）

public class Dmeo3 {
    
    
    
    enum Constants{
    
    
        Constants_A ("A"),
        Constants_B ("BB"),
        Constants_C ("CC"),
        Constants_D (22);
        
        private String name;
        private int n;
        
        //构造方法
        private Constants(String name){
    
    
            this.name = name;
        }
        private Constants(int n){
    
    
            this.n = n ;
        }
        
        //方法
        public String Getdata(){
    
    
            return name;
        }
        
    }
    
    //接口实现枚举中的方法
    interface EnumInterface {
    
    
        public String Getdata();
    }
    enum Constants2 implements EnumInterface{
    
    
        Constants_A{
    
    
            
            @Override
            public String Getdata() {
    
    
                return "枚举成员A";
            }
            
        },
        Constants_B{
    
    
        
            @Override
            public String Getdata() {
    
    
                return "枚举成员B";
            }
        
        }
        
    }
    
    
    public static void main(String[] args) {
    
    
        
        System.out.println("遍历枚举：");
        Object[] array = Constants.values();
        for (int i = 0; i < array.length ; i++) {
    
    
            System.out.println(array[i]+"里面的Getdata()方法为："+Constants.values()[i].Getdata());
        }
    
        System.out.println("=================");
        
        System.out.println("遍历枚举：");
        Object[] array2 = Constants2.values();
        for (int i = 0; i < array2.length ; i++) {
    
    
            System.out.println(array2[i]+"里面的Getdata()方法为："+Constants2.values()[i].Getdata());
        }
        
    }
}

运行结果

遍历枚举：
Constants_A里面的Getdata()方法为：A
Constants_B里面的Getdata()方法为：BB
Constants_C里面的Getdata()方法为：CC
Constants_D里面的Getdata()方法为：null
=================
遍历枚举：
Constants_A里面的Getdata()方法为：枚举成员A
Constants_B里面的Getdata()方法为：枚举成员B