声明和使用基本枚举

枚举可以被认为是用于密封类的语法糖，该类仅在编译时在编译时已知的许多次数来定义一组常量。

列出不同季节的简单枚举将被声明如下：

public enum Season {
   WINTER,
   SPRING,
   SUMMER,
   FALL
}

虽然枚举常量不一定需要全部大写，但它是Java惯例，常量的名称完全是大写的，单词由下划线分隔。

我们可以在自己的文件中声明枚举：

/**
* This enum is declared in the Season.java file.
*/
public enum Season {
   WINTER,
   SPRING,
   SUMMER,
   FALL
}

但你也可以在另一个类内声明它：

public class Day {
    private Season season;
    public String getSeason() {
        return season.name();
    }
    public void setSeason(String season) {
        this.season = Season.valueOf(season);
    }
    /**
    * This enum is declared inside the Day.java file and
    * cannot be accessed outside because it's declared as private.
    */
    private enum Season {
         WINTER,
         SPRING,
         SUMMER,
         FALL
    }
}

最后，我们无法在方法正文或者构造函数内声明枚举：

public class Day {
     /**
     * Constructor
     */
     public Day() {
         //Illegal. Compilation error
         enum Season {
               WINTER,
               SPRING,
               SUMMER,
               FALL
         }
    }
    public void aSimpleMethod() {
         //Legal. You can declare a primitive (or an Object) inside a method. Compile!
        int primitiveInt = 42;
        //Illegal. Compilation error.
        enum Season {
             WINTER,
             SPRING,
             SUMMER,
             FALL
        }
        Season season = Season.SPRING;
     }
}

不允许重复的枚举常量：

public enum Season {
    WINTER,
    WINTER, //Compile Time Error : Duplicate Constants
    SPRING,
    SUMMER,
    FALL
}

easum的每个常数都是公共，静态和最终默认情况下。
由于每个常量都是静态的，可以使用枚举名称直接访问它们。

枚举常量可以随着方法参数传递：

public static void display(Season s) {
      System.out.println(s.name()); //name() is a built-in method that gets the exact name of the enum constant
}
display(Season.WINTER); //Prints out "WINTER"

我们可以使用值()方法获取枚举常量的数组。
值保证在返回的数组中处于声明顺序：

Season[] seasons = Season.values();

注意：此方法每次调用时都会分配新的值数组。

迭代枚举常量：

public static void enumIterate() {
    for (Season s : Season.values()) {
        System.out.println(s.name());
    }
}

我们可以在switch语句中使用枚举：

public static void enumSwitchExample(Season s) {
     switch(s) {
         case WINTER:
              System.out.println("It's pretty cold");
              break;
         case SPRING:
              System.out.println("It's warming up");
              break;
         case SUMMER:
              System.out.println("It's pretty hot");
              break;
         case FALL:
              System.out.println("It's cooling down");
              break;
       }
}

我们还可以使用==比较枚举常量：

Season.FALL == Season.WINTER     //false
Season.SPRING == Season.SPRING   //true

将枚举常量进行比较的另一种方法是使用等于()如下所示，这被认为是不良的做法，因为我们可以轻松地落入陷阱，如下所示：

Season.FALL.equals(Season.FALL);   //true
Season.FALL.equals(Season.WINTER); //false
Season.FALL.equals("FALL");        //false and no compiler error

此外，虽然枚举中的一组实例在运行时不能更改，但本身本身并不是不可变的，因为与任何其他类一样，枚举可以包含如下所示的可变字段。

public enum MutableExample {
    A,
    B;
    private int count = 0;
    public void increment() {
         count++;
    }
    public void print() {
         System.out.println("The count of " + name() + " is " + count);
    }
}
//Usage:
MutableExample.A.print(); //Outputs 0
MutableExample.A.increment();
MutableExample.A.print(); //Outputs 1 -- we've changed a field
MutableExample.B.print(); //Outputs 0 -- another instance remains unchanged

但是，良好的做法是使枚举实例成为可能的，例如：当它们没有任何其他字段或者所有这些字段标记为最终并且是不可变的。
这将确保为应用程序的生命周期，枚举不会泄露任何内存，并且在所有线程中使用其实例是安全的。

Java枚举（使用enum关键字声明）是单个类别的大量常量的速写语法。