Sobre la enumeración
La mayoría de los enumeros escritos en los lugares reciben un enumno y luego el ejemplo comienza a cambiar. Pero quiero decir que es poco probable que los datos de mi código sean Enums, generalmente cadenas o números. Por ejemplo, después de analizar un SQL, primero determino el tipo SQL. Al interceptar el token SQL, la intersección puede ser seleccionada, eliminar, actualizar, insertar, alterar, etc., pero todas son cadenas. En este momento, quiero usar enums, pero no puedo hacerlo. ¿Cómo convertir la cadena en un enumio? Situaciones similares incluyen sacar datos de la base de datos y hacer juicios basados en algunos tipos, pasar datos de la página y realizar diferentes operaciones de acuerdo con diferentes tipos, pero todas son cadenas, no enums. La tragedia es que rara vez veo a alguien escribiendo esto; Así que lo escribí, con la esperanza de que alguien pueda usarlo.
En primer lugar, ¿por qué usar la enumeración? ¿Cuándo es mejor usar enums? ¿Cuáles son las ventajas de usar enums?
Creo que cuando se encuentra en algunas clases de categoría y puede enumerar y tipos sin cambios para guiar el programa para enrutar a diferentes lugares, usar la enumeración es una mejor opción;
Suena un poco confuso, pero hay un ejemplo que podría entenderse, por ejemplo:
Podemos enumerar las cosas que hacemos en nuestros días hábiles diarios:
Ir a trabajar, tener reuniones, comer, dormir, etc.
Podemos enumerar las piezas que deben ser examinadas por el Departamento de ENT del hospital:
Ojos, nariz, orejas, boca, etc.
Estos pueden ser enumerados, y tenemos que hacer cada uno de ellos de una manera diferente;
Por supuesto que puedes decir:
1. Se puede enviar dinámicamente a través de archivos de configuración o anotación;
2. Las constantes pueden usarse para lograr efectos similares;
3. Expresarlo directamente a través de los iguales de la cadena, y expresarlo con si más
Si utiliza el método de adición de configuración para enviarlo, es flexible y fácil de modificar; Pero si usamos muchos parámetros que no se modifican con frecuencia, a menudo aumentamos la carga de la configuración, y cuando necesita leer la lógica del sistema, debe leer la configuración y el código nuevamente; Sin embargo, si los parámetros son información transformable dinámicamente, usar la configuración es la opción correcta;
El uso de constantes suele ser números al cambiar de casos, y las cadenas no pueden ser casos de conmutación en Java. El propósito de usar constantes aumenta la legibilidad que el caso 1 y el caso 2 ... pero los datos de la cadena también son problemáticos. A menos que se mapee nuevamente, no hay necesidad. De hecho, la enumeración casi está mapeada para usted una vez, pero solo encapsula el código. Como se ha hecho y compatible sintácticamente, ¿por qué no usarlo? En segundo lugar, aunque las constantes aumentan la legibilidad, no tienen el concepto de categorías y tipos de gestión. Es decir, una definición de Enum define una categoría, que puede enumerar bien las cosas necesarias para este rango. Las constantes suelen ser algunas piscinas definidas por ellas mismas, colocadas en algunas clases públicas o definidas al azar, y están relativamente dispersas. Además, el enum se define claramente cuando se cambia, y el caso está dentro del rango de la enumeración de bloqueo. No solo puede controlar el sistema, aumentar la legibilidad, sino también verificar qué información enum en esta categoría es en cualquier momento, para lograr la función de mirar los archivos de configuración; Pero aún regresa en esa oración, si los parámetros son variables, entonces no es adecuado para la enumeración. Las enumeraciones deben ser enumerables, o las consideraciones actuales del sistema pueden enumerarse. Por ejemplo, puede haber muchos hospitales en el hospital anterior, pero el hospital actual solo procesa algunas partes y no procesa otras. Esta es la razón. ¿Qué es variable? Por ejemplo, los parámetros de URL se envían al método correspondiente. Es imposible para todos agregar un pedazo de lógica y agregar un enumerador y un estuche. En este momento, es mejor usar [Configuración + envío de métodos dinámicos]. Por supuesto, la configuración puede ser solo un archivo o anotación.
Lo más rústico es usar la cadena igual para implementarlo con IFE. Jaja, no hay nada de malo en esto, pero esto está escrito de manera dispersa. En segundo lugar, cada coincidencia es necesario comparar con cada personaje cada vez que coincida con los iguales. Si recorre mucho en su código, el rendimiento no es muy bueno, y el resto será más claro después de mirar la descripción anterior;
En segundo lugar, la enumeración proporciona un componente de gestión de tipo, lo que hace que el sistema orientado a objetos sea más perfecto, de modo que algunos tipos de administración se puedan configurar y administrar. Cuando se utiliza la enumeración, puede encontrar la definición de enumeración que se ha procesado y no se ha procesado, y lo anterior es difícil de lograr; Por ejemplo, hay 10 tipos de tipos de operación definidos en bases de datos, por lo que en el proceso de determinación, la enumeración se puede ver como un archivo de configuración, y es muy simple de administrar.
Finalmente, la enumeración es absolutamente singleton, y el rendimiento de la comparación es comparable al rendimiento digital, que puede obtener la legibilidad y el rendimiento.
Uso básico del tipo enum
Con una base tan teórica, echemos un vistazo a los tipos de enum en Java:
1. Puede agregar variables y métodos a enum.
Echemos un vistazo a un ejemplo de código:
public enum State {normal ("normal", 1), actualización ("actualizado", 2), eliminado ("eliminado", 3), disparado ("enmascarado", 4); // nombre de cadena privada variable de variable; Índice de int privado; // Método de construcción, Nota: El constructor no puede ser público, porque enum no puede ser instanciado estado privado (nombre de cadena, int index) {this.name = name; this.index = index; } // Método normal Public static String getName (int index) {for (state c: state .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; }}En el código anterior, podemos ver que después de definir el valor enum, luego agregarle un punto y coma, y luego puede definir otras variables y métodos. Cabe señalar en particular que el método de construcción en Enum no puede ser identificado por público, por lo que esto se hace para evitar que el usuario instancie el enum.
2. Se puede usar para definir constantes
Primero revisemos cómo definir constantes en Java y ver el siguiente código:
Public static final int normal = 1; private static final int updateState = 2;
A continuación también podemos usar enum enum para reemplazar la definición constante anterior, el código es el siguiente:
Public Enum State {normal, actualización, eliminado, despedido}No existe una ventaja de sintaxis en el uso de Enum para definir constantes en Java, pero el tipo enum enum puede proporcionar más funciones operativas.
3. Implementar la interfaz en Enum
Primero veamos el siguiente código:
interfaz pública iCanReadState {void read (); String getState ();} public enum State implementa IcanReadState {normal ("normal", 1), actualización ("actualizado", 2), eliminado ("eliminado", 3), disparado ("enmascarado", 4); nombre de cadena privada; Índice de int privado; estado privado (nombre de cadena, int index) {this.name = name; this.index = index; } // Método de interfaz 1 @Override public String getState () {return this.name; } // Método de interfaz 2 @Override public void Read () {System.out.println (this.index + ":" + this.name); }}Al igual que el uso de interfaces en las clases generales, el enum enum también puede heredar la interfaz e implementar todos los métodos en la interfaz. La ventaja de esto es que puede clasificar, comparar y otras operaciones más convenientes en los valores en el enum, y tener una mejor encapsulación.
Ejemplo
Primero definamos un enume simple (aquí hay solo un ejemplo, por lo que simplemente definiremos 3 variables):
public enum sqltypeenum {insertar, actualizar, eliminar, seleccionar}Después de analizar SQL, se obtiene un token. ¿Cómo obtenemos la enumeración de este token?
Consíguelo así:
String token = "Seleccionar"; Sqltypeenum sqltypeenum = sqltypeenum.valueOf (token.toupperCase ());
Si no se obtiene, Java lanzará una excepción: ilegalargumentException no enum const class sqltypeenum.xxx
La razón por la que hago capitalización es porque los enums también están capitalizados (por supuesto, si su enumación es minúscula, entonces usted es minúscula, pero es más problemático mezclarlo). De hecho, Value de llama el mapeo subyacente del enum:
Este método se llamará al llamar:
Así que también hay un hashmap adentro, ¡jaja!
Después de obtener esta información, puede hacer la operación deseada:
Switch (SQLTypeenum) {Case Insert: Handle Insertar Logic; romper; Eliminar de casos: manejar la lógica de eliminación; romper; ....}Ok, a veces es posible que no queramos usar cadenas como Insertar o Actualizar directamente en la interacción, porque muchas veces se requieren las especificaciones de nombres;
Por ejemplo, defina algunos tipos de acción del usuario:
1. Guarde la información del usuario
2. Obtenga información básica del usuario a través de ID
3. Obtenga la lista de usuarios
4. Eliminar información del usuario a través de ID
etc.
Podemos definir enumeraciones como:
public enum userOptionEnum {save_user, get_user_by_id, get_user_list, delete_user_by_id}Sin embargo, los métodos del sistema y algunas configuraciones de palabras clave generalmente se escriben como:
SaveUser, GetUserByid, GetUserByid, DeleteUserByid
Por supuesto, cada uno tiene sus propias reglas, pero si no quieres hacer la asignación en el medio, solo te comprometes. Reemplace todos los nombres de Enum, lo que parece bastante extraño, o reemplace todos los nombres de métodos, que es aún más extraño, o puede hacer la asignación usted mismo. Ok, es un poco más problemático, pero en realidad no es problemático?
Primero escribamos un método para convertir los datos de estilo subrayado enumerado a los camellos y colocarlos en un stringUtils:
Public static String convertDBStyletOJavastyle (String dbStyLestring, boolean FirstUpper) {dbStylestring = dbStylestring.tolowerCase (); String [] tokens = dbstylestring.split ("_"); StringBuilder StringBuilder = new StringBuilder (128); int longitud = 0; for (string token: tokens) {if (stringUtils.isnotblank (token)) {if (longitud == 0 &&! FirstUpper) {stringBuilder.append (token); } else {char c = token.charat (0); if (c> = 'a' || c <= 'z') c = (char) (c - 32); StringBuilder.append (c); StringBuilder.append (token.substring (1)); }} ++ longitud; } return StringBuilder.ToString (); }Sobrecarga un método:
public static String convertDBStyletOJavalocalStyle (String dbStyLestring) {return convertDBStyletOJavastyle (dbStylEstring, false); }Luego defina el enum:
public enum userOptionEnum {save_user, get_user_by_id, get_user_list, delete_user_by_id; Mapa estático final privado <String, UserOptionEnum> enum_map = new Hashmap <String, UserOptionEnum> (64); static {for (userOptionEnum v: value ()) {enum_map.put (v.ToString (), v); }} public staticuseroPtionEnum fromString (string v) {userOptionEnum userOptionEnum = enum_map.get (v); return userOptionEnum == NULL? Valor predeterminado: UserOptionEnum; } public String toString () {String StringValue = Super.ToString (); return StringUtil.ConvertDBStyletOJavalocalStyle (StringValue); }}Ok, pase un parámetro de evento como este para que si es: SaveUser, use:
String event = "saveUser"; // Si obtiene el parámetro userOptionEnum enum = userOptionEnum.FromString (evento);
De hecho, yo mismo hice un hashmap, y agregué un fromtring porque hay algunas restricciones en la enumeración y algunos métodos no le permiten sobrescribir, como el método ValueOf.
En realidad, no hay nada que decir. Hablemos de agregar algunas variables personalizadas a las enumines. De hecho, excepto por ser un singleton, los otros enumeros son similares a las clases ordinarias. También pueden tener métodos de constructor, pero no por defecto. También pueden proporcionar variables personalizadas y luego obtener métodos establecidos y obtenidos. Sin embargo, si hay establecido, el hilo no es seguro, así que preste atención a este punto; Entonces el método de construcción generalmente está escrito:
public enum sqltypeenum {insertar ("insertar en"), eliminar ("eliminar de") ...... omitido; Nombre de cadena privada; // Definir variable personalizada sqltypeenum (nombre de cadena) {this.name = name; } public String getName () {nombre de retorno; } public String toString () {Return Name + "I Dash"; // Reescribe el método ToString} // generalmente no recomendado public void setName (name de cadena) {this.name = name; }}Llamado:
Sqltypeenum sqltypeenum = sqltypeenum.valueOf ("insertar"); system.out.println (sqltypeenum); system.out.println (sqltypeenum.getName ());No se recomienda llamarlo:
sqltypeenum.setName ("maldición");En otro hilo:
Sqltypeenum sqltypeenum = sqltypeenum.valueOf ("insertar"); system.out.println (sqltypeenum); system.out.println (sqltypeenum.getName ());Descubrí que el resultado cambió, ¡jaja!