在使用enum之前，需要先创建一个整型常量集，但枚举值并不会取值限定在这个常量集的范围内，因此，具有一定的风险，且较难使用。


枚举类型的创建,
public enum Spiciness{
    NOT,MILD,MEDIUM,HOT,FLAMING
}
创建枚举类型时编译器会自动添加一些特性，如会自动创建toString()方法，以便你可以很方便的显示某个enum实例的名字，除此之外，还会创建ordinal()方法，用于表示某个特定enum常量的声明顺序；还有static values()方法，按照enum常量的声明，产生由这些常量构成的数组：

实例如下：

public class SimpleEnumUse {
public enum Spiciness{
	NOT,MILD,MEDIUM,HOT,FLAMING
}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Spiciness hotHot= Spiciness.MEDIUM;
		System.out.println(hotHot);
		for(Spiciness s:Spiciness.values())          //value()方法用来产生顺序数组
			System.out.println(s+",ordinal "+s.ordinal());//ordinal()方法用来声明顺序
	}
}
/* Output:
NOT,ordinal 0
MILD,ordinal 1
MEDIUM,ordinal 2
HOT,ordinal 3
*/
由此可见，可以把enum当作其他类来处理。事实上enum确实是类，而且可以用有限的可能值集合配合switch使用。
如下，
import thinkinginjava5_.SimpleEnumUse.Spiciness;
class Burrito{
	Spiciness degree;
	public Burrito(Spiciness degree) {
		// TODO Auto-generated constructor stub
		this.degree=degree;
	}
	public void describe(){
		System.out.print("This burrito is ");
		switch(degree){
		case NOT:System.out.println("not spicy at all.");
			break;
		case MILD:
		case MEDIUM:System.out.println("a little hot");
		break;
		case HOT:
		case FLAMING:System.out.println("maybe too hot");
		break;
		}
	}
}
public class SimpleEnumUse {
public enum Spiciness{
	NOT,MILD,MEDIUM,HOT,FLAMING
}
	public static void main(String[] args) {
		// TODO Auto-generated method stub		
		Burrito plain=new Burrito(Spiciness.NOT),
		greenChile=new Burrito(Spiciness.MEDIUM),
		jalapeno=new Burrito(Spiciness.HOT);
		plain.describe();
		greenChile.describe();
		jalapeno.describe();
		
	}
}
/*Output 
This burrito is not spicy at all.
This burrito is a little hot
This burrito is maybe too hot
 */

今天写枚举类的时候发现了一个有趣的现象，在这里分享一下：
 
首先我们定义一个简单的枚举类：
 
/**
 * @author jinghuaixin
 * @date 2020/04/30
 */
public enum Week {

    Monday, Tuesday;
    // 静态代码块
    static {
        System.out.println("枚举中静态代码块执行了");
    }

    // 构造方法
    private Week() {
        System.out.println("枚举中构造方法执行了");
    }

    // 构造代码块
    {
        System.out.println("枚举中代码块执行了");
    }
}
 
然后定义一个简单的测试类：
 
public class TestEnum {

    static {
        System.out.println("普通类中静态代码块执行了");
    }
    {
        System.out.println("普通类中代码块执行了");
    }

    public TestEnum() {
        System.out.println("普通类的构造方法执行了");
    }

    public static void main(String[] args) {
        new TestEnum();
        System.out.println("+++++++++++++++++++++++++++");
        new TestEnum();
        System.out.println("=========================");
        Week week = Week.Monday;
        System.out.println("=========================");
        Week week2 = Week.Tuesday;
    }

}
 
运行结果：
 
普通类中静态代码块执行了
普通类中代码块执行了
普通类的构造方法执行了
+++++++++++++++++++++++++++
普通类中代码块执行了
普通类的构造方法执行了
=========================
枚举中代码块执行了
枚举中构造方法执行了
枚举中代码块执行了
枚举中构造方法执行了
枚举中静态代码块执行了
=========================
 
普通类中，静态代码块在类加载的时候执行，类只会加载一次，所以只会执行一次，并且这个动作在对象实例化之前，所以是最先输出的，紧接着每次实例化都会去调用构造代码块和构造方法，所以会2次输出。但是枚举类就比较有趣了，可以看到枚举类中第一次使用的时候，调用构造代码块和构造方法块执行次数和枚举元素相等，第二次并没有再调用构造代码块和构造方法，静态代码块虽然也只执行了一次，但是却放在最后了，这是为什么呢？
 
我们借助jad反编译一下枚举类的代码：
 
jad Week.class
 
反编译生成的代码：
 
// Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://www.kpdus.com/jad.html
// Decompiler options: packimports(3) 
// Source File Name:   Week.java

package learnbymaven.single;

import java.io.PrintStream;

public final class Week extends Enum
{

    private Week(String s, int i)
    {
        super(s, i);
        System.out.println("枚举中代码块执行了");
        System.out.println("枚举中构造方法执行了");
    }

    public static Week[] values()
    {
        Week aweek[];
        int i;
        Week aweek1[];
        System.arraycopy(aweek = ENUM$VALUES, 0, aweek1 = new Week[i = aweek.length], 0, i);
        return aweek1;
    }

    public static Week valueOf(String s)
    {
        return (Week)Enum.valueOf(learnbymaven/single/Week, s);
    }

    public static final Week Monday;
    public static final Week Tuesday;
    private static final Week ENUM$VALUES[];
	
	// 静态代码块初始化变量
    static 
    {
        Monday = new Week("Monday", 0);
        Tuesday = new Week("Tuesday", 1);
        ENUM$VALUES = (new Week[] {
            Monday, Tuesday
        });
        System.out.println("枚举中静态代码块执行了");
    }
}

 
通过反编译代码可以看到，枚举底层其实还是class，枚举元素是被声明成public static final的成员变量（可以通过类名直接调用），并且在static静态代码块中一起初始化了，这就解释了为什么第一次调用枚举类的时候，构造代码块和构造方法执行次数会和枚举元素相等，因为第一次加载类的时候就全部初始化了。由于java类的加载和初始化过程都是线程安全的，所以创建一个enum类型是线程安全的

知识点：枚举类 所有的枚举值都是类静态常量，在初始化时会对所有的枚举值对象进行第一次初始化。
 
package zml;
enum AccountType
{
    SAVING, FIXED, CURRENT;
    private AccountType()
    {
        System.out.println("It is a account type");
    }
}

 
public class TestEnum {
     public static void main(String[]args)
        {
            System.out.println(AccountType.FIXED);
            System.out.println("=================");
            System.out.println(AccountType.FIXED);
        }
}

 
结果：
 

 

 1、含义:
 

      个人的理解是，枚举就相当于是程序员自己定义的一组变量集合，当需要使用这些变量时，你只能在这个定义好的变量集合中取。
 

 
 
 

 2、作用：
 

      （1）限定取值范围，所有的内容只能从指定的范围中取得；
 

      （2）枚举还以按索引走，枚举的查找、比较、遍历都较为方便
 

      （3）枚举
 限定了取值范围，因此它的数据安全相对较高一些。
 

      （4）枚举定义的类相对比较明了、实用。
 

 
 
 

 3、用法：
 

 
 
 

 （1）定义：
 

      public 
 enum 
 State
 

           {
 

                  
 SUCCESS
 , 
 RETRY
 , 
 ERROR
 , 
 CRITICAL
 , 
 BLOCKED
 

           }
 

 
 
 

  (2)调用：State state= State.SUCCESS;
 

 
 
 

  (3)用法总结:
 

      定义枚举类，本质上也是一个普通的java类，它也可以声明构造函数（但是只能是私有或者包级私有）、成员变量和成员方法，还能实现接口，值得注意的是，成员变量和成员方                      法的声明必须放在所有枚举值定义的后面。
 enum定义时，定义出来的类型是默认继承java.lang.Enum类，并非Object类，它默认实现了java.lang.Comparable和 java.io.Serializable接口。所有的枚举类型都是final类，它没有子类。枚举值都是public static final，枚举值是常量，故通常应该大写。
 

 （4）常用的方法: 
 int compareTo方法
 
                                  String name():返回枚举实例的名称
 
                    int ordinal() 返回枚举值在枚举中的索引
 
                    String toString()返回枚举的实例名称 比name更常用
 

                      valueOf()
 

                    values()
 

      用法如下：
 
 
 

       public class EnumTest {
 
 
 

            public static void main(String[] args){
 
 
 

                 State sta =State.SUCCESS;
 
 
                System.out.println(sta );//FRI
 
 
                System.out.println(sta.name());//FRI
 
 
                System.out.println(sta .ordinal());//4
 
 
 

            System.out.println(State.valueOf("SUN").toLocaleString());//星期日
 
 
 
 
                System.out.println(sta.values().length);//7  获取枚举长度
 
 
           }
      }
 
 
 遍历：
 
 
      for(State st:State.values()){
 
               System.out.println(
st
 
);
          } 

  (5)枚举的构造函数：
 

      public enum Gender {
 

           MALE("男"),FEMALE("女");
           private String name;
           private Gender(String name){
           this.name =name;
     }
     public String getName(){
         return this.name;
     }
  
 

  
 
 
 
 

  （6）适用范围：
 
 
 
 
  
包中、类中，不能在方法中；
使用场合：从另一个函数得到一个值，但是这个值只能够在一个范围内，实用枚举可以限制这个函数传递进来的值。
当考虑在类中要指定选项必须为某些类型时。
 
 
 
 

  
 
 
 
 

  （7）注意事项
 
 
 

       枚举也像普通的类一样可以添加属性和方法，可以是静态的，也可以是非静态的
 
 
 

       注意：枚举定义时，必须写类体在最前面，否则会编译出错。