enumeración en Java

Las enumeraciones sirven para representar un grupo de constantes con nombre en un lenguaje de programación. Por ejemplo, los 4 palos en una baraja de naipes pueden ser 4 enumeradores llamados Trébol, Diamante, Corazón y Pica, pertenecientes a un tipo enumerado llamado Palo. Otros ejemplos incluyen tipos enumerados naturales (como los planetas, días de la semana, colores, direcciones, etc.). 

Las enumeraciones se usan cuando conocemos todos los valores posibles en tiempo de compilación, como opciones en un menú, modos de redondeo, banderas de línea de comandos, etc. No es necesario que el conjunto de constantes en un tipo de enumeración permanezca fijo todo el tiempo.

En Java (desde 1.5), las enumeraciones se representan utilizando el tipo de datos de enumeración . Las enumeraciones de Java son más potentes que las enumeraciones de C/C++ . En Java, también podemos agregarle variables, métodos y constructores. El objetivo principal de enum es definir nuestros propios tipos de datos (Tipos de datos enumerados).

Declaración de enumeración en Java: la declaración de enumeración se puede realizar fuera de una clase o dentro de una clase, pero no dentro de un método.

// A simple enum example where enum is declared
// outside any class (Note enum keyword instead of
// class keyword)
 
enum Color {
    RED,
    GREEN,
    BLUE;
}
 
public class Test {
    // Driver method
    public static void main(String[] args)
    {
        Color c1 = Color.RED;
        System.out.println(c1);
    }
}

RED

// enum declaration inside a class.
 
public class Test {
    enum Color {
        RED,
        GREEN,
        BLUE;
    }
 
    // Driver method
    public static void main(String[] args)
    {
        Color c1 = Color.RED;
        System.out.println(c1);
    }
}

RED

• La primera línea dentro de la enumeración debe ser una lista de constantes y luego otras cosas como métodos, variables y constructores.
• De acuerdo con las convenciones de nomenclatura de Java , se recomienda que nombre constante con todas las letras mayúsculas

Puntos importantes de la enumeración:  

• Cada enumeración se implementa internamente mediante el uso de Class.

/* internally above enum Color is converted to
class Color
{
     public static final Color RED = new Color();
     public static final Color BLUE = new Color();
     public static final Color GREEN = new Color();
}*/

• Cada constante de enumeración representa un objeto de tipo enumeración.
• El tipo de enumeración se puede pasar como un argumento para cambiar las declaraciones.

// A Java program to demonstrate working on enum
// in switch case (Filename Test. Java)
 
import java.util.Scanner;
 
// An Enum class
enum Day {
    SUNDAY,
    MONDAY,
    TUESDAY,
    WEDNESDAY,
    THURSDAY,
    FRIDAY,
    SATURDAY;
}
 
// Driver class that contains an object of "day" and
// main().
public class Test {
    Day day;
 
    // Constructor
    public Test(Day day) { this.day = day; }
 
    // Prints a line about Day using switch
    public void dayIsLike()
    {
        switch (day) {
        case MONDAY:
            System.out.println("Mondays are bad.");
            break;
        case FRIDAY:
            System.out.println("Fridays are better.");
            break;
        case SATURDAY:
        case SUNDAY:
            System.out.println("Weekends are best.");
            break;
        default:
            System.out.println("Midweek days are so-so.");
            break;
        }
    }
 
    // Driver method
    public static void main(String[] args)
    {
        String str = "MONDAY";
        Test t1 = new Test(Day.valueOf(str));
        t1.dayIsLike();
    }
}

Mondays are bad.

• Cada constante de enumeración siempre es implícitamente public static final . Como es estático , podemos acceder a él usando el nombre de enumeración. Dado que es final , no podemos crear enumeraciones secundarias.
• Podemos declarar el método main() dentro de la enumeración. Por lo tanto, podemos invocar enum directamente desde el símbolo del sistema.

// A Java program to demonstrate that we can have
// main() inside enum class.
 
enum Color {
    RED,
    GREEN,
    BLUE;
 
    // Driver method
    public static void main(String[] args)
    {
        Color c1 = Color.RED;
        System.out.println(c1);
    }
}

RED

Enumeración y herencia:  

• Todas las enumeraciones extienden implícitamente la clase java.lang.Enum . Como una clase solo puede extender un padre en Java, una enumeración no puede extender nada más.
• El método toString() se anula en la clase java.lang.Enum , que devuelve el nombre de la constante de enumeración.
• enum puede implementar muchas interfaces.

métodos de valores(), ordinales() y valueOf():  

• Estos métodos están presentes dentro de java.lang.Enum .
• El método de valores() se puede usar para devolver todos los valores presentes dentro de la enumeración.
• El orden es importante en las enumeraciones. Al usar el método ordinal() , se puede encontrar cada índice constante de enumeración, al igual que un índice de array.
• El método valueOf() devuelve la constante de enumeración del valor de string especificado, si existe.

// Java program to demonstrate working of values(),
// ordinal() and valueOf()
 
enum Color {
    RED,
    GREEN,
    BLUE;
}
 
public class Test {
    public static void main(String[] args)
    {
        // Calling values()
        Color arr[] = Color.values();
 
        // enum with loop
        for (Color col : arr) {
            // Calling ordinal() to find index
            // of color.
            System.out.println(col + " at index "
                               + col.ordinal());
        }
 
        // Using valueOf(). Returns an object of
        // Color with given constant.
        // Uncommenting second line causes exception
        // IllegalArgumentException
        System.out.println(Color.valueOf("RED"));
        // System.out.println(Color.valueOf("WHITE"));
    }
}

RED at index 0
GREEN at index 1
BLUE at index 2
RED

enumeración y constructor:  

• enum puede contener un constructor y se ejecuta por separado para cada constante de enumeración en el momento de la carga de la clase de enumeración.
• No podemos crear objetos de enumeración explícitamente y, por lo tanto, no podemos invocar el constructor de enumeración directamente.

enumeración y métodos:  

• enum puede contener métodos concretos y métodos abstractos . Si una clase de enumeración tiene un método abstracto, entonces cada instancia de la clase de enumeración debe implementarlo

// Java program to demonstrate that enums can have
// constructor and concrete methods.
 
// An enum (Note enum keyword inplace of class keyword)
enum Color {
    RED,
    GREEN,
    BLUE;
 
    // enum constructor called separately for each
    // constant
    private Color()
    {
        System.out.println("Constructor called for : "
                           + this.toString());
    }
 
    public void colorInfo()
    {
        System.out.println("Universal Color");
    }
}
 
public class Test {
    // Driver method
    public static void main(String[] args)
    {
        Color c1 = Color.RED;
        System.out.println(c1);
        c1.colorInfo();
    }
}

Constructor called for : RED
Constructor called for : GREEN
Constructor called for : BLUE
RED
Universal Color

Artículo siguiente sobre enumeración: enumeración  con valor personalizado en Java

Este artículo es una contribución de Gaurav Miglani . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks. Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.