Directorio de artículos
enumerar
1. Antecedentes y definición de enumeración
Las enumeraciones se introdujeron después de JDK 1.5. El objetivo principal es organizar un conjunto de constantes. Antes de eso, un conjunto de constantes generalmente se representaba por la forma de definir constantes:
public static final int RED = 1;
public static final int BLACK = 2;
public static final int GREEN = 3;
Pero hay cosas malas sobre los ejemplos constantes. Por ejemplo, puede haber un número 1, pero puede malinterpretarse como ROJO. Ahora podemos usar directamente la enumeración para organizar, de modo que tengamos un tipo, un tipo de enumeración. En lugar de dar forma ordinaria 1.
public enum TestEnum {
RED,BLACK,GREEN;
}
Ventajas: Organiza constantes para
escenarios de gestión unificados : código de estado de error, tipo de mensaje, división de color, máquina de estado, etc...
Esencia: Es java.lang.Enumuna subclase de, es decir, la clase de enumeración escrita por ti mismo, aunque no hay una herencia explícita Enum, hereda esta clase por defecto.
2. Uso de enumeraciones
2.1 declaración de cambio
public enum TestEnum {
RED,BLACK,GREEN,PINK;
public static void main(String[] args) {
TestEnum testEnum = TestEnum.BLACK;
switch (testEnum) {
case RED:
System.out.println("red!");
break;
case BLACK:
System.out.println("black!");
break;
case GREEN:
System.out.println("green!");
break;
case PINK:
System.out.println("pink!");
break;
default:
break;
}
}
}
2.2 Métodos comúnmente utilizados
EnumMétodos comunes de clases.
| nombre del método | describir |
|---|---|
| valores() | Devuelve todos los miembros de un tipo de enumeración como una matriz |
| ordinal() | Obtener la posición de índice de un miembro de enumeración |
| valor de() | Convierta una cadena ordinaria en una instancia de enumeración |
| comparar con() | Comparar el orden en el que se definen dos miembros de enumeración |
2.2.1 Uso de valores()
public enum TestEnum {
RED,BLACK,GREEN,PINK;
public static void main(String[] args) {
TestEnum[] testEnums = TestEnum.values();
for (int i = 0; i < testEnums.length; i++) {
System.out.println(testEnums[i]);
}
}
}
2.2.2 Uso de ordinal()
public enum TestEnum {
RED,BLACK,GREEN,PINK;
public static void main(String[] args) {
TestEnum[] testEnums = TestEnum.values();
for (int i = 0; i < testEnums.length; i++) {
System.out.println(testEnums[i].ordinal());
}
}
}
2.2.3 Uso de valueOf()
public enum TestEnum {
RED,BLACK,GREEN,PINK;
public static void main(String[] args) {
System.out.println(TestEnum.valueOf("RED"));
System.out.println(TestEnum.valueOf("BLACK"));
System.out.println(TestEnum.valueOf("WHITE"));
}
}
2.2.4 Uso de compareTo()
public enum TestEnum {
RED,BLACK,GREEN,PINK;
public static void main(String[] args) {
TestEnum testEnum1 = TestEnum.RED;
TestEnum testEnum2 = TestEnum.BLACK;
System.out.println(testEnum1.compareTo(testEnum2));
System.out.println(RED.compareTo(GREEN));
System.out.println(PINK.compareTo(RED));
}
}
2.2.5 Constructor
public enum TestEnum {
RED("red",1),BLACK("black",11),GREEN("green",111),PINK("pink",1111);
private String name;
private int ordinal;
private TestEnum(String name,int ordinal){
this.name = name;
this.ordinal = ordinal;
}
public static TestEnum getEnumKey (int ordinal) {
for (TestEnum t :TestEnum.values()){
if(t.ordinal == ordinal){
return t;
}
}
return null;
}
public static void main(String[] args) {
System.out.println(getEnumKey(1111));
}
}
2.3 Notas
- Las clases de enumeración escritas por usted mismo se heredan por defecto
Enum. - El constructor de su propia clase de enumeración es privado
- Cuando escribimos una enumeración personalizada, que no contiene el método de valores, y luego compilamos el archivo java, el compilador java automáticamente nos ayudará a generar este método.
3. Ventajas y desventajas de la enumeración
ventaja:
- Las constantes de enumeración son más simples y seguras.
- Las enumeraciones tienen métodos integrados para un código más elegante
defecto:
- No heredable, no prorrogable
4. Enumeración y reflexión
Acabamos de ver en la reflexión que cualquier clase, incluso si su constructor es privado, podemos obtener su objeto de instancia a través de la reflexión, entonces el constructor de la enumeración también es privado, ¿podemos obtenerlo? A continuación, experimentemos:
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
public class Reflect {
public static void reflectPrivateConstructor() {
try {
Class<?> c = Class.forName("TestEnum");
Constructor<?> constructor = c.getDeclaredConstructor(String.class,int.class);
constructor.setAccessible(true);
TestEnum testEnum = (TestEnum) constructor.newInstance("1231123",123123);
System.out.println(testEnum);
} catch (ClassNotFoundException | NoSuchMethodException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
reflectPrivateConstructor();
}
}
Se informa un error después de la ejecución.
El significado aquí es que no hay un método de construcción correspondiente.
¿Por qué sucede esto?
Debido a que la herencia predeterminada java.lang.Enumhereda todo de la clase principal, excepto el constructor, ¡y la subclase debe ayudar a la clase principal a construir! La clase que escribimos no ayudó a la clase padre a construir. La enumeración es especial. Aunque escribimos dos, también agregó dos parámetros por defecto.
Es decir, nuestro propio constructor tiene dos parámetros y uno es String y uno es int. Al mismo tiempo, dará dos parámetros detrás de él por defecto, uno es String y el otro es int. Es decir, aquí estamos dando correctamente 4 parámetros:
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
public class Reflect {
public static void reflectPrivateConstructor() {
try {
Class<?> c = Class.forName("TestEnum");
Constructor<?> constructor = c.getDeclaredConstructor(String.class,int.class,String.class,int.class);
constructor.setAccessible(true);
TestEnum testEnum = (TestEnum) constructor.newInstance("1231123",123123,"4444",2323);
System.out.println(testEnum);
} catch (ClassNotFoundException | NoSuchMethodException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
reflectPrivateConstructor();
}
}
Después de ejecutar,
la información anormal en este momento muestra que es uno de mis métodos. Este método es: se informa un newInstance()error .
Ver el código fuente
4.1 Resumen
Aunque la reflexión es poderosa, no se puede obtener una instancia de una clase de enumeración a través de la reflexión.