concepto
El nombre completo de enum es enumeración, que es una nueva característica introducida en JDK 1.5.
En Java, el tipo modificado por enum es el tipo enum. El formulario es el siguiente:
Color enum {rojo, verde, azul}Si el Enum no agrega ningún método, el valor de ENUM es predeterminado a un valor ordenado a partir de 0. Tomando el tipo de enumeración de color como ejemplo, sus constantes de enumeración son rojos: 0, verde: 1 y azul: 2 en secuencia
Los beneficios de la enumeración: las constantes se pueden organizar y gestionar de manera unificada.
Escenarios de aplicación típicos para la enumeración: códigos de error, máquinas de estado, etc.
La naturaleza de los tipos de enumeración
Aunque enum parece un nuevo tipo de datos, de hecho, Enum es una clase restringida y tiene su propio método.
Al crear una enumación, el compilador generará una clase relacionada para usted, que se hereda de java.lang.Enum .
java.lang.Enum Declaración de clase
La clase pública abstracta enum <e extiende enum <e>> implementa comparable <e>, serializable {...}Métodos de enumeración
En enum, se proporcionan algunos métodos básicos:
values() : Devuelve una matriz de instancias enum, y los elementos en esta matriz se mantienen estrictamente en el orden en que se declaran en enum.
name() : Devuelve el nombre de la instancia.
ordinal() : Devuelve el orden cuando se declara la instancia, comenzando desde 0.
getDeclaringClass() : Devuelve el tipo enum que pertenece la instancia.
equals() : determina si es el mismo objeto.
Puede usar == para comparar instancias enum .
Además, java.lang.Enum implementa las interfaces Comparable y Serializable , por lo que también se proporciona el método comparto ().
Ejemplo: métodos básicos para mostrar enum
clase pública enummethoddemo {enum color {rojo, verde, azul;} tamaño de enum {big, mediano, pequeño;} public static void main (string args []) {system.out.println ("================ Color todo color [] ========================================================================== For (Color C: Color.Values ()) System.out.println ("============== Impresa todo size ============================================== para (tamaño S: size.values ()) {System.Println (S +" Ordinal: " + S.ordinal ();) Color.green; Color.green: " + green.equals (color.green)); system.out.println (" Green es igual a size.middle: " + green.equals (size.middle)); system.out.println (" Green iguales 1: " + green.equals (1)); System.out.Format (" Green == Color.Blue: %B/N ", Green == Green.equals (1)); System.out.Format (" Green == Color.Blue: %B/N ", Green == Green.equals (1)); System.Out.Format (" Green == Color.Blue: %B/N ", Green == }}Producción
=============================== Red Ordinal: 0green Ordinal: 1Blue Ordinal: 2 ================ Impresión de todo el tamaño ================= Big Ordinal: 0Middle Ordinal: 1small Ordinal: 2green Nombre ():) getDeclaringClass (): class org.zp.javase.enumeration.enumdemo $ colorgreen hashcode (): 460141958green comparación color.green: 0green igual a color.green: trueGreen igual a tamaño.middle: falso iguales 1: falso ==
Características de la enumeración
Las características de la enumeración se resumen en una oración:
Además de no poder heredar, enum básicamente puede considerarse como una clase regular.
Pero esta oración debe entenderse por separado, expliquemos en detalle.
La enumeración puede agregar métodos
En el capítulo conceptual, el valor de ENUM es predeterminado a un valor ordenado a partir de 0. Entonces la pregunta es: cómo asignar valores al enum que se muestra.
Java no permite el uso de = asignar valores a las constantes enum
Si ha estado expuesto a C/C ++, definitivamente pensará en el símbolo de asignación = naturalmente. En el lenguaje C/C ++, el enum se puede asignar a las constantes enum con el símbolo de asignación = mostrado; Sin embargo, desafortunadamente, el símbolo de asignación = asignado a las constantes enum no está permitida en la sintaxis de Java.
Ejemplo: Declaración de enumeración en el lenguaje C/C ++
typedef enum {one = 1, dos, tres = 3, diez = 10} número;Enum puede agregar métodos ordinarios, métodos estáticos, métodos abstractos y métodos de constructor.
Aunque Java no puede asignar valores directamente a las instancias, tiene una solución aún mejor: Agregar métodos a Enum para implementar indirectamente las asignaciones de visualización.
Al crear enum , puede agregarle múltiples métodos e incluso constructores a él.
Nota Un detalle: si desea definir un método para una enumación, debe agregar un punto y coma al final de la última instancia de la enum. Además, en Enum, la instancia debe definirse primero, y los campos o métodos no se pueden definir antes de la instancia. De lo contrario, el compilador informará un error.
Ejemplo: Muestre completamente cómo definir métodos ordinarios, métodos estáticos, métodos abstractos y métodos de construcción en enumeraciones
public enum ErrorCode {OK (0) {public String getDescription () {return "exitoso"; }}, Error_a (100) {public String getDescription () {return "Error A"; }}, Error_b (200) {public String getDescription () {return "Error B"; }}; Código intivate int; // Constructor: el constructor de enum solo puede declararse como permiso privado o no declara permiso un código de error privado (int number) {// constructor this.code = number; } public int getCode () {// Código de retorno del método ordinario; } // método ordinario public abstract String getDescription (); // Método abstracto public static void main (String args []) {// método estático para (errorcode s: errorcode.values ()) {system.out.println ("código:" + s.getCode () + ", descripción:" + s.getdescription ()); }}}Nota: El ejemplo anterior no es recomendable, solo para mostrar que la enumeración respalda la definición de varios métodos. Aquí hay un ejemplo simplificado
Ejemplo: Definición de un tipo de enumeración del código de error
Los resultados de ejecución de este ejemplo y el ejemplo anterior son exactamente los mismos.
public enum ErrorCodeen {OK (0, "Success"), Error_a (100, "Error A"), Error_b (200, "Error B"); ErrorCodeen (int número, cadena descripción) {this.code = number; this.description = Descripción; } Código intivate int; Descripción de la cadena privada; public int getCode () {código de retorno; } public String getDescription () {return Descripción; } public static void main (string args []) {// método estático para (errorcodeen s: errorcodeen.values ()) {system.out.println ("code:" + s.getCode () + ", descripción:" + s.getdescription ()); }}}La enumeración puede implementar interfaces
enum puede implementar interfaces como clases generales.
También implementa la clase de enumeración del código de error en la sección anterior. Al implementar la interfaz, puede restringir sus métodos.
interfaz pública inumberenum {int getCode (); String getDescription ();} public enum errorcodeen2 implementa inumberenum {ok (0, "éxito"), error_a (100, "error A"), error_b (200, "error b"); ErrorCodeen2 (int número, string description) {this.code = number; this.description = Descripción; } Código intivate int; Descripción de la cadena privada; @Override public int getcode () {código de retorno; } @Override public string getDescription () {return Descripción; }}La enumeración no se puede heredar
Enum no puede heredar otra clase y, por supuesto, no puede heredar a otro enum.
Debido a que enum en realidad se heredan de java.lang.Enum , y Java no admite la herencia múltiple, Enum no puede heredar otras clases y, por supuesto, no puede heredar a otro enum .
Escenarios de aplicación enumerados
Organizar constantes
Antes de JDK1.5, la definición de constantes en Java era public static final TYPE a ; en esta forma. Con enumeraciones, puede organizar constantes de asociaciones para hacer que el código sea más legible y seguro, y también utilizar los métodos proporcionados por las enumeraciones.
Formato de declaración de enumeración
Nota: Si no hay ningún método definido en el enum, también puede agregar una coma, un semicolon o nada después de la última instancia.
Los siguientes tres métodos de declaración son equivalentes:
color enum {rojo, verde, azul} color enum {rojo, verde, azul,} color enum {rojo, verde, azul; }Interruptor de la máquina de estado
A menudo usamos declaraciones de interruptor para escribir máquinas de estado. Después de JDK7, Switch ha admitido los parámetros de int、char、String、enum . En comparación con este tipo de parámetros, el código de conmutación que usa enumeraciones es más legible.
Signal enum {rojo, amarillo, verde} public Static String getTraffiChiStruct (señal de señal) {String instruct = "falla de luz de señal"; interruptor (señal) {case rojo: instruct = "parada de luz roja"; romper; Caso amarillo: instruct = "por favor presta atención a la luz amarilla"; romper; Case verde: instruct = "línea de luz verde"; romper; predeterminado: ruptura; } instructo de retorno;}Organizar la enumeración
Las enumeraciones de tipos similares se pueden organizar a través de interfaces o clases.
Sin embargo, generalmente está organizado por la interfaz.
La razón es: la interfaz Java agregará automáticamente un modificador public static al tipo enum al compilar; La clase Java agregará automáticamente un modificador static al tipo enum al compilar. ¿Has visto la diferencia? Así es, es decir, organizar enum en la clase. Si no lo modifica al public , solo puede acceder a él en este paquete.
Ejemplo: organizar enums en interfaces
Planta de interfaz pública {enum vegetal implementa inumberenum {papa (0, "papa"), tomate (0, "tomate"); Vegetal (número int, string description) {this.code = number; this.description = Descripción; } Código intivate int; Descripción de la cadena privada; @Override public int getCode () {return 0; } @Override public String getDescription () {return null; }} Enum fruta implementa inumberenum {manzana (0, "manzana"), naranja (0, "naranja"), plátano (0, "plátano"); Fruit (int número, descripción de cadena) {this.code = number; this.description = Descripción; } Código intivate int; Descripción de la cadena privada; @Override public int getCode () {return 0; } @Override public String getDescription () {return null; }}}Ejemplo: Organice enums en una clase
Este ejemplo tiene el mismo efecto que el ejemplo anterior.
Public Class Plant2 {public enum vegetal implementa inumberenum {...} // omitir el código public enum fruta implementa inumberenum {...} // omitir el código}Enumeración de estrategia
Se muestra una enumeración de la estrategia en Java efectiva. Esta enumeración clasifica las constantes de enumeración por enumeraciones anidadas.
Aunque este enfoque no es tan conciso como la declaración Switch, es más seguro y más flexible.
Ejemplo: Ejemplo de enumeración de política en EffectViejava
enum payrolllday {lunes (paytype.weekday), martes (paytype.weekday), miércoles (paytype.weekday), jueves (paytype.weekday), viernes (paytype.weekday), sábado (paytype.weekend), domingo (paytype.weekend); PayType PayType de Pay Type privado; PayrOllDay (PayType PayType) {this.payType = PayType; } doble pago (doble hora de trabajo, doble Payrate) {return payType.pay (Hoursworked, PayRate); } // Política enum private enum payType {Weekday {doble overtimePay (horas dobles, doble payrate) {return horas <= sours_per_shift? 0: (horas - horas_per_shift) * Payrate / 2; }}, Fin de semana {doble overtimePay (horas dobles, doble payrate) {horas de retorno * PayRate / 2; }}; Private static final int soures_per_shift = 8; abstracto doble overtimePay (doble HRS, doble PayRate); doble pago (doble hora de trabajo, doble PayRate) {doble basepay = Hoursworked * PayRate; regresar Basepay + Overtimepay (Hourworked, Payrate); }}}prueba
System.out.println ("Ganancias para las personas que ganan 100 un salario por hora el viernes durante 8 horas:" + Payrolllday.friday.pay (8.0, 100)); System.out.println ("Ganancias para las personas que ganan 100 un salario por hora el sábado durante 8 horas:" + Payrollday.Saturday.pay (8.0, 100));Enumset y enummap
Java proporciona dos clases de herramientas que son convenientes para operar enums: enumset y enummap.
EnumSet es una implementación Set alto rendimiento de los tipos de Enum. Requiere que las constantes enumales colocadas en ella pertenezcan al mismo tipo de enum.
EnumMap es una implementación de mapa diseñada para tipos de enumes. Aunque el uso de otras implementaciones Map (como HASHMAP) también puede completar instancias de tipo Enum para la asignación de valor, el uso de enummap es más eficiente: solo puede recibir instancias del mismo tipo de enum que los valores clave, y debido a que el número de instancias de tipo enum es relativamente fijo y limitado, Enummap usa una matriz para almacenar los valores correspondientes al tipo de ENUM. Esto hace que el enumma sea muy eficiente.
// Uso de enumset System.out.println ("Enumset Display"); enumset <errorcodeen> errset = enumset.allof (errorcodeen.class); para (errorcodeen e: errset) {system.out.println (e.name () + ":" + e.ordinal ());} // uso de enummap system.out.println ("pantalla enummap"); enummap <stateMachine.signal, string> errmap = new New Enummap (stateMachine.signal.class); errmap.put (stateMachine.signal.red, "luz roja"); errmap.put (stateMachine.signal.yellow, "amarillo"); errmap.put (stateMachine.signal.green, "luz verde"); para (iterator <map.entry <statemachine.signal, singer = >> itera = errmap.entryset (). iterator (); System.out.println (Entry.getKey (). Name () + ":" + Entry.getValue ());}Lo anterior es todo el contenido de este artículo. Espero que sea útil para el aprendizaje de todos y espero que todos apoyen más a Wulin.com.