枚举类型

原文： https://docs.oracle.com/javase/tutorial/java/javaOO/enum.html

枚举类型是一种特殊数据类型，它使变量成为一组预定义常量。变量必须等于为其预定义的值之一。常见示例包括罗盘方向（NORTH，SOUTH，EAST 和 WEST 的值）和星期几。

因为它们是常量，所以枚举类型字段的名称是大写字母。

在 Java 编程语言中，您可以使用enum关键字定义枚举类型。例如，您可以将星期几的枚举类型指定为：

  1. public enum Day {
  2.     SUNDAY, MONDAY, TUESDAY, WEDNESDAY,
  3.     THURSDAY, FRIDAY, SATURDAY 
  4. }

您需要在需要表示一组固定常量时使用枚举类型。这包括自然枚举类型，例如太阳系中的行星和数据集，您可以在编译时知道所有可能的值 - 例如，菜单上的选项，命令行标志等。

以下是一些代码，向您展示如何使用上面定义的Day枚举：

  1. public class EnumTest {
  2.     Day day;
  4.     public EnumTest(Day day) {
  5.         this.day = day;
  6.     }
  8.     public void tellItLikeItIs() {
  9.         switch (day) {
  10.             case MONDAY:
  11.                 System.out.println("Mondays are bad.");
  12.                 break;
  14.             case FRIDAY:
  15.                 System.out.println("Fridays are better.");
  16.                 break;
  18.             case SATURDAY: case SUNDAY:
  19.                 System.out.println("Weekends are best.");
  20.                 break;
  22.             default:
  23.                 System.out.println("Midweek days are so-so.");
  24.                 break;
  25.         }
  26.     }
  28.     public static void main(String[] args) {
  29.         EnumTest firstDay = new EnumTest(Day.MONDAY);
  30.         firstDay.tellItLikeItIs();
  31.         EnumTest thirdDay = new EnumTest(Day.WEDNESDAY);
  32.         thirdDay.tellItLikeItIs();
  33.         EnumTest fifthDay = new EnumTest(Day.FRIDAY);
  34.         fifthDay.tellItLikeItIs();
  35.         EnumTest sixthDay = new EnumTest(Day.SATURDAY);
  36.         sixthDay.tellItLikeItIs();
  37.         EnumTest seventhDay = new EnumTest(Day.SUNDAY);
  38.         seventhDay.tellItLikeItIs();
  39.     }
  40. }

输出是：

  1. Mondays are bad.
  2. Midweek days are so-so.
  3. Fridays are better.
  4. Weekends are best.
  5. Weekends are best.

Java 编程语言枚举类型比其他语言中的对应类型更强大。 enum声明定义类（称为枚举类型）。枚举类主体可以包括方法和其他字段。编译器在创建枚举时会自动添加一些特殊方法。例如，它们有一个静态values方法，该方法返回一个数组，该数组按照声明的顺序包含枚举的所有值。此方法通常与 for-each 构造结合使用，以迭代枚举类型的值。例如，下面Planet类示例中的代码迭代太阳系中的所有行星。

  1. for (Planet p : Planet.values()) {
  2.     System.out.printf("Your weight on %s is %f%n",
  3.                       p, p.surfaceWeight(mass));
  4. }

Note: All enums implicitly extend java.lang.Enum. Because a class can only extend one parent (see Declaring Classes), the Java language does not support multiple inheritance of state (see Multiple Inheritance of State, Implementation, and Type), and therefore an enum cannot extend anything else.

在以下示例中，Planet是枚举类型，表示太阳系中的行星。它们具有恒定的质量和半径属性。

每个枚举常量都声明为质量和半径参数的值。创建常量时，这些值将传递给构造器。 Java 要求在任何字段或方法之前首先定义常量。此外，当存在字段和方法时，枚举常量列表必须以分号结尾。

Note: The constructor for an enum type must be package-private or private access. It automatically creates the constants that are defined at the beginning of the enum body. You cannot invoke an enum constructor yourself.

除了它的属性和构造器之外，Planet还有一些方法可以让你检索每个行星上一个物体的表面重力和重量。这是一个示例程序，它可以减轻地球上的重量（在任何单位）并计算并打印所有行星上的重量（在同一单位）：

  1. public enum Planet {
  2.     MERCURY (3.303e+23, 2.4397e6),
  3.     VENUS   (4.869e+24, 6.0518e6),
  4.     EARTH   (5.976e+24, 6.37814e6),
  5.     MARS    (6.421e+23, 3.3972e6),
  6.     JUPITER (1.9e+27,   7.1492e7),
  7.     SATURN  (5.688e+26, 6.0268e7),
  8.     URANUS  (8.686e+25, 2.5559e7),
  9.     NEPTUNE (1.024e+26, 2.4746e7);
  11.     private final double mass;   // in kilograms
  12.     private final double radius; // in meters
  13.     Planet(double mass, double radius) {
  14.         this.mass = mass;
  15.         this.radius = radius;
  16.     }
  17.     private double mass() { return mass; }
  18.     private double radius() { return radius; }
  20.     // universal gravitational constant  (m3 kg-1 s-2)
  21.     public static final double G = 6.67300E-11;
  23.     double surfaceGravity() {
  24.         return G * mass / (radius * radius);
  25.     }
  26.     double surfaceWeight(double otherMass) {
  27.         return otherMass * surfaceGravity();
  28.     }
  29.     public static void main(String[] args) {
  30.         if (args.length != 1) {
  31.             System.err.println("Usage: java Planet <earth_weight>");
  32.             System.exit(-1);
  33.         }
  34.         double earthWeight = Double.parseDouble(args[0]);
  35.         double mass = earthWeight/EARTH.surfaceGravity();
  36.         for (Planet p : Planet.values())
  37.            System.out.printf("Your weight on %s is %f%n",
  38.                              p, p.surfaceWeight(mass));
  39.     }
  40. }

如果从参数为 175 的命令行运行Planet.class，则会得到以下输出：

  1. $ java Planet 175
  2. Your weight on MERCURY is 66.107583
  3. Your weight on VENUS is 158.374842
  4. Your weight on EARTH is 175.000000
  5. Your weight on MARS is 66.279007
  6. Your weight on JUPITER is 442.847567
  7. Your weight on SATURN is 186.552719
  8. Your weight on URANUS is 158.397260
  9. Your weight on NEPTUNE is 199.207413