English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية
Uso de enum en Java
Uso 1: Constantes
En JDK1.5 Antes, definíamos constantes de la siguiente manera: public static fianl.... Ahora, con las enumeraciones, podemos agrupar constantes relacionadas en un tipo de enumeración y las enumeraciones proporcionan más métodos que las constantes.
public enum Color {
RED, GREEN, BLANK, YELLOW
}
Uso 2: switch
JDK1.6La declaración switch anterior solo admite tipos int, char, enum. Al usar enumeraciones, podemos mejorar la legibilidad de nuestro código.
enum Signal {
GREEN, YELLOW, RED
}
public class TrafficLight {
Signal color = Signal.RED;
public void change() {}}
switch (color) {
case RED:
color = Signal.GREEN;
break;
case YELLOW:
color = Signal.RED;
break;
case GREEN:
color = Signal.YELLOW;
break;
}
}
}
Uso tres: Añadir nuevos métodos a la enumeración
Si planea personalizar sus propios métodos, debe agregar un punto y coma al final de la secuencia de instancias de enum. Además, Java requiere que se defina primero el enum.
public enum Color {
RED("rojo", 1), GREEN("verde", 2), BLANK("blanco", 3), YELLO("amarillo", 4);
// miembro variable
private String name;
private int index;
// método constructor
private Color(String name, int index) {
this.name = name;
this.index = index;
}
// Métodos comunes
public static String getName(int index) {
for (Color c : Color.values()) {
if (c.getIndex() == index) {
return c.name;
}
}
return null;
}
// get set métodos
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getIndex() {
return index;
}
public void setIndex(int index) {
this.index = index;
}
}
Uso cuatro: Sobrescribir métodos de enumeración
A continuación se proporciona un ejemplo de la sobrescritura del método toString().
public class Test {
public enum Color {
RED("rojo", 1), GREEN("verde", 2), BLANK("blanco", 3), YELLO("amarillo", 4);
// miembro variable
private String name;
private int index;
// método constructor
private Color(String name, int index) {
this.name = name;
this.index = index;
}
// Métodos sobrescritos
@Override
public String toString() {
return this.index + "_" + this.name;
}
}
public static void main(String[] args) {
System.out.println(Color.RED.toString());
}
}
Uso cinco: Implementar la interfaz
Todos los enumerados heredan de la clase java.lang.Enum. Ya que Java no admite la herencia múltiple, los objetos enumerados ya no pueden heredar de otras clases.
public interface Behaviour {
void print();
String getInfo();
}
public enum Color implements Behaviour {
RED("rojo", 1), GREEN("verde", 2), BLANK("blanco", 3), YELLO("amarillo", 4);
// miembro variable
private String name;
private int index;
// método constructor
private Color(String name, int index) {
this.name = name;
this.index = index;
}
// método de interfaz
@Override
public String getInfo() {
return this.name;
}
// método de interfaz
@Override
public void print() {
System.out.println(this.index + ":" + this.name);
}
}
Uso seis: uso de interfaces para organizar enumeraciones
public interface Food {
enum Coffee implements Food {
BLACK_COFFEE, DECAF_COFFEE, LATTE, CAPPUCCINO
}
enum Dessert implements Food {
FRUIT, CAKE, GELATO
}
}
Uso siete: sobre el uso de conjuntos de enumeración
java.util.EnumSet y java.util.EnumMap son dos conjuntos de enumeración. EnumSet garantiza que los elementos del conjunto no se repitan; en EnumMap, la clave es del tipo enum y el valor puede ser de cualquier tipo. Sobre el uso de estos dos conjuntos, no se describirá aquí; se puede referir a la documentación de JDK
La diferencia entre la enumeración y la definición de constante
Primero, método de definición de constante común
Generalmente utilizamos el código definido por el método public final static, que se utiliza respectivamente por1representa la señal roja,3representa la señal verde,2representa la señal amarilla.
public class Light {
/* señal roja */
public final static int RED = 1;
/* señal verde */
public final static int GREEN = 3;
/* señal amarilla */
public final static int YELLOW = 2;
}
Segundo, método de definición de constante del tipo enumerativo
La definición simple del tipo enumerativo es como sigue, parece que no podemos definir cada valor del tipo enumerativo. Por ejemplo, el código para definir las luces rojas, verdes y amarillas puede ser el siguiente:
public enum Light {
RED, GREEN, YELLOW;
}
Sólo podemos representar las luces rojas, verdes y amarillas, pero no podemos expresar los valores específicos. No se apresure, ya que el tipo enumerativo proporciona un constructor, podemos implementar a través del constructor y el método toString sobrescrito. Primero, agregamos un método constructor al tipo enumerativo Light, luego cada valor del tipo enumerativo se transmite a través del constructor con los parámetros correspondientes, y al mismo tiempo sobrescribimos el método toString, que devuelve los parámetros introducidos en el constructor. El código modificado es el siguiente:
public enum Light {
// Uso del constructor con parámetros
), RED(1), GREEN(3), YELLOW(2);
// Definición de variable privada
private int nCode;
// Constructor, el tipo enumerado solo puede ser privado
private Light(int _nCode) {
this.nCode = _nCode;
}
@Override
public String toString() {
return String.valueOf(this.nCode);
}
}
Tres, ejemplo completo de código
El código completo del tipo enumerado se muestra a continuación:
public class LightTest {
// 1.Definición de tipo enumerado
public enum Light {
// Uso del constructor con parámetros
), RED(1), GREEN(3), YELLOW(2);
// Definición de variable privada
private int nCode;
// Constructor, el tipo enumerado solo puede ser privado
private Light(int _nCode) {
this.nCode = _nCode;
}
@Override
public String toString() {
return String.valueOf(this.nCode);
}
}
/**
*
* @param args
*/
public static void main(String[] args) {
// 1.Recorrida de tipos enumerados
System.out.println("Demostración de la recorrida de tipos enumerados ......");
testTraversalEnum();
// 2.Demostración del uso de objeto EnumMap
System.out.println("Demostración del uso y recorrida de objetos EnumMap.....");
testEnumMap();
// 3.Demostración del uso de EnumSet
System.out.println("Demostración del uso y recorrida de objetos EnumSet.....");
testEnumSet();
}
/**
*
* Demostración de la recorrida de tipos enumerados
*/
private static void testTraversalEnum() {
Light[] allLight = Light.values();
for (Light aLight : allLight) {
System.out.println("Nombre de la lámpara actual: " + aLight.name());
System.out.println("Ordinal de la lámpara actual: " + aLight.ordinal());
System.out.println("Lámpara actual: " + aLight);
}
}
/**
*
* Demostración del uso de EnumMap, el uso de EnumMap es similar al de HashMap, solo que el key debe ser de tipo enumeración
*/
private static void testEnumMap() {
// 1.Demostración de la definición de objeto EnumMap, el constructor del objeto EnumMap requiere que se pase un parámetro, el tipo de clase del key por defecto
EnumMap<Light, String> currEnumMap = new EnumMap<Light, String>(
Light.class);
currEnumMap.put(Light.RED, "semáforo rojo");
currEnumMap.put(Light.GREEN, "semáforo verde");
currEnumMap.put(Light.YELLOW, "semáforo amarillo");
// 2.Recorrer el objeto
for (Light aLight : Light.values()) {
System.out.println("[key=" + aLight.name() + ",value="
+ currEnumMap.get(aLight) + "];
}
}
/**
*
* Demostrar cómo usar EnumSet, EnumSet es una clase abstracta, obtener el contenido de tipos enumerados<BR/>
*
* Se puede usar el método allOf
*/
private static void testEnumSet() {
EnumSet<Light> currEnumSet = EnumSet.allOf(Light.class);
for (Light aLightSetElement : currEnumSet) {
System.out.println("Los datos actuales en EnumSet son:", + aLightSetElement);
}
}
}
El resultado de la ejecución es el siguiente:
Demostrar el recorrido de tipos enumerados......
Nombre de la luz actual: RED
Ordinal de la luz actual: 0
Luz actual:1
Nombre de la luz actual: GREEN
Ordinal de la luz actual:1
Luz actual:3
Nombre de la luz actual: YELLOW
Ordinal de la luz actual:2
Luz actual:2
Demostrar el uso y recorrido de objetos EnumMap.....
[key=RED,value=semáforo rojo]
[key=GREEN,value=semáforo verde]
[key=YELLOW,value=semáforo amarillo]
Demostrar el uso y recorrido de objetos EnumSet.....
Los datos actuales en EnumSet son:1
Los datos actuales en EnumSet son:3
Los datos actuales en EnumSet son:2
Diferencia entre el método de definición de constantes común y el método de definición de constantes enumeradas
El siguiente contenido puede ser un poco aburrido, pero definitivamente vale la pena echar un vistazo
1. Código:
public class State {
public static final int ON = 1;
public static final Int OFF= 0;
}
¿Qué hay de malo, todos lo han estado usando durante mucho tiempo, no hay problemas.
Primero, no es seguro de tipo. Debes asegurarte de que sea int
En segundo lugar, asegúrate de que su rango sea 0 y1
Finalmente, muchas veces cuando lo imprimes, solo ves 1 y 0 ,
Pero la persona que no ve el código no sabe tus intenciones, desecha todas tus constantes public static final antiguas
2. Se puede crear una clase enum, véala como una clase común. Además, no puede heredar de otras clases. (Java es de un solo heredamiento, ya que ha heredado de Enum),
Se pueden agregar otros métodos, sobrescribiendo sus métodos propios
3. Los parámetros de switch() pueden usar enum.
4. El método values() es insertado por el compilador en el método estático dentro de la definición de enum, por lo tanto, cuando se转型 una instancia de enum a un padre Enum, values() no es accesible. Solución: En la clase hay un método getEnumConstants(), por lo tanto, incluso si el interfaz Enum no tiene un método values(), aún podemos obtener todas las instancias de enum a través del objeto Class
5. No se puede heredar de subclases en enum, si es necesario expandir los elementos del enum, en el interior de una interfaz, cree un enum que implemente la interfaz, así se pueden agrupar los elementos del enum.
6. Utilice EnumSet en lugar de banderas. enum requiere que sus miembros sean únicos, pero no se pueden eliminar ni agregar elementos en el enum.
7. La clave de EnumMap es enum y el valor es cualquier otro objeto Object.
8. enum permite a los programadores escribir métodos para instancias de enum. Por lo tanto, se puede asignar un comportamiento diferente a cada instancia de enum.
9. Uso del Chain of Responsibility en enum. Esto se relaciona con el patrón de diseño Chain of Responsibility. Soluciona un problema de múltiples formas y luego los enlaza juntos. Cuando llega una solicitud, se recorre la cadena hasta que alguna solución en la cadena puede manejar la solicitud.
10. Máquina de estado utilizando enum.
11. Distribución de múltiples caminos utilizando enum.
Gracias por leer, espero que pueda ayudar a todos, gracias por el apoyo a nuestro sitio!