# Java 枚举

> 原文： [https://www.programiz.com/java-programming/enums](https://www.programiz.com/java-programming/enums)

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

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

```java
enum Size { 
   SMALL, MEDIUM, LARGE, EXTRALARGE 
} 
```

在这里，我们创建了一个名为`Size`的枚举。

花括号内的值称为枚举值（常量）。 这些是枚举类型可以保留的唯一值。

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

让我们举一个简单的例子。

```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);
   }
} 
```

**输出**

```java
SMALL
MEDIUM 
```

从上面的示例可以看出，我们使用枚举名称来访问常量值。

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

```java
Size pizzaSize; 
```

在此，`pizzaSize`是`Size`类型的变量。 它只能分配 4 个值。

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

* * *

### 示例 1：Java 枚举

```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();
 }
} 
```

**输出**：

```java
I ordered a medium size pizza. 
```

在上面的程序中，我们创建了一个枚举类型`Size`。 然后，我们声明了`Size`类型的变量`pizzaSize`。

变量`pizzaSize`只能分配 4 个值（`SMALL`，`MEDIUM`，`LARGE`，`EXTRALARGE`）。

变量`pizzaSize`分配有`MEDIUM`常数。 基于此，将打印`switch case`语句的一种情况。

* * *

## Java 枚举类

在 Java 中，枚举类型被认为是类的一种特殊类型。 它是在 Java 5 发行版中引入的。

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

```java
enum Size {
    constant1, constant2, …, constantN;

    // methods and fields	
} 
```

默认情况下，枚举常量始终为`public static final`。

创建枚举类时，编译器还将创建每个枚举常量的实例（对象）。

* * *

### 示例 2：枚举类

```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) {

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

**输出**：

```java
The size of the pizza is small 
```

在上面的示例中，我们创建了一个枚举类`Size`。 它具有四个常数`SMALL`，`MEDIUM`，`LARGE`和`EXTRALARGE`。

由于`size`是一个枚举类，因此编译器会自动为每个枚举常量创建实例。

在`main()`方法内部，我们使用实例`SMALL`来调用`getSize()`方法。

* * *

像常规类一样，枚举类也可以包含构造器。 要了解更多信息，请访问 [Java 枚举构造器](/java-programming/enum-constructor "Java enum constructor")。

* * *

## 枚举类的方法

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

### `ordinal()`方法

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

```java
ordinal(SMALL) 
// returns 0 
```

### `compareTo()`方法

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

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

### `toString()`方法

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

```java
SMALL.toString()
// returns "SMALL" 
```

### `name()`方法

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

```java
name(SMALL)
// returns "SMALL" 
```

### `valueOf()`方法

`valueOf()`方法采用字符串，并返回具有相同字符串名称的枚举常量。 例如，

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

### `values()`方法

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

```java
Size[] enumArray = Size.value(); 
```

* * *

## 为什么使用 Java 枚举？

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

假设我们使用了`int`常量的集合。

```java
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`常量，我们可以简单地使用枚举。 例如，

```java
enum Size {
   SMALL, MEDIUM, LARGE, EXTRALARGE
} 
```

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

同样，枚举提供了编译时类型的安全性。

如果我们声明一个`Size`类型的变量（如上述示例中所示），则可以确保该变量将容纳四个值之一。 如果我们尝试传递这四个值以外的值，则编译器将生成错误。