Effective Java （ENUM篇）

我们存放一些静态变量，像是一些变量和设置，等等等等，我们尽量使用ENUM，因为ENUM是不可实例化和继承的，所以他很安全，它是在程序一开始运行的时候进行一些编译，修改ENUM不需要再次编译。

在什么时候用ENUM呢。摘录如下。

Use enums when you want to define a range of values that something can be. Colour is an obvious example like:

public enum Colour
{
    White,
    Red,
    Blue
}
Or maybe a set of possible things like: (Example I stole from here as I'm lazy)

[FlagsAttribute]
enum DistributedChannel
{
  None = 0,
  Transacted = 1,
  Queued = 2,
  Encrypted = 4,
  Persisted = 16,
  FaultTolerant = Transacted | Queued | Persisted
}
Constants should be for a single value, like PI. There isn't a range of PI values, there is just PI.

一个简单应用

public enum CircleArea {
    CIRCLEONE(1.2),
    CIRCLETWO(2.5),
    CIRCLETHREE(3.5);

    private final double r;

    private static final double PI=3.14;

    CircleArea(double r) {
      this.r=r;
    }

    public double R(){
        return r;
    }

    public double Area(){
        return r*r*PI;
    }

    public double SomeArea(int Some){
        return Some*r*r*PI;
    }
}

测试

for (CircleArea c:CircleArea.values() ){

System.out.println(c+" "+c.R()+" "+c.SomeArea(3)+"");
}

使用ENUM的时候，如果enum里面有ABstract ，则声明的时候也必须要有，所以以下尽量使用Operation2的形式。

public enum Operation {
    PLUS, MINUS, TIMES, DIVDE;
    double apply(double x, double y) {
        switch (this) {
        case PLUS:
            return x + y;
        case MINUS:
            return x - y;
        case TIMES:
            return x * y;
        case DIVDE:
            return x / y;
        }
        throw new AssertionError("未定义类型" + this);
    }
}

public enum Operation2 {
    PLUS {
        double apply(double x, double y) {
            return x + y;
        }
    },
    MINUS {
        double apply(double x, double y) {
            return x - y;
        }
    },
    TIMES {
        double apply(double x, double y) {
            return x * y;
        }
    },
    DIVIDE {
        double apply(double x, double y) {
            return x / y;
        }
    };

    abstract double apply(double x, double y);
}

/////////////////////////带符号输出的
public enum Operation3 {
    PLUS("+") {
        double apply(double x, double y) {
            return x + y;
        }
    },
    MINUS("-") {
        double apply(double x, double y) {
            return x - y;
        }
    },
    TIMES("*") {
        double apply(double x, double y) {
            return x * y;
        }
    },
    DIVIDE("/") {
        double apply(double x, double y) {
            return x / y;
        }
    };

    private final String symbol;

    Operation3(String symbol) {
        this.symbol = symbol;
    }
    @Override public String toString(){
        return symbol;
    }

    abstract double apply(double x, double y);
}

除了EnumSet和EnumMap，都不要使用ordinals。

public enum WrongIdEnum {
    FIRST,SECOND,THIRD;
    public int getId(){
        return ordinal()+1;
    }
}

public enum IdEnum {
       FIRST(1),SECOND(2),THIRD(3);

    private final int id;
    IdEnum(int id){
        this.id=id;
    }
    public int getId(){
        return id;
    }
}

上面两个Enum都可以实现返回ID的功能，但是千万不要使用第一个类型，因为第一个类型非常不方便增删，如果我在中间删掉一个定量，因为ordinals代表的是当前在Enum的排序第几个，后面所代表的意义全部会乱。

在JAVA中，尽量不要使用位操作定量，可以使用EnumSet来替换，EnumSet比较安全且高效，继承了Enum的所有优点，什么是位操作定量，需要了解一下。附上EnumSet的一个实现。

public enum Day {
    MONDAY, TUESDAY, WEDNESDAY,
    THURSDAY, FRIDAY, SATURDAY, SUNDAY;
}

public class Worker {
     private String name;
     private Set<Day> avalibleDay;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Set<Day> getAvalibleDay() {
        return avalibleDay;
    }
    public void setAvalibleDay(Set<Day> avalibleDay) {
        this.avalibleDay = avalibleDay;
    }
    public Worker(String name, Set<Day> avalibleDay) {
        super();
        this.name = name;
        this.avalibleDay = avalibleDay;
    }
}

public static void getNoDay(Worker[] work){//哪天都没人来
        Set<Day> days = EnumSet.allOf(Day.class);
        for(Worker w:work){
            days.removeAll(w.getAvalibleDay());//在这里体现“位”操作
        }
        System.out.println("都没人在的是"+days);
    }

    public static void getEveryDay(Worker[] work){//哪天都来人
        Set<Day> days = EnumSet.allOf(Day.class);
        for(Worker w:work){
            days.retainAll(w.getAvalibleDay());//在这里体现“位”操作
        }
        System.out.println("都有人在的是"+days);
    }

Worker[] workers = new Worker[]{
                new Worker("张三", EnumSet.of(
                        Day.TUESDAY, Day.WEDNESDAY, Day.FRIDAY)),
                new Worker("李四", EnumSet.of(
                        Day.TUESDAY, Day.THURSDAY, Day.SATURDAY)),
                new Worker("王五", EnumSet.of(
                        Day.TUESDAY, Day.THURSDAY)),
        };
        MyTestMethod.getNoDay(workers);
        MyTestMethod.getEveryDay(workers);

//输出
//都没人在的是[MONDAY, SUNDAY]
//都有人在的是[TUESDAY]

 

用接口模拟可扩展Enum

设计枚举的时候最好不要设计可扩展性，如果实在要设计，可以使用接口的方式实现。

public interface OperationInterface {
  double apply(double x,double y);
}

public enum OperationEnum implements OperationInterface {//可以设计很多个implements  OperationInterface的枚举，实现枚举的变相扩展
    PLUS("+") {
        @Override
        public double apply(double x, double y) {
            return x + y;
        }
    },
    MINUS("-") {
        @Override
        public double apply(double x, double y) {
            return x - y;
        }
    };
    private final String symbol;

    OperationEnum(String symbol) {
        this.symbol = symbol;
    }
    @Override
    public String toString() {
        /**
         * @Description:
         * @author: shengzhizhi
         * @modifier:
         * @date: 2018年8月20日 下午5:58:21
         */
        return this.symbol;
    }

}

public class TestEnumForImplement {

    public static void main(String[] args) {
        double d1 = 1.2;
        double d2 = 2.2;
        say(Arrays.asList(OperationEnum.values()),d1,d2);
    }

    public static void say(Collection<? extends OperationInterface> opSet, double x, double y) {
        for (OperationInterface e : opSet) {
            System.out.printf("the methos is %s, result is %f%n", e, e.apply(x, y));
        }
    }
}