Clase de enumeración

Cuando necesitamos definir un conjunto de constantes, a menudo usamos clases de enumeración.

Uso 1: constante

Antes de JDK1.5, definíamos las constantes como: public static fianl .... Eso es bueno, con enumeraciones, las constantes relacionadas se pueden agrupar en un tipo de enumeración y las enumeraciones proporcionan más métodos que constantes.

public enum ColorEnum {  
  RED, GREEN, BLANK, YELLOW  
}

Uso 2: cambiar

La declaración de cambio antes de JDK1.6 solo admite tipos int, char, enum. El uso de enumeraciones puede hacer que nuestro código sea más legible.

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 3: agregar un nuevo método a la enumeración

Si planea personalizar su propio método, debe agregar un punto y coma al final de la secuencia de instancia de enumeración. Y Java requiere que primero se defina una instancia de enumeración.

public enum Color {  
    RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);  
    // 成员变量  
    private String name;  
    private int index;  
    // 构造方法  
    private Color(String name, int index) {  
        this.name = name;  
        this.index = index;  
    }  
    // 普通方法  
    public static String getName(int index) {  
        for (Color c : Color.values()) {  
            if (c.getIndex() == index) {  
                return c.name;  
            }  
        }  
        return null;  
    }  
    // get set 方法  
    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 cinco: implementar la interfaz

Todas las enumeraciones se heredan de la clase java.lang.Enum. Dado que Java no admite la herencia múltiple, los objetos de enumeración ya no pueden heredar otras clases.

public interface Behaviour {  
    void print();  
    String getInfo();  
}  
public enum Color implements Behaviour{  
    RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);  
    // 成员变量  
    private String name;  
    private int index;  
    // 构造方法  
    private Color(String name, int index) {  
        this.name = name;  
        this.index = index;  
    }  
    //接口方法  
    @Override  
    public String getInfo() {  
        return this.name;  
    }  
    //接口方法  
    @Override  
    public void print() {  
        System.out.println(this.index+":"+this.name);  
    }  
}

Uso seis: use la interfaz para organizar la enumeración

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 colecciones enumeradas

java.util.EnumSetLa suma java.util.EnumMapson dos colecciones enumeradas. EnumSet garantiza que los elementos del conjunto no se repitan; la clave en EnumMap es del tipo enum y el valor puede ser de cualquier tipo. En cuanto al uso de estas dos colecciones, no las repetiré aquí, puedes consultar la documentación de JDK.

Para conocer los detalles de implementación y los principios de enumeración, consulte:

Materiales de referencia: Cuarta edición de "ThinkingInJava"

anotación

Introducción

A partir de JDK 5.0, Java ha agregado soporte para MetaData, que es
Anotación
Las anotaciones son en realidad etiquetas especiales en el código. Estas etiquetas se pueden leer durante la compilación, la carga de clases y el tiempo de ejecución, y se puede realizar el procesamiento correspondiente. Al habilitar Anotación, los programadores pueden incrustar información complementaria en el archivo fuente sin cambiar la lógica original. Las herramientas de análisis de código, las herramientas de desarrollo y las herramientas de implementación se pueden verificar o implementar a través de esta información complementaria.

Anotaciones comunes

@author indica el autor que desarrolló este tipo de módulo, utilizado entre varios autores, split
@version indica la versión de este tipo de módulo
@ver dirección de referencia, es decir, el tema relevante
@ desde el cual
se agregó la versión @param a un parámetro en el método Si no hay parámetro, no puede escribir
@return para describir el valor de retorno del método. Si el tipo de valor de retorno del método es nulo, no puede escribir
@exception para describir las excepciones que el método puede generar. Si el método no lanza explícitamente con throws, la excepción no se puede escribir en él.

@Override: Límite que anula el método de la clase principal, esta anotación solo se puede usar para el método
@Deprecated: Se usa para indicar que el elemento modificado (clase, método, etc.) está desactualizado. Por lo general, porque la estructura modificada es peligrosa o hay una mejor opción
@SuppressWarnings: Suprimir las advertencias del compilador

Anotación personalizada

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@interface MyAnnotation{
	String value() default "myannotion"; 
}

Meta anotaciones en JDK

Defina un nuevo tipo de anotación usando la palabra clave @interface
Las anotaciones personalizadas heredan automáticamente la interfaz java.lang.annotation.Annotation
Las variables miembro de Annotation se declaran en forma de método sin parámetros en la definición de Annotation. El nombre del método y el valor de retorno definen el nombre y el tipo del miembro. Lo llamamos parámetros de configuración. El tipo solo puede ser
una matriz de ocho tipos de datos básicos, tipo de cadena, tipo de clase, tipo de enumeración, tipo de anotación y todos los tipos anteriores.
Puede especificar el valor inicial de la variable miembro de Anotación cuando la define, y puede usar la palabra clave predeterminada para especificar el valor inicial de la variable miembro.
Si solo hay un miembro de parámetro, se recomienda utilizar el valor del nombre del parámetro
Si la anotación definida contiene parámetros de configuración, entonces el valor del parámetro debe especificarse al usarlo, a menos que tenga un
valor predeterminado . El formato es "nombre de parámetro = valor de parámetro". Si solo hay un miembro de parámetro y el nombre es valor,
se puede omitir "valor ="
Las anotaciones sin definiciones de miembros se denominan etiquetas; las anotaciones que contienen variables de miembros se denominan
anotaciones de metadatos

Clases y anotaciones de enumeración de revisión básica de Java