Enumeraciones (Enum) de Java

En este tutorial, aprenderemos sobre las enumeraciones en Java. Aprenderemos a crear y usar enumeraciones y clases de enumeración con la ayuda de ejemplos.

En Java, una enumeración es un tipo que tiene un conjunto de valores posibles fijos. Utilizamos la palabra clave enum para declarar una enumeración. Por ejemplo,

enum Size {　
　　　PEQUEÑO, MEDIANO, GRANDE, EXTRA GRANDE　
}

Aquí, creamos una enumeración llamada Size.

Los valores dentro de los corchetes llave se denominan valores de enumeración (constantes). Estos son los valores únicos que puede conservar el tipo de enumeración.

Atención:Los constantes de enumeración se representan generalmente en mayúsculas.

Vamos a tomar un ejemplo simple.

enum Size {
　　　PEQUEÑO, MEDIANO, GRANDE, EXTRA GRANDE
}
class Main {
　　　public static void main(String[] args) {
　　　　　　System.out.println(Size.SMALL);
　　　　　　System.out.println(Size.MEDIUM);
　　　}
}

Resultado de salida

SMALL
MEDIUM

A partir del ejemplo anterior, podemos ver que accedemos a los valores constantes utilizando el nombre de la enumeración.

Del mismo modo, podemos crear variables de tipo enum. Por ejemplo,

Tamaño pizzaSize;

Aquí, pizzaSize es una variable de tipo Tamaño. Solo puede asignar4valores.

pizzaSize = Tamaño.PEQUEÑO;
pizzaSize = Tamaño.MEDIO;
pizzaSize = Tamaño.GRANDE;
pizzaSize = Tamaño.EXTRA GRANDE;

Ejemplo1Clase enum de Java

enum Size {
　PEQUEÑO, MEDIANO, GRANDE, EXTRA GRANDE
}
class Test {
　Tamaño pizzaSize;
　public Test(Tamaño pizzaSize) {
　　　this.pizzaSize = pizzaSize;
　}
　public void orderPizza() {
　　　switch(pizzaSize) {
　　　　　case PEQUEÑO:
　　　　　　　System.out.println("Pedí una pizza pequeña.");
　　　　　　　break;
　　　　　case MEDIUM:
　　　　　　　System.out.println("Pedí una pizza de tamaño mediano.");
　　　　　　　break;
　　　　　default:
　　　　　　　System.out.println("No sé qué pedir.");
　　　　　　　break;
　　　}
　}
}
class Main {
　public static void main(String[] args) {
　　　Test t1　= new Test(Tamaño.MEDIO);
　　　t1.orderPizza();
　}
}

Resultado de salida

Pedí una pizza de tamaño mediano.

En el programa anterior, creamos un tipo enum Tamaño. Luego, declaramos una variable de tipo Tamaño llamada pizzaSize.

La variable pizzaSize solo puede asignar4valores (PEQUEÑO, MEDIO, GRANDE, EXTRA GRANDE).

La variable pizzaSize asignó el constante MEDIO. Basado en esto, se imprimirá una situación de la declaración switch case.

Clase enum de Java

En Java, el tipo enum se considera un tipo especial de clase. Es en Java 5Introducido en la versión.

Una clase enum puede contener métodos y campos como una clase normal.

enum Size {
　　　　constante1, constante;2, ..., constanteN;
　　　　//Métodos y campos
}

Las constantes enum siempre son public static final por defecto.

Cuando se crea una clase enum, el compilador también crea una instancia (objeto) para cada constante enum.

Ejemplo2Clase enum

enum Tamaño{
　　　PEQUEÑO, MEDIO, GRANDE, EXTRA GRANDE;
　　　public String getSize() {
　　　　　　//Esto referenciará al objeto PEQUEÑO
　　　　　　switch(this) {
　　　　　　　　　case PEQUEÑO:
　　　　　　　　　　return \
　　　　　　　　　case MEDIUM:
　　　　　　　　　　return \
　　　　　　　　　case LARGE:
　　　　　　　　　　return \
　　　　　　　　　case EXTRALARGE:
　　　　　　　　　　return \
　　　　　　　　　default:
　　　　　　　　　　return null;
　　　　　　}
　　　}
　　　public static void main(String[] args) {
　　　　　　//
　　　　　　System.out.println(\　+　Size.SMALL.getSize());
　　　}
}

Resultado de salida

El tamaño de la pizza es small

En el ejemplo anterior, creamos una clase de enumeración Size. Tiene cuatro constantes SMALL, MEDIUM, LARGE y EXTRALARGE.

Dado que Size es una clase de enumeración, el compilador crea automáticamente una instancia para cada constante de enumeración.

Dentro del método main(), hemos utilizado el ejemplo SMALL para llamar al método getSize().

Como las clases normales, las clases de enumeración también pueden contener un constructor. Para obtener más información, visiteJava 枚举构造函数.

Métodos de la clase de enumeración

En la clase de enumeración hay algunos métodos predefinidos que se pueden usar en cualquier momento.

El método ordinal()

El método ordinal() devuelve la posición del constante de enumeración. Por ejemplo:

ordinal(SMALL)　
//devuelve 0

El método compareTo()

El método compareTo() compara los constantes de enumeración según el valor ordinal. Por ejemplo:

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

El método toString()

El método toString() devuelve la representación en cadena del constante de enumeración. Por ejemplo:

SMALL.toString()
//devuelve \

El método name()

El método name() devuelve el nombre definido en cadena del constante de enumeración en forma de cadena. El valor devuelto por el método name() es final. Por ejemplo:

name(SMALL)
//devuelve \

El método valueOf()

El método valueOf() toma una cadena y devuelve el constante de enumeración con el nombre de cadena equivalente. Por ejemplo:

Size.valueOf("SMALL")
//devuelve el constante SMALL

El método values()

El método values() devuelve un array de tipo enumeración que contiene todos los valores constantes. Por ejemplo:

Size[] enumArray = Size.value();

¿Por qué usar la enumeración de Java?

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

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

class Size {
　　　public final static int PEQUEÑO =　1;
　　　public final static int MEDIANO =　2;
　　　public final static int GRANDE =　3;
　　　public final static int EXTRA GRANDE =　4;
}

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

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

enum Size {
　　　PEQUEÑO, MEDIANO, GRANDE, EXTRA GRANDE
}

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

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

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