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;