Hola,
Si alguna vez te has realizado la siguiente pregunta: Por qué usar Enum sobre Constantes en Java? o se les han realizado esa pregunta en el trabajo o en una entrevista, las ventajas son las siguientes:
¿Por qué enums?
- Constantes fácilmente relacionadas, más legibles y que expresan una clara intencionalidad.
- Ahorro en tiempo de ejecución y compilación, ya que typescript asigna sus valores como constantes declaradas por cada asignación.
- Fácilmente refactorizable.
Cuando no utilizar enums:
- Cuando cualquiera de sus propiedades pueda ser reasignada en tiempo de ejecución.
- Cuando se pretenda ampliar la cantidad de propiedades de forma indefinida. La naturaleza de un enum debe estar definida y constatada por la utilidad que se le vaya a dar.
Si se quiere profundizar más, tengan en cuenta lo siguiente:
Primero, en las versiones anteriores a la versión 1.5 o 5 de Java no existían los tipos de datos enum con lo que se debía usar constantes de la siguiente forma:
public static String COLOR_ROJO = "rojo";
public static String COLOR_VERDE = "verde";
public static String COLOR_AZUL = "azul";
A partir de la versión 5 de Java se incorporarón al lenguaje los tipos de datos enumerados con el objetivo de mejorar varios aspectos sobre el uso de las constantes.
Segundo, tener en cuenta sus definiciones:
const
Un dato que no va a ser modificador a lo largo de un programa, es una constante:
const DEFAULT_COLOR: string = 'red';
Esto es aplicable a un conjunto de datos también.
const DEFAULT_CONFIGURATION: any {
APP_NAME: ‘Nombre de mi programa‘,
AUTHOR: ‘Branko Fuenzalida’,
BUILD: 34,
VERSION: ‘1.0.0’
};
enum
Un conjunto de constantes relacionadas entre si por un factor común, es un Enum:
enum Colors {
enum Colors {
Blue, // 0 Blue = 'BLUE',
Green, // 1 Green = 'GREEN',
Purple, // 2 Purple = 'PURPLE',
Red // 3 Red = 'RED'
};
};
Si no se indica un valor para cada propiedad, se le es asignado una consecución de números en incremento empezando por el cero.
Básicamente, un enum en Java es un conjunto fijo y relacionado de constantes como pueden ser los días de la semana y deberían usarse siempre que se necesite representar un conjunto de constantes con esas características. La característica de relacionado es importante, las constantes solo lo están por la convención que sigamos al darles un nombre. Los enums se definen de la siguiente forma:
public enum Dia {
LUNES,
MARTES,
MIERCOLES,
JUEVES,
VIERNES,
SABADO,
DOMINGO
}
public enum Color {
ROJO("FF0000"),
VERDE("00FF00"),
AZUL("0000FF");
private final String rgb; Color(String rgb) { this.rgb = rgb; }
public String getRGB() { return rgb; }
}
Como son constantes por las convenciones del lenguaje se escriben en mayúscula. Pero los enum son algo más que constantes, la clase del tipo del enum puede definir métodos y otras propiedades, como el método getRGB del ejemplo anterior o en el siguiente caso que se usa el método values() y que se añade automáticamente a todos los enums.
for (Dia d : Dia.values()) {
System.out.printf("El día de la semana %s", d);
}
for (Color c : Color.values()) {
System.out.printf("El color %s tiene como RGB %s", c, c.getRGB());
}
Ventajas de usar Enum sobre Constantes:
- Algunas cosas que hacen de los enum muy interesantes es que al definir las constantes de este modo se obtiene «type safety» (Seguridad de tipos para disminuir o prevenir los errores de tipos). Si decimos que un método de una clase recibe un enum el compilador comprobará en tiempo de compilación que cuando lo usamos le pasemos realmente un valor de ese enum, cosa que con constantes definidas como int o String el compilador solo comprueba que pasemos un int o String y por tanto podremos pasar cualquier valor aunque no sea una de las constantes esperadas por el método.
- Otra de las ventajas que ya se ve en ejemplo anterior es que los enums pueden tener comportamiento a través de los métodos que defina.
- También, específicamente diseñadas para los enums existen las clases EnumSet y EnumMap que trabajan con enums de forma más eficiente que con Set y Map.
- Además, los enums pueden ser usados en expresiones switch cosa que con constantes de tipo String solo podemos hacer a partir de la versión 7 de Java.
- Para comparar valores de enums podemos hacerlo con el operador == o con el método equals. Usar el operador == tiene la ventaja de evitar un posible NullPointerException y de que el compilador comprueba que se estén comparando dos valores del mismo enum.
== nunca lanza NullPointerException
Dia dia = null; if (dia == Dia.LUNES); // se ejecuta
if (dia.equals(Dia.LUNES)); // lanza NullPointerException
== comprueba compatibilidad de tipos en tiempo de compilación
if (Dia.LUNES.equals(COLOR.ROJO)); // compila bien
if (DIA.LUNES == COLOR.ROJO); // no compila, incompatibilidad de tipos
Tomado literalmente de:
