Java 2：枚举

1 基本使用

枚举里定义了一组常量，并赋给常量一个类型，及类和对象的行为。

package com.cowthan.enum2;

public enum Planet {

    MERCURY(3.302e+23, 2.439e6),  //水星
    VENUS(4.869e+24, 6.052e6),  //金星
    EARTH(5.975e+24, 6.378e6),  //
    MARS(6.419e+23, 3.393e6),   //火星
    JUPITER(1.899e+27, 7.149e7), //木星
    SATURN(5.685e+26, 6.027e7), //土星
    URANUS(8.683e+25,  2.556e7), //天王星
    NEPTUNE(1.024e+26, 2.477e7); //海王星

    /*

     枚举天生不可变，因此所有域都应该是final的

     */
    private final double mass;   //  kg
    private final double radius; //  meter
    private final double surfaceGravity; //    m/s^2
    public boolean fuck = false;

    private static final double G = 6.67300E-11;

    Planet(double mass, double radius) {
        this.mass = mass;
        this.radius = radius;
        surfaceGravity = G * mass / (radius * radius);
    }

    public double mass() {return mass;}
    public double radius() { return radius;}
    public double surfaceGravity() { return surfaceGravity;}
    public double surfaceWeight(double mass){
        return mass * surfaceGravity;
    }


    public static void main(String[] args) {
        double earthWeight = 100; //kg
        double mass = earthWeight / Planet.EARTH.surfaceGravity();
        for(Planet p: Planet.values()){
            System.out.printf("Weight on %s is %f%n", p, p.surfaceWeight(mass));
        }
    }
}

public enum Operation_1 {

    PLUS, MINUS, TIMES, DIVIDE;

    public double apply(double x, double y){

        switch(this){
        case PLUS: return x+y;
        case MINUS: return x-y;
        case TIMES: return x*y;
        case DIVIDE: return x/y;
        }
        throw new AssertionError("unknown op: " + this);  ///没有这句,编译不会通过
    }

}

2 抽象方法

package com.cowthan.enum2;

/**
 * 特定于常量的方法实现
 *
 */
public enum Operation {

    PLUS("+") {
        @Override
        double apply(double x, double y) {
            return x + y;
        }
    }, 
    MINUS("-") {
        @Override
        double apply(double x, double y) {
            return x - y;
        }
    }, 
    TIMES("*") {
        @Override
        double apply(double x, double y) {
            return x * y;
        }
    }, 
    DIVIDE("/") {
        @Override
        double apply(double x, double y) {
            return x / y;
        }
    };

    private final String symbol;

    private Operation(String symbol) {
        this.symbol = symbol;
    }

    abstract double apply(double x, double y);

    @Override
    public String toString() {
        return symbol;
    }
}

3 enum操作

enum的静态方法：
Week[] values()：返回所有常量的数组
Week valueOf(String)：根据常量名，获得枚举常量


enum的实例方法：
name()：获取常量名
ordinal()：获取枚举常量在类型中的数字位置，从0开始


特别注意：
ordinal()是内置的，这个是序数，是为EnumSet和EnumMap设计的，程序员不应该依赖这个方法做有关下标的事

你应该用实例域代替序数，例如MONDAY(1)

4 EnumSet代替位域： 枚举的集合

什么是位域呢，就是常见的flag模式，或者标志位模式

public class Text{

    public static final int STYLE_BOLD          = 1 << 0; //1   0001
    public static final int STYLE_ITALIC        = 1 << 1; //2   0010
    public static final int STYLE_UNDERLINE     = 1 << 2; //4   0100
    public static final int STYLE_STRIKETHROUGH = 1 << 3; //8   1000

    public void applyStyles(int styles){
    }

}

text.applyStyles(STYLE_BOLD | STYLE_ITALIC);  

OR运算符可以将几个常量合并到一个集合中，
这就叫位域（bit field），可以认为位域是标志位的集合


EnumSet可以用单个long来实现，性能比得上位域

改为使用位域：

public class Text{
    public enum Style { BOLD, ITALIC, UNDERLINE, STRIKETHROUGH }

    //任何Set都可以传进来，但EnumSet是最佳的

    public void applyStyles(Set<Style> styles){
    }
}

怎么调用：text.applyStyles(EnumSet.of(Style.BOLD, Style.ITALIC));

5 EnumMap代替序数索引

避免使用enum.ordinal()作为数组下标，如果想根据enum的序数快速定位枚举，应该用EnumMap

EnumMap：键是枚举的Map

Map<Week, Set<Course>> courses = new EnumMap<Week, Set<Course>>(Week.class);

for(Week w: Week.values()){
    courses.put(w, new HashSet<Course>>);
}

指定了EnumMap的key类型之后，由于enum的常量个数是固定的，
所以Enum最多有几个键也是固定的，
所以可以实现完美哈希

6 枚举和String

Enum.valueOf(s)方法，根据常量名的字符串直接得到枚举常量
如果toString被覆盖（默认返回常量名），则你需要下面这段代码来进行字符串和枚举常量的映射：

public enum Week {

    Monday;


    public String toString() {
        if(this == Week.Monday){
            return "周一";
        }
        return "";
    }

    private static final Map<String, Week> stringToEnum  = new HashMap<>();
    static{
        for(Week w: Week.values()){
            stringToEnum.put(w.toString(), w);
        }
    }

    public static void main(String[] args) {

        Week monday = Week.valueOf("Monday");   ///转换枚举常量name
        System.out.println(monday);

        Week monday2 = Week.stringToEnum.get("周一");  ///转换自定义字符串
        System.out.println(monday2);

    }

}

7 例子

策略枚举

策略模式的枚举版，普通的策略模式是一个接口，具体实现类来提供具体算法

需求：算每天的工资
每天上班标准是8小时，工资固定
超出部分是加班，工资1.5倍
平时超出8小时算加班
周末全算加班

你分析一下这个需求：
1 上班的这一天可能是工作日，周末，也有可能是其他节假日，而且加班工资可能也不一样
2 所以先定义个工作日类型，也可以看做薪资类型，主要处理加班工资的问题，这里是PayType

public enum PayRollDay {

    MONDAY(PayType.WEEKDAY),
    TUESDAY(PayType.WEEKDAY),
    WEDNESDAY(PayType.WEEKDAY),
    THURSDAY(PayType.WEEKDAY),
    FRIDAY(PayType.WEEKDAY),
    SATURDAY(PayType.WEEKEND),
    SUBDAY(PayType.WEEKEND);

    private final PayType payType;
    PayRollDay(PayType payType){
        this.payType = payType;
    }

    double pay(double hoursWorked, double payRate){
        return payType.pay(hoursWorked, payRate);
    }




    private enum PayType{
        WEEKDAY{
            double overtimePay(double hours, double payRate){
                return hours <= HOURS_PER_SHIFT ? 0 : (hours - HOURS_PER_SHIFT) * payRate / 2;
            }
        },

        WEEKEND{
            double overtimePay(double hours, double payRate){
                return (hours) * payRate / 2;
            }
        };


        private static final int HOURS_PER_SHIFT = 8;
        abstract double overtimePay(double hrs, double parRate);

        double pay(double hoursWorked, double payRate){
            double basePay = hoursWorked * payRate;
            return basePay + overtimePay(hoursWorked, payRate);
        }

    }


}

8 安卓里的枚举

安卓开发里之前一直有个说法，就是谷歌本身不建议使用枚举，因为枚举比不用枚举性能耗费高，但其实不用很在意这里的性能问题，如果你觉得用枚举确实能让代码清晰，那就用。
使用枚举一般情况下是给常量以类型，从而在方法参数里可以加类型限制，关于这一点，有个替代方案，就是@IntDef，这个就是谷歌为了让大家不使用枚举提供的注解，主要用于给int类型的常量提供编译期类型检查。

这个使用不是很复杂，代码如下：
代码来源：https://my.oschina.net/Bruce370/blog/499279?p={{page}}

public class MainActivity extends Activity {

    //先定义 常量
    public static final int SUNDAY = 0;
    public static final int MONDAY = 1;
    public static final int TUESDAY = 2;
    public static final int WEDNESDAY = 3;
    public static final int THURSDAY = 4;
    public static final int FRIDAY = 5;
    public static final int SATURDAY = 6;

    //用 @IntDef "包住" 常量；
    // @Retention 定义策略
    // 声明构造器
    @IntDef({SUNDAY, MONDAY,TUESDAY,WEDNESDAY,THURSDAY,FRIDAY,SATURDAY})
    @Retention(RetentionPolicy.SOURCE)
    public @interface WeekDays {}

    @WeekDays int currentDay = SUNDAY;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        setCurrentDay(WEDNESDAY);

        //声明变量
        @WeekDays int today = getCurrentDay();

        switch (today){
            case SUNDAY:
                break;
            case MONDAY:
                break;
            case TUESDAY:
                break;
            case WEDNESDAY:
                break;
            case THURSDAY:
                break;
            case FRIDAY:
                break;
            case SATURDAY:
                break;
            default:
                break;
        }

    }

    public void setCurrentDay(@WeekDays int currentDay) {
        this.currentDay = currentDay;
    }

    @WeekDays
    public int getCurrentDay() {
        return currentDay;
    }
}

注意：
compile 'com.android.support:support-annotations:22.0.0'