关键字 enum 枚举

  enum  枚举

是常用

常用常量集合；
通过 enum创建枚举；enum和class 一样是个关键字，但是它并不是一个类；
枚举类型中可以定义成员变量和方法；
public enum Season {
　　//每个枚举项都是一个常量,我们使用常量的命名规则(全部大写,不同单词之间使用下划线分割)
　　SPRING,SUMMER,AUTUMN,WINTER;
}
如若不然；枚举类型的常用模式是声明一组具有int类型的常量；
public class Sesson{
　　public static finnal int SPRING = 1;
　　public static finnal int SUMMER = 2;
　　public static finnal int AUTUMN = 3;
　　public static finnal int WINTER = 4;
}

JAVA枚举类型（Enum）的使用

 public class Test{
   public static void main(String[] args) {
    String summer = "SUMMER";
    //通过valueOf，获取SUMMER的枚举类型
    SeasonEnum season2 = SeasonEnum.valueOf(summer); 
    //直接初始化
    SeasonEnum season1 = SeasonEnum.SPRING; 
　　// switch 只能使用整型；实际是将枚举转换成int类型进行支持的；switch(operation.ordinal())
    switch (season1) {  
            case SPRING:  
                 System.out.println("春天"); 
                 break;  
            case SUMMER:  
                 System.out.println("夏天"); 
                 break;  
            case AUTUMN:  
                 System.out.println("秋天"); 
                 break; 
            case WINTER:  
                 System.out.println("冬天"); 
                 break; 
        }  
    }  
}

switch(表达式)
{
case 常量表达式1:
语句1;
break;
…
case 常量表达式2:
语句2;
break;
default:语句;
}

 如果只需要实现这样的功能，定义一个常量类也可以实现，

枚举的进阶使用；是对枚举进行成员变量和方法的操作；和java类差不多只是，枚举限制了类型；

public enum SeasonEnum {
    //枚举类的实例对象必须在最前面先定义，而且必须每个实例对象都必须维护上chinese成员变量
    SPRING("春天"),SUMMER("夏天"),AUMUTN("秋天"),WINTER("冬天");
 
    private String chinese;
 
    //枚举类型的构造函数默认为private，因为枚举类型的初始化要在当前枚举类中完成。
    SeasonEnum (String chinese){
        this.chinese= chinese;
    }
 
    public String getChinese(){
        return chinese;
    }
}

 public class Test{
    public static void main(String[] args) {
    //直接初始化
    SeasonEnum season1 = SeasonEnum.SPRING; 
    //调用SeasonEnum枚举类的getChinese()方法获取SPRING的中文值
    System.out.println(season1.getChinese()); 
    
   }  
} 

---简化了代码

枚举的源码实现中

enum类型中定义了两个变量；分别是name和ordinal;
name的存在所有需要给枚举项定义一个名字；
ordinal的存在，枚举会给每个枚举项默认整数类型的序号。

枚举方式是实现单例最好的方式；
之前用的创建单例的方法是懒汉式的双锁校验；

　　代码之所以臃肿，是因为保证线程的安全性，不得不在线程安全和锁粒度之间做取舍；但是有个问题 无法解决反序列化会破坏单例模式的问题；

//单例实现的懒汉式的双层锁校验；
public class Slingleton {
    private volatile static Singleton singleton;
    private Singelton (){}
    public static Singleton getSingleton(){
        if(singleton != null){
            synchronized (Singleton.class){
                if(singleton != null){
                    singleton = new Singleton();
                }
            }
        }
    
        return singelton;
    }

枚举实现单例模式；

public enum Singleton {
    INSTANCE;
    public void watererMethod() {
    }
}