paquete de enumeración

Referencia de dirección 1:. Https://blog.csdn.net/qq_35385687/article/details/90147104 
referencia Dirección 2: http://blog.lichengwu.cn/java/2011/09/26/the-usage-of-enum -in-java /

Lo enumeraciones son?

　　La enumeración es una colección de una constante entera es un grupo llamado, declarado con un identificador constante. La enumeración es común en la vida diaria normal, como el sexo de una persona sólo puede ser "macho" o "hembra", que es el único día de la semana de siete días, y así sucesivamente. Esto es similar a cuando una variable fija cuando hay varios valores posibles, que se puede definir como un tipo de enumeración. No tipos enumerados para 1,5 antes de la JDK, a continuación, la interfaz se utiliza generalmente en lugar de la constante. El uso de Java enumeración tipo de enumeración puede representar más de cerca esta constante.

declaración enum

Debe utilizarse cuando se declara una palabra clave de la enumeración de enumeración, a continuación, definir el nombre de la enumeración, accesibilidad, tipo subyacente, y miembros y así sucesivamente . sintaxis de declaración de enumeración es el siguiente:

enumeración patrón para coincidir enumeración enumname: enumeración - la base {
     enum - cuerpo, 
}

• ENUM modificadores enumeraciones modificadores incluyendo públicas, privadas e interna;
• enumname representan una declaración de enumeración del nombre;
• enum-base indica el tipo de base;
• enum-cuerpo de un miembro de la enumeración, es un tipo enumerado llamado constantes.

Enumeración de cualesquiera dos miembros no pueden tener el mismo nombre, y que debe estar en un valor constante de la gama de base de tipo de enumeración, separados por comas miembros pluralidad de enumeración.

Consejo: Si no se declara explícitamente un tipo subyacente de una enumeración, significa que se corresponde con el tipo subyacente es de tipo int.

Usando 1: El siguiente código define un tipo SexEnum enumerado representado el sexo y representan un color tipo enumerado de color.

// sexo enumerado tipo 
de enumeración SexEnum { 
    macho, hembra; 
} 
// representa el color enumerado tipo 
de enumeración color { 
    ROJO, AZUL, VERDE, NEGRO, AMARILLO; 
} 

pública  clase EnumDemo { 
    Color Color = Color.RED; 

    pública  nula cambio () {
         conmutador (color) {
             Caso ROJO: 
                color = Color.green;
                 PAUSA ;
             Caso AMARILLO: 
                color = Color.RED;
                 PAUSA ;
            Caso VERDE: 
                color = Color.YELLOW ,;
                 PAUSA ; 
        } 
    } 
    pública  estática  vacío main (String [] args) {
         // todos los casos el método de enumeración puede ser llamado Enum clase 
        System.out.println (SexEnum.male); // resultados de salida: hombre 
        System.out.println (SexEnum.female); // salida: Hembra 

        enumDemo enumDemo = nuevo nuevo enumDemo (); 
        enumDemo.change (); 
        System.out.println (enumDemo.color); // salida : VERDE 
    } 
}

la clase de enumeración

　　Java 中的每一个枚举都继承自 java.lang.Enum 类。当定义一个枚举类型时，每一个枚举类型成员都可以看作是 Enum 类的实例，这些枚举成员默认都被 final、public, static 修饰，当使用枚举类型成员时，直接使用枚举名称调用成员即可。所有枚举实例都可以调用 Enum 类的方法，常用方法如表 1 所示。

表1 Enum类的常用方法

方法名称	描述
values()	以数组形式返回枚举类型的所有成员
valueOf()	将普通字符串转换为枚举实例
compareTo()	比较两个枚举成员在定义时的顺序
ordinal()	获取枚举成员的索引位置

 

使用2：通过调用枚举类型实例的 values() 方法可以将枚举的所有成员以数组形式返回，也可以通过该方法获取枚举类型的成员。

//定义一个枚举类型
enum Signal{
    GREEN,YELLOW,RED;
}
public static void main(String[] args){
    for(int i=0;i<Signal.values().length;i++)    {
        System.out.println("枚举成员："+Signal.values()[i]);
    }
}

输出结果：

枚举成员：GREEN 
枚举成员：YELLOW 
枚举成员：RED

 

使用3：创建一个示例，调用 valueOf() 方法获取枚举的一个成员，再调用 compareTo() 方法进行比较，并输出结果。

public enum Sex {
   //定义一个枚举
   male,female;
}
public class TestEnum {
    public static void main(String[] args) {
        compare(Sex.valueOf("male"));    //比较
    }

    public static void compare(Sex s) {
        for(int i=0;i<Sex.values().length;i++){
            System.out.println(s+"与"+Sex.values()[i]+"的比较结果是："+s.compareTo(Sex.values()[i]));
        }
    }
}

输出结果：

male与male的比较结果是：0
male与female的比较结果是：-1

 

使用4：通过调用枚举类型实例的 ordinal() 方法可以获取一个成员在枚举中的索引位置。下面的示例创建一个包含 3 个成员的枚举类型 Signal，然后调用 ordinal() 方法输出成员及对应索引位置。

public class TestEnum1{
    enum Signal{
        //定义一个枚举类型
        GREEN,YELLOW,RED;
    }

    public static void main(String[] args)    {
        for(int i=0;i<Signal.values().length;i++){
            System.out.println("索引"+Signal.values()[i].ordinal()+"，值："+Signal.values()[i]);
        }
    }
}

输出结果：

索引0，值：GREEN
索引1，值：YELLOW
索引2，值：RED

 

使用5：下面的代码创建了一个枚举类型 WeekDay，而且在该类型中添加了自定义的方法。

注：为枚举添加方法；Java 为枚举类型提供了一些内置的方法，同时枚举常量也可以有自己的方法。此时要注意必须在枚举实例的最后一个成员后添加分号，而且必须先定义枚举实例。

enum WeekDay{    
　　 Mon("Monday"),
　　 Tue("Tuesday"),
　　 Wed("Wednesday"),
　　 Thu("Thursday"),
　　 Fri("Friday"),
　　 Sat("Saturday"),
　　 Sun("Sunday");

    //以上是枚举的成员，必须先定义，而且使用分号结束
    private final String day;
    private WeekDay(String day){
        this.day=day;
    }
    public static void printDay(int i) {
        switch(i) {
            case 1:
                System.out.println(WeekDay.Mon);
                break;
            case 2:
                System.out.println(WeekDay.Tue);
                break;
            case 3:
                System.out.println(WeekDay.Wed);
                break;
            case 4:
                System.out.println(WeekDay.Thu);
                break;
            case 5:
                System.out.println(WeekDay.Fri);
                break;
            case 6:
                System.out.println(WeekDay.Sat);
                break;
            case 7:
                System.out.println(WeekDay.Sun);
                break;
            default:
                System.out.println("wrong number!");
        }
    }
    public String getDay() {
        return day;
    }
}

测试：

public static void main(String[] args){
    for(WeekDay day:WeekDay.values()){
        System.out.println(day+"====>"+day.getDay());
    }
    WeekDay.printDay(5);
}

输出结果如下：

Mon====>Monday
Tue====>Tuesday
Wed====>Wednesday
Thu====>Thursday
Fri====>Friday
Sat====>Saturday
Sun====>Sunday
Fri

 

使用6：Java 中的 enum 还可以跟 Class 类一样覆盖基类的方法。下面示例代码创建的 Color 枚举类型覆盖了 toString() 方法。

public class Test{
    public enum Color {
        RED("红色",1),
　　　　 GREEN("绿色",2),
　　　　 WHITE("白色",3),
　　　　 YELLOW("黄色",4);

        //成员变量
        private String name;
        private int index;
        //构造方法
        private Color(String name,int index) {
            this.name=name;
            this.index=index;
        }
        //覆盖方法
        @Override
        public String toString() {
            return this.index+"-"+this.name;
        }
    }
    public static void main(String[] args) {
        System.out.println(Color.RED.toString());    //输出：1-红色
    }
}

EnumMap 和 EnumSet

　　为了更好地支持枚举类型，java.util 中添加了两个新类：EnumMap 和 EnumSet。使用它们可以更高效地操作枚举类型。
EnumMap 类是专门为枚举类型量身定做的 Map 实现。虽然使用其他的 Map（如 HashMap）实现也能完成枚举类型实例到值的映射，但是使用 EnumMap 会更加高效。java.util.EnumSet和java.util.EnumMap是两个枚举集合。EnumSet保证集合中的元素不重复；EnumMap中的 key是enum类型，而value则可以是任意类型。

使用7：下面是使用 EnumMap 的一个代码示例。枚举类型 DataBaseType 里存放了现在支持的所有数据库类型。针对不同的数据库，一些数据库相关的方法需要返回不一样的值，例如示例中 getURL() 方法。

//定义数据库类型枚举
public enum DataBaseType{
    MYSQUORACLE,
　　DB2,
　　SQLSERVER；
}

//某类中定义的获取数据库URL的方法以及EnumMap的声明
private EnumMap<DataBaseType,String> urls=new EnumMap<DataBaseType,String>(DataBaseType.class);
public DataBaseInfo(){
    urls.put(DataBaseType.DB2,"jdbc:db2://localhost:5000/sample");
    urls.put(DataBaseType.MYSQL,"jdbc:mysql://localhost/mydb");
    urls.put(DataBaseType.ORACLE,"jdbc:oracle:thin:@localhost:1521:sample");
    urls.put(DataBaseType.SQLSERVER,"jdbc:microsoft:sqlserver://sql:1433;Database=mydb");
}

//根据不同的数据库类型，返回对应的URL
//@param type DataBaseType 枚举类新实例
//@return
public String getURL(DataBaseType type){
    return this.urls.get(type);
}

EnumSet 是枚举类型的高性能 Set 实现，它要求放入它的枚举常量必须属于同一枚举类型。

EnumSet 提供了许多工厂方法以便于初始化，如表 所示。

使用8：实现接口（多实现）

interface Behaviour {
    void print();
    String getInfo();
}
interface Behaviour2 {
}
public enum EnumDemo implements Behaviour,Behaviour2{
    RED("红色", 1), 
    GREEN("绿色", 2), 
    BLANK("白色", 3), 
    YELLO("黄色", 4);
    
    // 成员变量
    private String name;
    private int index;
    // 构造方法
    private EnumDemo(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);
    }

    public static void main(String[] args) {
        EnumDemo.RED.print();
    }
}

使用9：接口组织枚举

public interface Food {  
    enum Coffee implements Food{  
        BLACK_COFFEE,DECAF_COFFEE,LATTE,CAPPUCCINO  
    }  
    enum Dessert implements Food{  
        FRUIT, CAKE, GELATO  
    }  
}