1. Antecedentes
Antes de que se haya introducido el lenguaje Java, el patrón común para indicar un tipo de enumación es declarar un conjunto de constantes int. El código que usamos para definir antes de usar el método estático final público es el siguiente, utilizando 1 para representar la primavera, 2 para representar el verano, 3 para representar el otoño y 4 para representar el invierno.
Temporada de clase pública {public static final int spring = 1; Public estática final int verano = 2; Public Static Final Int Autumn = 3; Public estática final int winter = 4;}Este método se llama patrón de enumeración. Pero, ¿qué pasa con este modelo? Lo hemos usado durante tanto tiempo, por lo que no debería haber ningún problema. Por lo general, el código que escribimos tiene en cuenta su seguridad, facilidad de uso y legibilidad. Primero, consideremos su tipo de seguridad. Por supuesto, este patrón no es seguro. Por ejemplo, diseñamos una función que requiere un cierto valor en primavera, verano, otoño e invierno. Sin embargo, con el tipo int, no podemos garantizar que el valor pasado sea legal. El código se ve así:
String privado getChinesesEason (int sempentiz) {stringBuffer resultado = new StringBuffer (); switch (temporada) {case store.spring: resultado.append ("primavera"); romper; CASE TEMPORADA.GUMMER: Result.append ("Summer"); romper; Case Season.Autumn: result.append ("otoño"); romper; Case Season.winter: result.append ("Invierno"); romper; predeterminado: resultado.append ("Temporada Ninguno en la Tierra"); romper; } return resultado.toString (); } public void dosomething () {System.out.println (this.getChinesesEason (sazone.spring)); // Este es un escenario normal System.out.println (this.getChinesesEesonason (5)); // Este es un escenario anormal, que conduce a tipos de inseguridad}El programa GetChinesesEeson (temporada.spring) es el método que esperamos usar. Pero GetChinesesEason (5) obviamente no es el caso, y la compilación es muy pasiva. No sabemos qué sucede en el tiempo de ejecución. Obviamente, esto no se ajusta a la seguridad de los programas Java.
A continuación, consideremos la legibilidad de este patrón. La mayoría de las ocasiones, al usar enumeraciones, necesito ser conveniente para obtener expresiones de cadena de tipo enum. Si imprimimos las constantes de intenumeración, lo que vemos es un conjunto de números, que no es muy útil. Podemos pensar en usar constantes de cadena en lugar de constantes int. Aunque proporciona cadenas imprimibles para estas constantes, causa problemas de rendimiento, ya que se basa en las operaciones de comparación de cadenas, por lo que este patrón también es algo que no esperamos. Teniendo en cuenta tanto la seguridad como la legibilidad del programa, se revelan las desventajas de los patrones de enumeración INT y String. Afortunadamente, desde la liberación de Java 1.5, se ha propuesto otra solución alternativa que evita las desventajas de los patrones de enumeración INT y String y proporciona muchos beneficios adicionales. Ese es el tipo enum. Los siguientes capítulos presentarán las definiciones, características, escenarios de aplicaciones y ventajas y desventajas de los tipos de enumeración.
2. Definición <Br /> El tipo de enum se refiere a un tipo legal compuesto por un conjunto fijo de constantes. En Java, la palabra clave enum se usa para definir un tipo enum. La siguiente es la definición del tipo Java Enum.
Temporada de enum público {Primavera, verano, otoño, winer;} 3. Características
Las declaraciones de Java que definen los tipos de ENUM son muy simples. Tiene las siguientes características:
1) Use la palabra clave enum 2) Nombre de tipo, como la temporada 3) una cadena de valores permitidos, como la primavera, el verano, el otoño, el invierno y las temporadas definidas por encima de 4) las enumeraciones se pueden definir por separado en un archivo o incrustarse en otras clases de Java.
Además de tales requisitos básicos, los usuarios tienen otras opciones
5) Las enumeraciones pueden implementar una o más interfaces (interfaces) 6) Se pueden definir nuevas variables 7) Se pueden definir un nuevo método 8) Las clases que varían según los valores de enumeración específicos se pueden definir
4. Escenarios de aplicación
Tomando el tipo de seguridad mencionado en segundo plano como ejemplo, reescribe ese código con un tipo de enum. El código es el siguiente:
Temporada pública enum {primavera (1), verano (2), otoño (3), invierno (4); Código intivate int; temporada privada (código int) {this.code = código; } public int getCode () {código de retorno; }} La clase pública usa temporada { / ** * Convertir la temporada de inglés a la temporada china * @param temporada * @return * / public string getChinesesEason (temporada de temporada) {stringBuffer resultado = new StringBuffer (); Switch (temporada) {Case Spring: Result.Append ("[Chino: primavera, enumeración constante:" + temporada.name () + ", data:" + sazone.getcode () + "]"); romper; Caso otoño: resultado.append ("[chino: otoño, enumeración constante:" + sazone.name () + ", data:" + temporada.getCode () + "]"); romper; Case Summer: Result.append ("[Chino: verano, enumeración constante:" + temporada.name () + ", data:" + temporada.getCode () + "]"); romper; Caso de invierno: resultado.append ("[chino: invierno, constantes de enumeración:" + temporada.name () + ", datos:" + sazone.getcode () + "]"); romper; predeterminado: resultado.append ("Season sin tierra" + temporada.name ()); romper; } return resultado.toString (); } public void dosomThething () {para (temporada s: sazone.values ()) {system.out.println (getChinesesEason (s)); // Este es un escenario normal} //system.out.println(getChinesesEsonseason(5)); // El compilador ya está fallando aquí, lo que garantiza la seguridad de tipo} public static void main (string [] arg) {useEason ussEason = new useEason (); usa temporada.dosomting (); }}[Chino: primavera, enumeración constante: primavera, datos: 1] [chino: verano, enumeración constante: verano, datos: 2] [chino: otoño, enumeración constante: otoño, datos: 3] [chino: invierno, enumeración constante: invierno, datos: 4]
Aquí hay una pregunta, ¿por qué quiero agregar el dominio al tipo enum? El propósito es asociar los datos con sus constantes. Por ejemplo, 1 representa la primavera y 2 representa el verano.
5. Resumen
Entonces, ¿cuándo debería usar enums? Cada vez que se necesita un conjunto fijo de constantes, como los días de una semana, las estaciones del año, etc. o una colección de todos los valores que contiene antes de compilar. La enumeración Java 1.5 puede cumplir con los requisitos de la mayoría de los programadores, y sus características concisas y fáciles de usar son muy prominentes.
6. Uso
Uso 1: Constante
Color en enum público {rojo, verde, en blanco, amarillo}Uso 2: Switch
Enum Signal {verde, amarillo, rojo} clase pública Transflight {Signal Color = Signal.Red; public void Change () {Switch (color) {case rojo: color = señal.green; romper; Caso amarillo: color = señal.red; romper; Case Green: Color = Signal.ellow; romper; }}}Uso 3: Agregue un nuevo método al enum
Color en enum público {rojo ("rojo", 1), verde ("verde", 2), en blanco ("blanco", 3), yello ("amarillo", 4); // nombre de cadena privada variable de variable; Índice de int privado; // Construir método Color privado (nombre de cadena, int index) {this.name = name; this.index = index; } // Método normal Public static String getName (int index) {for (color c: color.values ()) {if (c.getIndex () == index) {return c.name; }} return null; } // Obtener el método establecido public String getName () {Return Name; } public void setName (nombre de cadena) {this.name = name; } public int getIndex () {Index return; } public void setIndex (int index) {this.index = index; }}Uso 4: Métodos para sobrescribir enumeración
Color en enum público {rojo ("rojo", 1), verde ("verde", 2), en blanco ("blanco", 3), yello ("amarillo", 4); // nombre de cadena privada variable de variable; Índice de int privado; // Construir método Color privado (nombre de cadena, int index) {this.name = name; this.index = index; } // Método de sobrescribencia @Override public String toString () {return this.index+"_"+this.name; }}Uso 5: Implementar la interfaz
Comportamiento de interfaz pública {void print (); Cadena getInfo (); } Color de enum public en enum implementa el comportamiento {rojo ("rojo", 1), verde ("verde", 2), en blanco ("blanco", 3), yello ("amarillo", 4); // nombre de cadena privada variable de variable; Índice de int privado; // Construir método Color privado (nombre de cadena, 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 6: Use la interfaz para organizar la enumeración
Food Public Interface Food {Enum Coffee implementa la comida {Black_coffee, Decaf_coffee, Latte, Cappuccino} El postre enum implementa alimentos {fruta, pastel, gelato}}Lo anterior se trata de este artículo, espero que sea útil para el aprendizaje de todos.