java 枚举的原理与使用枚举设计单例

1.一个简单的季节枚举

    //1.季节枚举类，不能再继承其它类
    public enum SeasonEnum {
        SPRING,SUMMER,FALL，WINTER；
    }   

    //2.main测试
    public class TestEnums {
        public static void main(String [] a){
            //在打印输出SeasonEnum.SPRING时,调用了toString()方方法，枚举默认是重写了toString()方法，直接返回常量名（name）
            System.out.println(SeasonEnum.SPRING);
        }

    }

    //输出结果是：SPRING

2.SeasonEnum季节枚举的底层实现

    //SeasonEnum 默认继承Enum ，所以SeasonEnum不能再继承其它类
    public final class SeasonEnum extends Enum
    {

        //1.枚举对象
        public static final SeasonEnum SPRING;
        public static final SeasonEnum SUMMER;
        public static final SeasonEnum FALL;
        public static final SeasonEnum WINTER;
        private static final SeasonEnum ENUM$VALUES[];

        //3.私有化构造器，所以枚举对象默认是不能new获取
        private SeasonEnum(String s, int i)
        {
            super(s, i);
        }

        public static SeasonEnum[] values()
        {
            SeasonEnum aseasonenum[];
            int i;
            SeasonEnum aseasonenum1[];
            System.arraycopy(aseasonenum = ENUM$VALUES, 0, aseasonenum1 = new SeasonEnum[i = aseasonenum.length], 0, i);
            return aseasonenum1;
        }
        //4.通过s可以获取枚举
        public static SeasonEnum valueOf(String s)
        {
            return (SeasonEnum)Enum.valueOf(com/xmg/enums/SeasonEnum, s);
        }

        //2.实例化枚举对象
        static 
        {
            SPRING = new SeasonEnum("SPRING", 0);//第一个参数是：常量名，第二个参数是：常量的索引
            SUMMER = new SeasonEnum("SUMMER", 1);
            FALL = new SeasonEnum("FALL", 2);
            WINTER = new SeasonEnum("WINTER", 3);
            ENUM$VALUES = (new SeasonEnum[] {
                SPRING, SUMMER, FALL, WINTER
            });
        }
    }

• 总结：

  枚举中定义的常量，引用的是一个枚举的对象，对象是通过默认的私有化构造器实例化

3.SeasonEnum季节枚举的简单使用

    public class TestEnums {
        public static void main(String [] a){
            System.out.println(SeasonEnum.SPRING);//输出结果是：SPRING

            SeasonEnum summer = SeasonEnum.SUMMER;//实例化一个枚举对象

            //switch底层比较的是常量所在的索引
            switch (summer) {//jdk1.5的switch支持枚举的比较：传入枚举对象
            case SUMMER://枚举的常量
                System.out.println(summer);//输出结果是：SUMMER
                break;

            default:
                break;
            }

            //if底层比较的是枚举的引用
            if(summer==SeasonEnum.SUMMER){//是true
                System.out.println(summer);//输出结果是：SUMMER
            }
        }

    }

    //执行main输出的结果是：
            SPRING
            SUMMER
            SUMMER

• 底层实现的原理

        public class TestEnums
        {
            public static void main(String a[])
            {
                System.out.println(SeasonEnum.SPRING);
                SeasonEnum summer = SeasonEnum.SUMMER;
                //summer.ordinal()方法的作用就是去获取SUMMER常亮在枚举数组中的索引，返回值是2
                switch ($SWITCH_TABLE$com$xmg$enums$SeasonEnum()[summer.ordinal()])
                {
                case 2: // '\002'
                    System.out.println(summer);
                    break;
                }
                if (summer == SeasonEnum.SUMMER)
                    System.out.println(summer);
            }
            .....
            .....
            .....
            .....

        }

• 总结

  枚举的比较，其实比较的是：索引和引用，而不是常量的名称

4.枚举的常量也可以使用中文

    //枚举类
    public enum SeasonEnum2 {
        春天,夏天,秋天,冬天;
    }

    //测试类
    public class TestEnums2 {
        public static void main(String [] a){
            System.out.println(SeasonEnum2.春天);//输出结果是：春天

            SeasonEnum2 summer = SeasonEnum2.夏天;//实例化一个枚举对象
            //switch底层比较的是常量所在的索引
            switch (summer) {//jdk1.5的switch支持枚举的比较：传入枚举对象
            case 夏天://枚举的常量
                System.out.println(summer);//输出结果是：夏天
                break;

            default:
                break;
            }

            //if底层比较的是枚举的引用
            if(summer==SeasonEnum2.夏天){
                System.out.println(summer);//输出结果是：夏天
            }
        }

    }

    //输出的结果:
            春天
            夏天
            夏天

• 总结

  枚举的比较，其实比较的是：索引和引用，而不是常量的名称

5.自定义构造器，实现值得比较

    //自定义一个是否使用硬盘缓存的枚举
    public enum DiskCacheEnum {
        //常量名（在实例化枚举对象时，给构造器传递参数）
        TRUE(true),FALSE(false);

        //自定义boolean字段
        private final boolean isDiskCache;

        //自定义构造器，默认都是私有（当调用DiskCacheEnum.TRUE时，就会调用该构造器）
        DiskCacheEnum(boolean isDiskCache){
            this.isDiskCache=isDiskCache;
        }

        //获取字段的值
        public boolean isDiskCache() {
            return isDiskCache;
        }
    }


    //测试(比较字段的值，而不是比较枚举的“引用和索引”)
    public static void main(String [] a){

        DiskCacheEnum diskCacheEnum = DiskCacheEnum.TRUE;
        System.out.println(diskCacheEnum);//输出：TRUE
        if(diskCacheEnum.isDiskCache()){//判断布尔值的字段的值是否为true
            System.out.println(diskCacheEnum.isDiskCache());//输出布尔值的：true
        }

    }

• 总结

  这样就可以实现通过新建一个枚举（使用枚举的值）来与从数据库获取的值进行比较

6.用枚举设计单例

饿汉式单例：

    class SingleTon {

        private static SingleTon instance=new SingleTon();

        private SingleTon(){}

        public static SingleDemo getInstance(){
            return instance;
        }

    }

    //单例对象的获取：
    SingleTon instance = SingleTon.getInstance();

通过枚举实现饿汉式单例：

    public enum SingleTon {
        INSTANCE;
    }

    //单例对象的获取：
    SingleTon instance = SingleTon.INSTANCE;