Java封神之路-巧用Enum

为什么要用Enum

我们在实现业务功能时，经常会遇到一个维度的分类，比如针对小孩，成年人和老人我们需要做不同的业务实现，这时会用到if...else语句或者switch语句进行判断并处理。我们可以这样写

switch(personStatus) {
    case 1:
        doSomething
        break;
    case 2:
        doSomething
        break;
    case 3:
        doSomething
        break;
    default:
        break;
}

显然，从代码规范来说，这是比较糟糕的，因为我们使用了魔法值（即未被定义就直接使用的值），这里的1，2和3我们如果不结合上下文很难知道他们分别代表什么。
我们稍作改进可以写成这样

private static final String CHILD = 1;
private static final String ADULT = 2;
private static final String OLD = 3;
switch(personStatus) {
    case CHILD:
        doSomething
        break;
    case ADULT:
        doSomething
        break;
    case OLD:
        doSomething
        break;
    default:
        break;
}

这种写法让代码可读性更好，并且避免了使用魔法值的情况。

但是，如果你正在参与的是一个大项目，上面的代码块实现在A类中，如果需要在B类中使用同样的逻辑或者PersonStatus，那我们需要重新定义常量或者引用定义在常量类中的上面三个常量。
这时候，枚举类就可以派上用场，下面我们来看看java.lang下的Enum

有关Enum

继承关系

enum类.png

下面将上述提到的三个常量提到一个枚举类中,后面结合该类以及Enum的源码说说Enum有哪些常规用法和巧妙的用法

/**
 * Created by jackie on 17/7/30.
 */
public enum PersonStatus {
    NOT_SUPPORT(0), CHILD(1), ADULT(2), OLD(3);

    private int value;
    private PersonStatus(int value) {
        this.value = value;
    }

    public int getValue() {
        return this.value;
    }

    public static PersonStatus getPersonStatus(int personStatus) {
        PersonStatus result = null;
        switch (personStatus) {
            case 1:
                result = CHILD;
                break;
            case 2:
                result = ADULT;
                break;
            case 3:
                result = OLD;
                break;
            default:
                break;
        }

        return result;
    }
}

name和ordinal

Enum类有两个final类型的成员变量name和ordinal，分别表示枚举常量的名称以及枚举常量的序数，分别可以通过方法name()和ordinal()来获取。
既然声明为final类型，则表明一旦生成赋值则不会再变，即常量。
比如PersonStatus枚举类中定义的四个变量都是常量，可以通过这两个方法获取对应的值

PersonStatus personStatus = PersonStatus.getPersonStatus(1);
System.out.println("PersonStatus: " + personStatus);
System.out.println("name: " + personStatus.name());
System.out.println("ordinal: " + personStatus.ordinal());

得到的结果如下：

PersonStatus: CHILD
name: CHILD
ordinal: 1

equal方法

public final boolean equals(Object other) {
        return this==other;
    }

注意，这里用的是“==”进行比较，为什么呢?
因为这里的枚举常量都是final类型，都是不可变的常量，而且对于child、adult和old都只有一份，所以可以直接比较他们的值即可。

compareTo方法

public final int compareTo(E o) {
        Enum<?> other = (Enum<?>)o;
        Enum<E> self = this;
        if (self.getClass() != other.getClass() && // optimization
            self.getDeclaringClass() != other.getDeclaringClass())
            throw new ClassCastException();
        return self.ordinal - other.ordinal;
    }

从函数实现的源代码可以发现，compareTo函数实际上比较的是枚举常量的序数

System.out.println(PersonStatus.ADULT.compareTo(PersonStatus.OLD));

改行代码执行的结果为-1，因为PersonStatus.ADULT的ordinal值为2，小于PersonStatus.OLD的ordinal为3。

慎用ordinal

上面已经介绍了ordinal表示枚举常量的序数，默认是从0开始，这里NOT_SUPPORT是枚举类中的第一个，所以ordinal值为0，CHILD是枚举类中的第二个，所以ordinal的值为1，以此类推。
如果你在实际开发中使用ordinal来作为判断条件，好比上面的代码中判断某个枚举的常量的ordinal为1则表示的是CHILD。但是如果有一天，CHILD这个枚举常量从枚举类PersonStatus中删除了，那么你写出的代码就会有问题，这时候，我们可以使用上面枚举类中自己实现的getValue方法。这里getValue正好返回的与ordinal值是一样的，但是实际上返回的value是枚举常量括号里的数值，好比CHILD(1)通过getValue返回的实际上是括号的1，这样可以避免这个问题。

巧用NOT_SUPPORT

上面新建的枚举类中除了三个常量以外还定义了一个NOT_SUPPORT枚举常量，那么什么时候可以用到这个常量呢？
当我们需要校验时，比如现在对于不是PersonStatus中的CHILD、ADULT和OLD三种枚举常量的情况需要做额外的判断，比如用户填了值5，这时候需要捕获异常或者抛出异常。
常规做法是

if(PersonStatus.CHILD.getValue() != personStatus && PersonStatus.ADULT.getValue() != personStatus && PersonStatus.OLD.getValue() != personStatus) {
    ...
}

但是有了NOT_SUPPORT，我们可以这么写

if(PersonStatus.NOT_SUPPORT.equal(PersonStatus.getPersonStatus(personStatus))) {
    ...
}
这样的写法是不是更加简洁方便。