Java 枚举和枚举类

Java 枚举

在本教程中，我们将学习 Java 中的枚举。我们将在示例的帮助下学习创建和使用枚举和枚举类。

在 Java 中，枚举（enumeration 的缩写）是一种具有一组固定常量值的类型。我们使用enum关键字来声明枚举。例如，

enum Size { 
   SMALL, MEDIUM, LARGE, EXTRALARGE 
}

在这里，我们创建了一个名为的枚举 尺寸. 它包含固定值小的, 中等的, 大， 和 超大.

大括号内的这些值称为枚举常量（值）。

注意：枚举常量通常以大写形式表示。

---

示例 1：Java 枚举

enum Size {
   SMALL, MEDIUM, LARGE, EXTRALARGE
}

class Main {
   public static void main(String[] args) {
      System.out.println(Size.SMALL);
      System.out.println(Size.MEDIUM);
   }
}

输出

SMALL
MEDIUM

正如我们从上面的例子中看到的，我们使用枚举名称来访问常量值。

此外，我们可以创建枚举类型的变量。例如，

Size pizzaSize;

这里， 比萨大小 是一个变量 尺寸类型。它只能分配 4 个值。

pizzaSize = Size.SMALL;
pizzaSize = Size.MEDIUM;
pizzaSize = Size.LARGE;
pizzaSize = Size.EXTRALARGE;

---

示例 2：带有 switch 语句的 Java 枚举

enum Size {
 SMALL, MEDIUM, LARGE, EXTRALARGE
}

class Test {
 Size pizzaSize;
 public Test(Size pizzaSize) {
   this.pizzaSize = pizzaSize;
 }
 public void orderPizza() {
   switch(pizzaSize) {
     case SMALL:
       System.out.println("I ordered a small size pizza.");
       break;
     case MEDIUM:
       System.out.println("I ordered a medium size pizza.");
       break;
     default:
       System.out.println("I don't know which one to order.");
       break;
   }
 }
}

class Main {
 public static void main(String[] args) {
   Test t1 = new Test(Size.MEDIUM);
   t1.orderPizza();
 }
}

输出

I ordered a medium size pizza.

在上面的程序中，我们创建了一个枚举类型 尺寸. 然后我们声明了一个变量比萨大小 的 尺寸 类型。

这里，变量 比萨大小 只能分配 4 个值 (小的, 中等的, 大, 超大）。

注意声明，

Test t1 = new Test(Size.MEDIUM);

它将调用Test()内部的构造函数测试班级。现在，变量比萨大小 被分配了 中等的 不变。

根据该值，执行switch case 语句的其中一种情况。

---

Java 中的枚举类

在 Java 中，枚举类型被认为是一种特殊类型的类。它是随着 Java 5 的发布而引入的。

枚举类可以像常规类一样包含方法和字段。

enum Size {
    constant1, constant2, …, constantN;

    // methods and fields	
}

当我们创建一个枚举类时，编译器会创建每个枚举常量的实例（对象）。此外，public static final默认情况下所有枚举常量始终是。

---

示例 3：Java 枚举类

enum Size{
  SMALL, MEDIUM, LARGE, EXTRALARGE;

  public String getSize() {

    // this will refer to the object SMALL
    switch(this) {
      case SMALL:
        return "small";

      case MEDIUM:
        return "medium";

      case LARGE:
        return "large";

      case EXTRALARGE:
        return "extra large";

      default:
        return null;
      }
   }

  public static void main(String[] args) {

    // call getSize()
    // using the object SMALL
    System.out.println("The size of the pizza is " + Size.SMALL.getSize());
  }
}

输出

The size of the pizza is small

在上面的例子中，我们创建了一个枚举类 尺寸. 它有四个常数小的, 中等的, 大 和 超大.

自从 尺寸 是一个枚举类，编译器会自动为每个枚举常量创建实例。

在main()方法内部，我们使用了实例小的调用该getSize()方法。

注意：与常规类一样，枚举类也可能包含构造函数。要了解更多信息，请访问Java 枚举构造函数。

---

Java 枚举类的方法

枚举类中有一些预定义的方法可供使用。

1. Java Enum ordinal()

该ordinal()方法返回枚举常量的位置。例如，

ordinal(SMALL) 
// returns 0

2. 枚举 compareTo()

该compareTo()方法根据序数值比较枚举常量。例如，

Size.SMALL.compareTo(Size.MEDIUM)
 // returns ordinal(SMALL) - ordinal(MEDIUM)

3.枚举toString()

该toString()方法返回枚举常量的字符串表示形式。例如，

SMALL.toString()
// returns "SMALL"

4.枚举名称()

该name()方法以字符串形式返回枚举常量的定义名称。该name()方法的返回值为final。例如，

name(SMALL)
// returns "SMALL"

5. Java 枚举 valueOf()

该valueOf()方法接受一个字符串并返回一个具有相同字符串名称的枚举常量。例如，

Size.valueOf("SMALL")
// returns constant SMALL.

6.枚举值()

该values()方法返回一个包含所有枚举常量的枚举类型数组。例如，

Size[] enumArray = Size.value();

---

为什么是 Java 枚举？

在 Java 中，引入了 enum 来代替 int 常量的使用。

假设我们使用了一组int常量。

class Size {
   public final static int SMALL = 1;
   public final static int MEDIUM = 2;
   public final static int LARGE = 3;
   public final static int EXTRALARGE = 4;
}

在这里，如果我们打印常量就会出现问题。这是因为只打印了可能没有帮助的数字。

因此，我们可以简单地使用枚举，而不是使用 int 常量。例如，

enum Size {
   SMALL, MEDIUM, LARGE, EXTRALARGE
}

这使我们的代码更加直观。

此外， enum 提供编译时类型安全。

如果我们声明一个变量 尺寸类型。例如，

Size size;

在这里，保证变量将保存四个值之一。现在，如果我们尝试传递这四个值以外的值，编译器将产生错误。

在 Java 中，枚举类可能像常规类一样包含构造函数。这些枚举构造函数是

• 私人- 在班级内访问
  或
• package-private - 在包内访问

---

示例：枚举构造函数

enum Size {

   // enum constants calling the enum constructors 
   SMALL("The size is small."),
   MEDIUM("The size is medium."),
   LARGE("The size is large."),
   EXTRALARGE("The size is extra large.");

   private final String pizzaSize;

   // private enum constructor
   private Size(String pizzaSize) {
      this.pizzaSize = pizzaSize;
   }

   public String getSize() {
      return pizzaSize;
   }
}

class Main {
   public static void main(String[] args) {
      Size size = Size.SMALL;
      System.out.println(size.getSize());
   }
}

输出

The size is small.

在上面的例子中，我们创建了一个枚举 尺寸. 它包括一个private枚举构造函数。构造函数接受一个字符串值作为参数，并为变量赋值比萨大小.

由于构造函数是private，我们无法从类外部访问它。但是，我们可以使用枚举常量来调用构造函数。

在里面 主要的 类，我们将 SMALL 分配给枚举变量 尺寸. 常数小的 然后调用构造函数 尺寸 以字符串为参数。

最后，我们调用getSize()using尺寸.

Java 枚举字符串

在Java中，我们可以使用toString()方法或name()方法来获取枚举常量的字符串表示。例如，

enum Size {
   SMALL, MEDIUM, LARGE, EXTRALARGE
}

class Main {
   public static void main(String[] args) {

      System.out.println("string value of SMALL is " + Size.SMALL.toString());
      System.out.println("string value of MEDIUM is " + Size.MEDIUM.name());

   }
}

输出

string value of SMALL is SMALL
string value of MEDIUM is MEDIUM

在上面的例子中，我们已经看到枚举常量的默认字符串表示是同一个常量的名称。

---

更改枚举的默认字符串值

我们可以通过覆盖该toString()方法来更改枚举常量的默认字符串表示形式。例如，

enum Size {
   SMALL {

      // overriding toString() for SMALL
      public String toString() {
        return "The size is small.";
      }
   },

   MEDIUM {

     // overriding toString() for MEDIUM
      public String toString() {
        return "The size is medium.";
      }
   };
}

class Main {
   public static void main(String[] args) {
      System.out.println(Size.MEDIUM.toString());
   }
}

输出

The size is medium.

在上面的程序中，我们创建了一个枚举 尺寸. 我们已经覆盖了toString()枚举常量SMALL和的方法MEDIUM。

注意：我们不能覆盖该name()方法。这是因为name()方法是final.

要了解更多信息，请访问创建枚举 String 的最佳方法。