viñetas uso rae puntuación puntuacion punto mayúsculas mayusculas mayuscula listados las fundeu enumeración enumeraciones con java enums

java - uso - ¿Qué son las enumeraciones y por qué son útiles?



puntuación viñetas rae (23)

Ahora, ¿por qué y para qué debo usar enum en la programación del día a día?

Puede usar un Enum para representar un conjunto fijo de constantes más bien pequeño o un modo de clase interno al tiempo que aumenta la legibilidad. Además, las enumeraciones pueden imponer una cierta rigidez cuando se usan en parámetros de métodos. Ofrecen la posibilidad interesante de pasar información a un constructor como en el ejemplo Planetas en el sitio de Oracle y, como ya descubrió, también permiten una forma sencilla de crear un patrón de singleton.

ej: Locale.setDefault(Locale.US) lee mejor que Locale.setDefault(1) y hace cumplir el uso del conjunto fijo de valores que se muestra en un IDE cuando agrega el . separador en lugar de todos los enteros.

Hoy exploré algunas preguntas en este sitio y encontré una mención de una enum utilizada en un patrón único sobre los supuestos beneficios de seguridad de subprocesos para dicha solución.

Nunca he usado enum s y he estado programando en Java durante más de un par de años. Y al parecer han cambiado mucho. Ahora incluso hacen un apoyo completo de la POO dentro de ellos mismos.

Ahora, ¿por qué y para qué debo usar enum en la programación del día a día?

¿Qué es una enumeración?

  • enum es una palabra clave definida para enumerar un nuevo tipo de datos. Las enumeraciones seguras de tipos se deben utilizar generosamente. En particular, son una alternativa sólida a las constantes String o int simples utilizadas en API mucho más antiguas para representar conjuntos de elementos relacionados.

¿Por qué usar enum

  • Las enumeraciones son subclases implícitamente finales de java.lang.Enum
  • Si una enumeración es un miembro de una clase, es implícitamente estática.
  • nunca se puede usar nuevo con una enumeración, incluso dentro del mismo tipo de enumeración
  • nombre y valor. Simplemente use el texto de las constantes de enumeración, mientras que toString puede ser anulado para proporcionar cualquier contenido, si lo desea
  • para las constantes de enumeración, igual y == equivalen a la misma cosa, y se pueden usar indistintamente
  • las constantes de enumeración son implícitamente públicas final estáticas

Nota

  • Enums no puede extender ninguna clase.
  • Una enumeración no puede ser una superclase.
  • el orden de aparición de las constantes de enumeración se denomina "orden natural" y define el orden utilizado por otros elementos también: compareTo, orden de iteración de los valores, EnumSet, EnumSet.range.
  • Una enumeración puede tener constructores, bloques estáticos y de instancia, variables y métodos, pero no puede tener métodos abstractos.

¿Por qué usar cualquier función de lenguaje de programación? La razón por la que tenemos idiomas es para

  1. Los programadores pueden expresar algoritmos de forma correcta y eficiente en una forma que las computadoras puedan usar.
  2. Los encargados de mantenimiento entienden los algoritmos que otros han escrito y hacen cambios correctamente .

Las enumeraciones mejoran tanto la probabilidad de corrección como la legibilidad sin tener que escribir una gran cantidad de referencias. Si está dispuesto a escribir boilerplate, puede "simular" enumeraciones:

public class Color { private Color() {} // Prevent others from making colors. public static final Color RED = new Color(); public static final Color AMBER = new Color(); public static final Color GREEN = new Color(); }

Ahora puedes escribir:

Color trafficLightColor = Color.RED;

La placa de arriba de arriba tiene el mismo efecto que

public enum Color { RED, AMBER, GREEN };

Ambos proporcionan el mismo nivel de verificación de ayuda del compilador. Boilerplate es más que escribir. Pero el hecho de ahorrar mucho al escribir hace que el programador sea más eficiente (ver 1), por lo que es una característica que vale la pena.

También vale la pena por al menos una razón más:

Cambiar declaraciones

Una cosa que la simulación de enumeración static final anterior no le da a usted es un buen switch casos. Para los tipos de enumeración, el conmutador de Java utiliza el tipo de su variable para inferir el alcance de los casos de enumeración, por lo que para el enum Color anterior simplemente necesita decir:

Color color = ... ; switch (color) { case RED: ... break; }

Tenga en cuenta que no es Color.RED en los casos. Si no usa enumeración, la única manera de usar cantidades nombradas con el switch es algo como:

public Class Color { public static final int RED = 0; public static final int AMBER = 1; public static final int GREEN = 2; }

Pero ahora una variable para mantener un color debe tener el tipo int . La buena comprobación del compilador de la enumeración y la simulación static final se han ido. No feliz.

Un compromiso es usar un miembro de valor escalar en la simulación:

public class Color { public static final int RED_TAG = 1; public static final int AMBER_TAG = 2; public static final int GREEN_TAG = 3; public final int tag; private Color(int tag) { this.tag = tag; } public static final Color RED = new Color(RED_TAG); public static final Color AMBER = new Color(AMBER_TAG); public static final Color GREEN = new Color(GREEN_TAG); }

Ahora:

Color color = ... ; switch (color.tag) { case Color.RED_TAG: ... break; }

Pero tenga en cuenta, incluso más repetitivo!

Usando una enumeración como un singleton

En la placa de arriba, puedes ver por qué una enumeración proporciona una forma de implementar un singleton. En lugar de escribir:

public class SingletonClass { public static final void INSTANCE = new SingletonClass(); private SingletonClass() {} // all the methods and instance data for the class here }

y luego accediendo a ella con

SingletonClass.INSTANCE

solo podemos decir

public enum SingletonClass { INSTANCE; // all the methods and instance data for the class here }

Lo que nos da lo mismo. Podemos salir adelante con esto porque las enums de Java se implementan como clases completas con solo un poco de azúcar sintáctica esparcido por encima. De nuevo, esto es menos repetitivo, pero no es obvio a menos que el idioma te resulte familiar. También me disgusta el hecho de que obtengas las diversas funciones de enumeración, aunque no tienen mucho sentido para el singleton: ord y values , etc. (De hecho, hay una simulación más complicada donde Color extends Integer que funcionará con el interruptor, pero es tan Es difícil que muestre aún más claramente por qué la enum es una mejor idea.)

Seguridad del hilo

La seguridad de los hilos es un problema potencial solo cuando los singletons se crean perezosamente sin bloqueo.

public class SingletonClass { private static SingletonClass INSTANCE; private SingletonClass() {} public SingletonClass getInstance() { if (INSTANCE == null) INSTANCE = new SingletonClass(); return INSTANCE; } // all the methods and instance data for the class here }

Si muchos subprocesos llaman a getInstance simultáneamente mientras INSTANCE sigue siendo nulo, se pueden crear cualquier número de instancias. Esto es malo. La única solución es agregar acceso synchronized para proteger la variable INSTANCE .

Sin embargo, el código static final anterior no tiene este problema. Crea la instancia con entusiasmo en el tiempo de carga de clase. La carga de clases está sincronizada.

El enum singleton es efectivamente perezoso porque no se inicializa hasta el primer uso. La inicialización de Java también está sincronizada, por lo que varios subprocesos no pueden inicializar más de una instancia de INSTANCE . Usted está obteniendo un singleton de inicio perezoso con muy poco código. El único negativo es la sintaxis bastante oscura. Necesita saber el idioma o comprender a fondo cómo funcionan la carga y la inicialización de clases para saber qué está sucediendo.

Además de los casos de uso ya mencionados, a menudo encuentro enumerados útiles para implementar el patrón de estrategia, siguiendo algunas pautas básicas de OOP:

  1. Tener el código donde se encuentran los datos (es decir, dentro de la propia enumeración, o a menudo dentro de las constantes de enumeración, que pueden anular los métodos).
  2. Implementar una interfaz (o más) para no vincular el código del cliente a la enumeración (que solo debería proporcionar un conjunto de implementaciones predeterminadas).

El ejemplo más simple sería un conjunto de implementaciones de Comparator :

enum StringComparator implements Comparator<String> { NATURAL { @Override public int compare(String s1, String s2) { return s1.compareTo(s2); } }, REVERSE { @Override public int compare(String s1, String s2) { return NATURAL.compare(s2, s1); } }, LENGTH { @Override public int compare(String s1, String s2) { return new Integer(s1.length()).compareTo(s2.length()); } }; }

Este "patrón" se puede usar en escenarios mucho más complejos, haciendo un uso extensivo de todos los beneficios que vienen con la enumeración: iterando sobre las instancias, confiando en su orden implícito, recuperando una instancia por su nombre, métodos estáticos que proporcionan la instancia correcta para contextos específicos, etc. Y todavía tiene todo esto oculto detrás de la interfaz para que su código funcione con implementaciones personalizadas sin modificaciones en caso de que desee algo que no esté disponible entre las "opciones predeterminadas".

He visto esto aplicado con éxito para modelar el concepto de granularidad de tiempo (diaria, semanal, etc.) donde toda la lógica se encapsuló en una enumeración (elegir la granularidad correcta para un rango de tiempo dado, el comportamiento específico vinculado a cada granularidad como constante métodos etc.). Y aún así, la Granularity vista por la capa de servicio era simplemente una interfaz.

Algo que ninguna de las otras respuestas ha cubierto y que hace que las enumeraciones sean particularmente poderosas es la capacidad de tener métodos de plantilla . Los métodos pueden ser parte de la enumeración base y reemplazados por cada tipo. Y, con el comportamiento adjunto a la enumeración, a menudo elimina la necesidad de construcciones if-else o declaraciones de cambio como lo demuestra esta publicación del blog , donde enum.method() hace lo que originalmente se ejecutaría dentro del condicional. El mismo ejemplo también muestra el uso de importaciones estáticas con enumeraciones y produce un código de tipo DSL mucho más limpio.

Algunas otras cualidades interesantes incluyen el hecho de que los enumerados proporcionan implementación para equals() , toString() y hashCode() e implementan Serializable y Comparable .

Para un resumen completo de todo lo que los enums tienen para ofrecer, recomiendo el 4º edición Thinking in Java de Bruce Eckel, que dedica un capítulo completo al tema. Particularmente iluminadores son los ejemplos que incluyen un juego de Rock, Paper, Scissors (es decir, RoShamBo) como enumeraciones.

Aparte de todo lo dicho por otros ... En un proyecto anterior en el que solía trabajar, una gran cantidad de comunicación entre entidades (aplicaciones independientes) utilizaba números enteros que representaban un conjunto pequeño. Fue útil declarar el conjunto como enum con métodos estáticos para obtener objeto enum desde value y viceversa. El código se veía más limpio, cambia la facilidad de uso de la caja y es más fácil escribir en los registros.

enum ProtocolType { TCP_IP (1, "Transmission Control Protocol"), IP (2, "Internet Protocol"), UDP (3, "User Datagram Protocol"); public int code; public String name; private ProtocolType(int code, String name) { this.code = code; this.name = name; } public static ProtocolType fromInt(int code) { switch(code) { case 1: return TCP_IP; case 2: return IP; case 3: return UDP; } // we had some exception handling for this // as the contract for these was between 2 independent applications // liable to change between versions (mostly adding new stuff) // but keeping it simple here. return null; } }

Cree un objeto de enum partir de los valores recibidos (por ejemplo, 1,2) usando ProtocolType.fromInt(2) Escriba en los registros usando myEnumObj.name

Espero que esto ayude.

De los documents Java -

Debe usar tipos de enumeración cada vez que necesite representar un conjunto fijo de constantes. Esto incluye tipos de enumeración naturales, como los planetas de nuestro sistema solar y los conjuntos de datos en los que conoce todos los valores posibles en el momento de la compilación, por ejemplo, las opciones en un menú, las marcas de línea de comando, etc.

Un ejemplo común es reemplazar una clase con un conjunto de constantes int internas finales estáticas privadas (dentro de un número razonable de constantes) con un tipo de enumeración. Básicamente, si cree que conoce todos los valores posibles de "algo" en el momento de la compilación, puede representarlo como un tipo de enumeración. Las enumeraciones proporcionan legibilidad y flexibilidad sobre una clase con constantes.

Pocas otras ventajas que puedo pensar en los tipos de enumeración. Siempre son una instancia de una clase de enumeración particular (de ahí el concepto de usar enumeraciones cuando llega Singleton). Otra ventaja es que puede usar enumeraciones como un tipo en la sentencia switch-case. También puede usar toString() en la enumeración para imprimirlas como cadenas legibles.

ENum significa "tipo enumerado". Es un tipo de datos que tiene un conjunto fijo de constantes que usted mismo define.

En lo que respecta a hacer que el código sea legible en el futuro, el caso de enumeración aplicable más útil se representa en el siguiente fragmento de código:

public enum Items { MESSAGES, CHATS, CITY_ONLINE, FRIENDS, PROFILE, SETTINGS, PEOPLE_SEARCH, CREATE_CHAT } @Override public boolean onCreateOptionsMenu(Menu menuPrm) { // Inflate the menu; this adds items to the action bar if it is present. getMenuInflater().inflate(R.menu.main, menuPrm); View itemChooserLcl; for (int i = 0; i < menuPrm.size(); i++) { MenuItem itemLcl = menuPrm.getItem(i); itemChooserLcl = itemLcl.getActionView(); if (itemChooserLcl != null) { //here Im marking each View'' tag by enume values: itemChooserLcl.setTag(Items.values()[i]); itemChooserLcl.setOnClickListener(drawerMenuListener); } } return true; } private View.OnClickListener drawerMenuListener=new View.OnClickListener() { @Override public void onClick(View v) { Items tagLcl= (Items) v.getTag(); switch (tagLcl){ case MESSAGES: ; break; case CHATS : ; break; case CITY_ONLINE : ; break; case FRIENDS : ; break; case PROFILE: ; break; case SETTINGS: ; break; case PEOPLE_SEARCH: ; break; case CREATE_CHAT: ; break; } } };

En mi opinión, todas las respuestas que obtuviste hasta ahora son válidas, pero en mi experiencia, lo expresaría en pocas palabras:

Use enumeraciones si desea que el compilador verifique la validez del valor de un identificador.

De lo contrario, puedes usar cadenas como siempre lo hiciste (probablemente hayas definido algunas "convenciones" para tu aplicación) y serás muy flexible ... pero no obtendrás el 100% de seguridad contra los errores tipográficos en tus cadenas y solo te darás cuenta de ellas. en tiempo de ejecución.

Enum hereda todos los métodos de la clase Object y la clase abstracta Enum . Por lo tanto, puede usar sus métodos de reflexión, multihilo, serilización, comparables, etc. Si simplemente declara una constante estática en lugar de Enum, no puede. Además de eso, el valor de Enum también se puede pasar a la capa DAO.

Aquí hay un programa de ejemplo para demostrar.

public enum State { Start("1"), Wait("1"), Notify("2"), NotifyAll("3"), Run("4"), SystemInatilize("5"), VendorInatilize("6"), test, FrameworkInatilize("7"); public static State getState(String value) { return State.Wait; } private String value; State test; private State(String value) { this.value = value; } private State() { } public String getValue() { return value; } public void setCurrentState(State currentState) { test = currentState; } public boolean isNotify() { return this.equals(Notify); } } public class EnumTest { State test; public void setCurrentState(State currentState) { test = currentState; } public State getCurrentState() { return test; } public static void main(String[] args) { System.out.println(State.test); System.out.println(State.FrameworkInatilize); EnumTest test=new EnumTest(); test.setCurrentState(State.Notify); test. stateSwitch(); } public void stateSwitch() { switch (getCurrentState()) { case Notify: System.out.println("Notify"); System.out.println(test.isNotify()); break; default: break; } } }

Enumerar ¿Por qué debería ser utilizado? Creo que es más comprensible cuándo lo usarás. Tengo la misma experiencia.

Digamos que tiene una operación de base de datos crear, eliminar, editar y leer.

Ahora si creas una enumeración como una operación:

public enum operation { create("1") delete("2") edit("3") read("4") // You may have is methods here public boolean isCreate() { return this.equals(create); } // More methods like the above can be written }

Ahora puedes declarar algo como:

private operation currentOperation; // And assign the value for it currentOperation = operation.create

Así que puedes usarlo de muchas maneras. Siempre es bueno tener enumeración para cosas específicas, ya que la operación de la base de datos en el ejemplo anterior se puede controlar al verificar la operación actual . Quizás se pueda decir que esto también se puede lograr con variables y valores enteros. Pero creo que Enum es una forma más segura y programadora.

Otra cosa: creo que a todos los programadores les encanta el booleano , ¿no? Porque puede almacenar solo dos valores, dos valores específicos. Por lo tanto, se puede considerar que Enum tiene el mismo tipo de instalaciones donde el usuario definirá cuántos y qué tipo de valor almacenará, solo de una manera ligeramente diferente. :)

Es útil saber que las enums son como las otras clases con campos Constant y un private constructor .

Por ejemplo,

public enum Weekday { MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY }

El compilador lo compila como sigue;

class Weekday extends Enum { public static final Weekday MONDAY = new Weekday( "MONDAY", 0 ); public static final Weekday TUESDAY = new Weekday( "TUESDAY ", 1 ); public static final Weekday WEDNESDAY= new Weekday( "WEDNESDAY", 2 ); public static final Weekday THURSDAY= new Weekday( "THURSDAY", 3 ); public static final Weekday FRIDAY= new Weekday( "FRIDAY", 4 ); public static final Weekday SATURDAY= new Weekday( "SATURDAY", 5 ); public static final Weekday SUNDAY= new Weekday( "SUNDAY", 6 ); private Weekday( String s, int i ) { super( s, i ); } // other methods... }

Hasta ahora, nunca he necesitado usar enumeraciones. He estado leyendo sobre ellos desde que se introdujeron en 1.5 o versión tiger como se llamaba en su día. Realmente nunca resolvieron un ''problema'' para mí. Para aquellos que lo usan (y veo que muchos lo hacen), estoy seguro de que definitivamente tiene algún propósito. Sólo mis 2 libras.

Java le permite restringir la variable para que tenga uno solo de unos pocos valores predefinidos; en otras palabras, un valor de una lista enumerada. Usar enums puede ayudar a reducir los errores en su código. Aquí hay un ejemplo de enums fuera de una clase:

enums coffeesize{BIG , HUGE , OVERWHELMING }; //This semicolon is optional.

Esto restringe el coffeesize del coffeesize a tener: BIG , HUGE o OVERWHELMING como variable.

Lo que me dio el momento Ah-Ha fue esta conclusión: que Enum tiene un constructor privado al que solo se puede acceder a través de la enumeración pública:

enum RGB { RED("Red"), GREEN("Green"), BLUE("Blue"); public static final String PREFIX = "color "; public String getRGBString() { return PREFIX + color; } String color; RGB(String color) { this.color = color; } } public class HelloWorld { public static void main(String[] args) { String c = RGB.RED.getRGBString(); System.out.print("Hello " + c); } }

Según mi experiencia, el uso de Enum a veces hace que los sistemas sean muy difíciles de cambiar. Si está utilizando un Enum para un conjunto de valores específicos del dominio que cambian con frecuencia, y tiene muchas otras clases y componentes que dependen de él, es posible que desee considerar no usar un Enum.

Por ejemplo, un sistema de comercio que utiliza un Enum para mercados / intercambios. Hay muchos mercados y es casi seguro que habrá muchos subsistemas que necesitan acceder a esta lista de mercados. Cada vez que desee agregar un nuevo mercado a su sistema, o si desea eliminar un mercado, es posible que todo lo que esté bajo el sol tenga que ser reconstruido y lanzado.

Un mejor ejemplo sería algo así como un tipo de categoría de producto. Digamos que su software gestiona el inventario de una tienda por departamentos. Hay muchas categorías de productos y muchas razones por las que esta lista de categorías podría cambiar. Es posible que los gerentes deseen almacenar una nueva línea de productos, deshacerse de otras líneas de productos y posiblemente reorganizar las categorías de vez en cuando. Si tiene que reconstruir y volver a implementar todos sus sistemas simplemente porque los usuarios quieren agregar una categoría de producto, entonces tomó algo que debería ser simple y rápido (agregar una categoría) y lo hizo muy difícil y lento.

En pocas palabras, las enumeraciones son buenas si los datos que está representando son muy estáticos a lo largo del tiempo y tienen un número limitado de dependencias. Pero si los datos cambian mucho y tienen muchas dependencias, entonces necesita algo dinámico que no se verifique en el momento de la compilación (como una tabla de base de datos).

Siempre debe usar enumeraciones cuando una variable (especialmente un parámetro de método) solo puede tomar una de un pequeño conjunto de valores posibles. Ejemplos serían cosas como constantes de tipo (estado del contrato: "permanente", "temp", "aprendiz"), o banderas ("ejecutar ahora", "aplazar ejecución").

Si usa enumeraciones en lugar de números enteros (o códigos de cadena), aumenta la verificación en tiempo de compilación y evita que los errores pasen en constantes no válidas, y documenta qué valores son legales usar.

Por cierto, el uso excesivo de enums puede significar que sus métodos hacen demasiado (a menudo es mejor tener varios métodos separados, en lugar de un método que toma varios indicadores que modifican lo que hace), pero si tiene que usar indicadores o códigos de tipo, enums son el camino a seguir

Como ejemplo, ¿cuál es mejor?

/** Counts number of foobangs. * @param type Type of foobangs to count. Can be 1=green foobangs, * 2=wrinkled foobangs, 3=sweet foobangs, 0=all types. * @return number of foobangs of type */ public int countFoobangs(int type)

versus

/** Types of foobangs. */ public enum FB_TYPE { GREEN, WRINKLED, SWEET, /** special type for all types combined */ ALL; } /** Counts number of foobangs. * @param type Type of foobangs to count * @return number of foobangs of type */ public int countFoobangs(FB_TYPE type)

Un método llamado como:

int sweetFoobangCount = countFoobangs(3);

entonces se convierte en:

int sweetFoobangCount = countFoobangs(FB_TYPE.SWEET);

En el segundo ejemplo, se aclara de inmediato qué tipos están permitidos, los documentos y la implementación no se pueden desincronizar, y el compilador puede imponer esto. Además, una llamada no válida como

int sweetFoobangCount = countFoobangs(99);

ya no es posible

Usaría enums como un instrumento de mapeo útil, evitando múltiples if-else siempre que se implementen algunos métodos.

public enum Mapping { ONE("1"), TWO("2"); private String label; private Mapping(String label){ this.label = label; } public static Mapping by(String label) { for(Mapping m: values() { if(m.label.equals(label)) return m; } return null; } }

Por lo tanto, el método le by(String label)permite obtener el valor enumerado por no enumerados. Además, uno puede inventar la cartografía entre 2 enumeraciones. También podría probar ''1 a muchos'' o ''muchos a muchos'' además de la relación predeterminada ''uno a uno''

Al final, enumes una clase de Java. Por lo tanto, puede tener un mainmétodo en su interior, que podría ser útil cuando necesite realizar algunas operaciones de mapeo de argsinmediato.

Use las enumeraciones para SEGURIDAD DE TIPO, esta es una función de lenguaje por lo que generalmente obtendrá:

  • Compilador de soporte (ver inmediatamente problemas de tipo)
  • Soporte de herramientas en IDE (autocompletado en caso de cambio ...)

Las enumeraciones pueden tener métodos, constructores, incluso puedes usar enumeraciones dentro de las enumeraciones y combinar enumeraciones con interfaces.

Piense en las enumeraciones como tipos para reemplazar un conjunto bien definido de constantes int (que Java "heredó" de C / C ++).

El libro Effective Java 2nd Edition tiene un capítulo completo sobre ellos y contiene más detalles. También vea este post de desbordamiento de pila .

Enum s enumerar un conjunto fijo de valores, de forma autodocumentada.
Hacen que su código sea más explícito y también menos propenso a errores.

¿Por qué no usar String , o int , en lugar de Enum , para constantes?

  1. El compilador no permitirá errores tipográficos , ni valores fuera del conjunto fijo, ya que los enumerados son tipos por sí mismos. Consecuencias:
    • No tendrá que escribir una condición previa (o un manual if ) para asegurarse de que su argumento se encuentre dentro del rango válido.
    • El tipo invariante viene gratis.
  2. Las enumeraciones pueden tener comportamiento, al igual que cualquier otra clase.
  3. Probablemente necesitaría una cantidad similar de memoria para usar String s, de todos modos (esto depende de la complejidad del Enum ).

Además, cada una de las instancias de Enum es una clase para la cual puede definir su comportamiento individual.

Además, garantizan la seguridad de subprocesos en la creación de las instancias (cuando se carga la enumeración), que ha visto una gran aplicación para simplificar el patrón Singleton .

Este blog ilustra algunas de sus aplicaciones, como una máquina de estado para un analizador.

enum significa significa enumeración, es decir, mencionar (una serie de cosas) una por una.

Una enumeración es un tipo de datos que contiene un conjunto fijo de constantes.

O

Una enum es como una class , con un conjunto fijo de instancias conocidas en tiempo de compilación.

Por ejemplo:

public class EnumExample { interface SeasonInt { String seasonDuration(); } private enum Season implements SeasonInt { // except the enum constants remaining code looks same as class // enum constants are implicitly public static final we have used all caps to specify them like Constants in Java WINTER(88, "DEC - FEB"), SPRING(92, "MAR - JUN"), SUMMER(91, "JUN - AUG"), FALL(90, "SEP - NOV"); private int days; private String months; Season(int days, String months) { // note: constructor is by default private this.days = days; this.months = months; } @Override public String seasonDuration() { return this+" -> "+this.days + "days, " + this.months+" months"; } } public static void main(String[] args) { System.out.println(Season.SPRING.seasonDuration()); for (Season season : Season.values()){ System.out.println(season.seasonDuration()); } } }

Ventajas de enumeración:

  • la enumeración mejora la seguridad de tipos en el tiempo de compilación para evitar errores en tiempo de ejecución.
  • enum se puede utilizar fácilmente en el interruptor
  • enum puede ser atravesado
  • Enum puede tener campos, constructores y métodos.
  • enum puede implementar muchas interfaces pero no puede extender ninguna clase porque extiende internamente la clase Enum

para more