枚举详解

[图片上传失败...(image-74b02-1520561610956)]

Enum 类型的介绍

枚举类型（Enumerated Type）很早就出现在编程语言中，它被用来将一组类似的值包含到一种类型当中。而这种枚举类型的名称则会被定义成独一无二的类型描述符，在这一点上和常量的定义相似。不过相比较常量类型，枚举类型可以为申明的变量提供更大的取值范围

清单 1. 常量定义

Public static class RainbowColor { 
    
   // 红橙黄绿青蓝紫七种颜色的常量定义
   public static final int RED = 0; 
   public static final int ORANGE = 1; 
   public static final int YELLOW = 2; 
   public static final int GREEN = 3; 
   public static final int CYAN = 4; 
   public static final int BLUE = 5; 
   public static final int PURPLE = 6; 
}

使用的时候，你可以在程序中直接引用这些常量。但是，这种方式还是存在着一些问题。

类型不安全

由于颜色常量的对应值是整数形，所以程序执行过程中很有可能给颜色变量传入一个任意的整数值，导致出现错误。

2. 没有命名空间

由于颜色常量只是类的属性，当你使用的时候不得不通过类来访问。

3.一致性差

因为整形枚举属于编译期常量，所以编译过程完成后，所有客户端和服务器端引用的地方，会直接将整数值写入。这样，当你修改旧的枚举整数值后或者增加新的枚举值后，所有引用地方代码都需要重新编译，否则运行时刻就会出现错误。

4. 类型无指意性

由于颜色枚举值仅仅是一些无任何含义的整数值，如果在运行期调试时候，你就会发现日志中有很多魔术数字，但除了程序员本身，其他人很难明白其奥秘

如何定义 Enum 类型

为了改进 Java 语言在这方面的不足弥补缺陷，5.0 版本 SDK 发布时候，在语言层面上增加了枚举类型。枚举类型的定义也非常的简单，用 enum 关键字加上名称和大括号包含起来的枚举值体即可，例如上面提到的彩虹颜色就可以用新的 enum 方式来重新定义：

enum Color {            // 定义枚举类型
    RED, BLUE, YELLOW; // 定义枚举的三个类型

}

测试

class GetEnumContext{
    public static void main(String[] args) {
        Color color = Color.BLUE;       // 取出蓝色
        System.out.println(color);      // 输出信息
    }
}

使用switch判断

class GetEnumContext {
    public static void main(String[] args) {
        for (Color color : Color.values()) { // 枚举.values()获取全部枚举内容
            print(color);
        }
    }

    public static void print(Color color) {
        switch (color) {
            case RED:
                System.out.println("red 颜色");
            default:
                System.out.println("参数有误");
        }

    }
}

取得枚举信息

验证ordinal() 和 name()

class GetEnumContext {
    public static void main(String[] args) {

        for (Color color : Color.values()) { // 枚举.values()获取全部枚举内容
            System.out.println(color.ordinal() + "---->" + color.name());
            /**输出结果:
             * 0---->RED
             1---->BLUE
             2---->YELLOW
             */
        }
    }
}

为每一个枚举对象赋值

enum Color {                                    // 定义枚举类型
    RED("红色"), BLUE("蓝色"), YELLOW("黄色");  // 定义枚举3个类型
    private String dec;

    private Color(String dec) {                 // 定义构造方法
                                                // 设置名字
        this.dec = dec;
    }

    public String getDec() {                    // setXxx 和 getXxx
        return dec;
    }

    public void setDec(String dec) {
        this.dec = dec;
    }
}

测试

public class GetEnumContext {
    public static void main(String[] args) {

        for (Color color : Color.values()) { // 枚举.values()获取全部枚举内容
            System.out.println(color.ordinal()+"---->"+color.name()+"------>"+color.getDec());
            /**输出结果:
             * 0---->RED------>红色
             * 1---->BLUE------>蓝色
             * 2---->YELLOW------>黄色
             */
        }
    }
}

通过setXxx方法为属性赋值

public class Test6 {
    public static void main(String[] args) {

        Color color = Color.RED;
        color.setName("绿色");
        color.setName("红色");
        System.out.println(color.getName());
        
        /** 输出
         * 内容设置有误...
         红色
         */
    }
}


enum Color {             // 定义枚举类型
    RED, BLUE, YELLOW;  // 定义枚举3个类型
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        switch (this) {
            case RED:{
                if("红色".equals(name)){
                    this.name = name;
                }else {
                    System.out.println("内容设置有误...");
                }
                break;
            }

             default:{
                 System.out.println("该颜色有误..");
             }


        }

    }

}

使用比较器排序

enum Color {             // 定义枚举类型
    RED, BLUE, YELLOW;  // 定义枚举3个类型
}

public class Test6 {
    public static void main(String[] args) {

        Set<Color> colors = new TreeSet<Color>();
        colors.add(Color.YELLOW);
        colors.add(Color.RED);
        colors.add(Color.BLUE);
        Iterator<Color> iterator = colors.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());

        }

        /** 输出 按照ordinal的属性排序
         * RED
         BLUE
         YELLOW
         */
    }
}

类集对枚举的支持 EnumMap EnumSet

验证: EnumMap

enum Color {             // 定义枚举类型
    RED, BLUE, YELLOW;  // 定义枚举3个类型
}

public class Test6 {
    public static void main(String[] args) {

        Map<Color,String> desc = null;
        desc = new EnumMap<Color, String>(Color.class); // 实例化EnumMap
        desc.put(Color.BLUE,"绿色");
        desc.put(Color.RED,"红色");
        desc.put(Color.YELLOW,"黄色");
        for (Color color : Color.values()){
            System.out.println(color.name()+"----->"+desc.get(color));
        }

        /** 输出 按照ordinal的属性排序
         * RED----->红色
           BLUE----->绿色
           YELLOW----->黄色
         */
    }
}

使用枚举方法实现工厂模式更加简洁

public class S88 {
    public static void main(String[] args) {
      /*  Car car = CarFactory.createCar(FordCar.class);
        car.run();*/
      CarFactorys car = CarFactorys.BuickCar;
      car.create().run();

    }
}

interface Car {
    public abstract void run();
};

class FordCar implements Car {
    @Override
    public void run() {
        System.out.println("FordCar.run");
    }
}

class BuickCar implements Car {
    @Override
    public void run() {
        System.out.println("BuickCar.run");
    }
}

class CarFactory {
    Car car = null;

    public static Car createCar(Class<? extends Car> c) {
        try {
            return c.newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return null;
    }
}

// 第二种使用枚举

enum CarFactorys {
    // 定义工厂类能产生的类型
    FordCar, BuickCar;

    // 成产骑车
    public Car create() {
        switch (this) {
            case FordCar:
                return new FordCar();
            case BuickCar:
                return new BuickCar();
            default:
                throw new AssertionError("参数无效");
        }
    }
}

根据id获取对象

package com.toltech.appstore.persistence.entity.Test;

import java.util.Arrays;
import java.util.List;

/**
 * Created by wanggs on 2017/8/22.
 */
public class EnumTest {
    public static void main(String[] args) {
         List<Integer> USER_TYPES = Arrays.asList(CustType.STUDENT.getValue(), CustType.TEACHER.getValue(), CustType.PARENTS.getValue());
        System.out.println(USER_TYPES.contains(6));
        
        // false

    }
}
enum CustType {
    /**
     * 学生
     */
    STUDENT(1, "S", "学生"),
    /**
     * 教师
     */
    TEACHER(2, "T", "教师"),
    /**
     * 家长
     */
    PARENTS(3, "P", "家长");
    private int value;
    private String prefix;
    private String desc;

    private CustType(int value, String prefix, String desc){
        this.value = value;
        this.prefix = prefix;
        this.desc = desc;
    }

    public int getValue(){
        return value;
    }

    public String getPrefix() {
        return prefix;
    }

    public String getDesc(){
        return desc;
    }

    public static CustType getMemberType(int value){
        for(CustType mtype : CustType.values()){
            if(value == mtype.getValue()){
                return mtype;
            }
        }
        return null;
    }
}

Enum 类型的介绍

清单 1. 常量定义

类型不安全

由于颜色常量的对应值是整数形，所以程序执行过程中很有可能给颜色变量传入一个任意的整数值，导致出现错误。

2. 没有命名空间

由于颜色常量只是类的属性，当你使用的时候不得不通过类来访问。

3.一致性差

4. 类型无指意性

由于颜色枚举值仅仅是一些无任何含义的整数值，如果在运行期调试时候，你就会发现日志中有很多魔术数字，但除了程序员本身，其他人很难明白其奥秘

如何定义 Enum 类型

测试

使用switch判断

取得枚举信息

验证ordinal() 和 name()

为每一个枚举对象赋值

测试

通过setXxx方法为属性赋值

使用比较器排序

类集对枚举的支持 EnumMap EnumSet

验证: EnumMap

使用枚举方法实现工厂模式更加简洁

根据id获取对象

推荐阅读更多精彩内容