《Effective Java》读书笔记五（枚举和注解）

No30 用enum代替int常量

一：综述

int枚举模式，示范：

// The int enum pattern - severely deficient!
public static final int APPLE_FUJI             =  0;
public static final int APPLE_PIPPIN           =  1;
public static final int APPLE_GRANNY_SMITH     =  2;

还有一种是这种模式的变体，使用String常量代替int常量，称为String枚举模式。缺点：

• int枚举是编译时常量，如果它发生了变化，客户端需要重新编译；
• 将int枚举常量翻译成可打印的字符串，并没有很便利的方法，你所见到的就是一个数字（比如调试，跟踪值等）；
• String枚举中的硬编码常量如果包含有书写错误，那么这样的错误在编译时不会被检测到，运行时会出错。

JDK1.5发行版本开始，提出了另一种可以替代的解决方案，可以避免int和String枚举模式的缺点，并提供许多额外的好处。示范：

public enum Apple {FUJI, PIPPIN, GARNNY_SMITH}

• 枚举提供了编译时的类型安全。如果声明一个参数的类型为Apple，就可以保证，被传到该参数上的任何非null的对象引用一定属于三个有效的Apple值之一。
• 常量值没有被编译到客户端代码中；
• 允许添加任意的方法和域，并实现任意的接口。

二：有关枚举的一个好例子：

// Enum type with data and behavior - Pages 149-150
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);
    private final double mass;           // In kilograms
    private final double radius;         // In meters
    private final double surfaceGravity; // In m / s^2

    // Universal gravitational constant in m^3 / kg s^2
    private static final double G = 6.67300E-11;

    // Constructor
    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;  // F = ma
    }
}

// Takes earth-weight and prints table of weights on all planets - Page 150
public class WeightTable {
   public static void main(String[] args) {
           if(args.length == 0) {
               args = new String[]{"100"};
           }
           
      double earthWeight = Double.parseDouble(args[0]);
      double mass = earthWeight / Planet.EARTH.surfaceGravity();
      for (Planet p : Planet.values())
          System.out.printf("Weight on %s is %f%n",
                            p, p.surfaceWeight(mass));
    
            Planet p = Planet.MERCURY;
      System.out.printf("dd Weight on %s is %f%n",
                        p, p.surfaceWeight(mass));
   }
}

三：复杂一些的例子，比较如下两段代码：

代码一：

// Enum type that switches on its own value – questionable
public enum Operation {
         PLUS, MINUS, TIMES, DIVIDE;
       
         // Do the arithmetic op represented by this constant
         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);
         }
}

上述代码可行，但是不太好看。如果没有throw语句，它就不能进行编译。另外，如果添加了新的枚举常量，却忘记给switch添加相应的条件，枚举仍然可以编译，但当你试图运用新的运算时，就会运行失败。

代码二：

// Enum type with constant-specific class bodies and data - Page 153
import java.util.*;

public enum Operation {
    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;
    Operation(String symbol) { this.symbol = symbol; }
    @Override public String toString() { return symbol; }

    abstract double apply(double x, double y);

    // Implementing a fromString method on an enum type - Page 154
    private static final Map<String, Operation> stringToEnum
        = new HashMap<String, Operation>();
    static { // Initialize map from constant name to enum constant
        for (Operation op : values())
            stringToEnum.put(op.toString(), op);
    }
    // Returns Operation for string, or null if string is invalid
    public static Operation fromString(String symbol) {
        return stringToEnum.get(symbol);
    }

    // Test program to perform all operations on given operands
    public static void main(String[] args) {
        double x = Double.parseDouble(args[0]);
        double y = Double.parseDouble(args[1]);
        for (Operation op : Operation.values())
            System.out.printf("%f %s %f = %f%n",
                              x, op, y, op.apply(x, y));
    }
}

输出：

2.000000 + 4.000000 = 6.000000

2.000000 - 4.000000 = -2.000000

2.000000 * 4.000000 = 8.000000

2.000000 / 4.000000 = 0.500000

注：枚举类型中的抽象方法必须被它所有常量中的具体方法覆盖。

No32 用EnumSet代替位域

如果一个枚举类型的元素主要用在集合中，一般就使用int枚举模式，将2的不同倍数赋予每个常量：

// Bit field enumeration constants – OBSOLETE!
import java.util.*;

public class Text {
    public static final int STYLE_BOLD          = 1 << 0;       //1
    public static final int STYLE_ITATIC         = 1 << 1;       //2
    public static final int STYLE_UNDERLINE     = 1 << 2;       //4
    public static final int STYLE_STRIKETHROUGH = 1 << 3;       //8
  
    //Parameter is bitwise OR of zero or more STYLE_ constants
    public void applyStyles(int styles){
        // 根据styles值进行拆分，判断是哪些参数...
    };

    // Sample use
    public static void main(String[] args) {
        Text text = new Text();
        text.applyStyles(STYLE_BOLD|STYLE_ITATIC);
    }   
}

下面是一个范例改成枚举代替位域后的代码，它更加简洁、更加清楚、也更加安全。

// EnumSet - a modern replacement for bit fields - Page 160
import java.util.*;

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

    // Any Set could be passed in, but EnumSet is clearly best
    public void applyStyles(Set<Style> styles) {
        // Body goes here
    }

    // Sample use
    public static void main(String[] args) {
        Text text = new Text();
        text.applyStyles(EnumSet.of(Style.BOLD, Style.ITALIC));
    }
}

No36 坚持使用Override注解

如果你能判断出下面的代码输出结果是260，而不是26，那么你的水平应该足够高。即使这样，也不应该忽略Override注解。

// Can you spot the bug? - Page 176
import java.util.*;

public class Bigram {
    private final char first;
    private final char second;
    public Bigram(char first, char second) {
        this.first  = first;
        this.second = second;
    }
    public boolean equals(Bigram b) {
        return b.first == first && b.second == second;
    }
    public int hashCode() {
        return 31 * first + second;
    }

    public static void main(String[] args) {
        Set<Bigram> s = new HashSet<Bigram>();
        for (int i = 0; i < 10; i++)
            for (char ch = 'a'; ch <= 'z'; ch++)
                s.add(new Bigram(ch, ch));
        System.out.println(s.size());
    }
}

在上面的代码中的方法equals之前增加@Override注解，则编译出错！因为equals需要的是Object参数，而不是Bigram参数。这样，你应该能够明白@Override的作用了吧。