Effective.Java第34-44条(枚举)
34. 使用枚举类型替代整型常量
常量的语义表达不清晰，只能靠前面的名称来区分。枚举具有可读性、更安全、更强大等优势。而且枚举类型对象之间的值比较可以使用==来比较值是否相等的，不是必须使用equals方法。
要将数据与枚举常量相关联，首先需要声明实例属性并编写一个构造方法，构造方法带有数据并将数据保存在属性中。枚举本质上是不变的，所有的属性都应设为final。
如下:
一个原始的常量类保存int值:
public class Constants { public static final int APPLE_FUJT = 1; public static final int APPLE_PIPPIN = 2; public static final int APPLE_other = 3; }
改装为枚举类型后的类如下:
public enum Apples { APPLE_FUJT(1), APPLE_PIPPIN(2), APPLE_other(3); final int number; private Apples(int number) { this.number = number; } }
测试代码:
public class Client { public static void main(String[] args) { System.out.println(Constants.APPLE_FUJT); System.out.println(Apples.APPLE_FUJT.number); } }
JDK中的枚举类型代替整形的例子:RoundingMode类和BigDecimal紧密关联
public enum RoundingMode { UP(BigDecimal.ROUND_UP), DOWN(BigDecimal.ROUND_DOWN), CEILING(BigDecimal.ROUND_CEILING), FLOOR(BigDecimal.ROUND_FLOOR),
HALF_UP(BigDecimal.ROUND_HALF_UP), HALF_DOWN(BigDecimal.ROUND_HALF_DOWN), HALF_EVEN(BigDecimal.ROUND_HALF_EVEN), UNNECESSARY(BigDecimal.ROUND_UNNECESSARY); final int oldMode; private RoundingMode(int oldMode) { this.oldMode = oldMode; } public static RoundingMode valueOf(int rm) { switch(rm) { case BigDecimal.ROUND_UP: return UP; case BigDecimal.ROUND_DOWN: return DOWN; case BigDecimal.ROUND_CEILING: return CEILING; case BigDecimal.ROUND_FLOOR: return FLOOR; case BigDecimal.ROUND_HALF_UP: return HALF_UP; case BigDecimal.ROUND_HALF_DOWN: return HALF_DOWN; case BigDecimal.ROUND_HALF_EVEN: return HALF_EVEN; case BigDecimal.ROUND_UNNECESSARY: return UNNECESSARY; default: throw new IllegalArgumentException("argument out of range"); } } }
BigDecimal中设置scale:
public BigDecimal setScale(int newScale, RoundingMode roundingMode) { return setScale(newScale, roundingMode.oldMode); }
35. 使用实例属性代替序数
也就是说枚举类的ordinal()方法返回的序号尽量不要使用。ordinal方法返回枚举常量的序数（它在枚举声明中的位置，其中初始常量序数为零）。
public class Client { public static void main(String[] args) { System.out.println(Operation.PLUS.ordinal()); System.out.println(Operation.MINUS.ordinal()); System.out.println(Operation.TIMES.ordinal()); System.out.println(Operation.DIVIDE.ordinal()); } }
结果:
0
1
2
3
如果需要用到序号，自己定义一个成员属性。如下:
public enum Operation { PLUS(1) { @Override double operate(double num1, double num2) { return num1 + num2; } }, MINUS(2) { @Override double operate(double num1, double num2) { return num1 - num2; } }, TIMES(3) { @Override double operate(double num1, double num2) { return num1 * num2; } }, DIVIDE(4) { @Override double operate(double num1, double num2) { return num1 / num2; } }; private int index; private Operation(int index) { this.index = index; } abstract double operate(double num1, double num2); public int getIndex() { return index; } public void setIndex(int index) { this.index = index; } }
测试代码:
public class Client { public static void main(String[] args) { System.out.println(Operation.PLUS.getIndex()); System.out.println(Operation.MINUS.getIndex()); System.out.println(Operation.TIMES.getIndex()); System.out.println(Operation.DIVIDE.getIndex()); } }
结果:
1
2
3
4
36. 使用EnumSet替代位属性
有时候我们使用位属性来做一些属性，比如按位 &,| 等操作。
常量类和枚举改造的常量类同上面34,如下:
public static void main(String[] args) { eatFruits(Constants.APPLE_FUJT | Constants.APPLE_PIPPIN); } static void eatFruits(int fruit) { System.out.println(fruit); }
我们在eatFruits知道参数是3，所以知道是1和2.
public static void main(String[] args) { EnumSet<Apples> enumSets = EnumSet.of(Apples.APPLE_FUJT, Apples.APPLE_PIPPIN); eatFruits(enumSets); } static void eatFruits(Set fruit) { System.out.println(fruit); }
结果:
[APPLE_FUJT, APPLE_PIPPIN]
37. 使用EnumMap替代序数索引
使用序数来索引数组很不合适，改用EnumMap。如果代表的关系是多维的，用EnumMap<...,EnumMap<...>>。程序员应该很少用Enum.ordinal。
如下植物类:
/** * 植物类 * * @author Administrator * */ public class Plant { enum LifeCycle { // 1年生, 永久, 两年生 ANNUAL, PERENNIAL, BIENNIAL; } final String name; final LifeCycle lifeCycle; public Plant(String name, LifeCycle lifeCycle) { super(); this.name = name; this.lifeCycle = lifeCycle; } public String getName() { return name; } public LifeCycle getLifeCycle() { return lifeCycle; } @Override public String toString() { return name; } }
现在假设有一组植物代表一个花园，想要列出这些由声明周期组织的植物(一年生、多年生、两年生)。
如下:普通程序的做法是构建三个集合，每个声明周期作为一个花园，并且从植物数组中筛选植物组成一个花园，筛选的时候根据ordinal()确定对应的花园。
import java.util.HashSet; import java.util.Set; public class Client { public static void main(String[] args) { // 3个数组 Set<Plant>[] plantsByLifeCycle = new Set[Plant.LifeCycle.values().length]; for (int i = 0; i < Plant.LifeCycle.values().length; i++) { plantsByLifeCycle[i] = new HashSet<>(); } Plant[] garden = { new Plant("西兰花", Plant.LifeCycle.PERENNIAL), new Plant("菊花", Plant.LifeCycle.ANNUAL), new Plant("木兰", Plant.LifeCycle.BIENNIAL), new Plant("菜兰", Plant.LifeCycle.PERENNIAL) }; for (Plant p : garden) { plantsByLifeCycle[p.lifeCycle.ordinal()].add(p); } for (int i = 0; i < plantsByLifeCycle.length; i++) { System.out.printf("%s: %s%n", Plant.LifeCycle.values()[i], plantsByLifeCycle[i]); } } }
结果：
ANNUAL: [菊花]
PERENNIAL: [西兰花, 菜兰]
BIENNIAL: [木兰]
这种做法可以实现，但是充满了问题，而且代码阅读起来比较费劲。
更好的办法是使用EnumMap：(如果按我的一开始的想法是HashMap<LifeStyle,Set<Plant>>)
import java.util.EnumMap; import java.util.HashSet; import java.util.Map; import java.util.Set; public class Client { public static void main(String[] args) { Plant[] garden = { new Plant("西兰花", Plant.LifeCycle.PERENNIAL), new Plant("菊花", Plant.LifeCycle.ANNUAL), new Plant("木兰", Plant.LifeCycle.BIENNIAL), new Plant("菜兰", Plant.LifeCycle.PERENNIAL) }; Map<Plant.LifeCycle, Set<Plant>> maps = new EnumMap<>(Plant.LifeCycle.class); for (Plant.LifeCycle lifeCycle : Plant.LifeCycle.values()) { maps.put(lifeCycle, new HashSet<>()); } for (Plant p : garden) { maps.get(p.lifeCycle).add(p); } System.out.println(maps); } }
结果:
{ANNUAL=[菊花], PERENNIAL=[菜兰, 西兰花], BIENNIAL=[木兰]}
38. 使用接口模拟可扩展的枚举
虽然不能编写可扩展的枚举类型，但是可以编写一个接口配合实现接口的基本的枚举类型来进行模拟。
比如一个运算例子:
public interface OperationInter { double operate(double num1, double num2); }
public enum BasicOperation implements OperationInter { PLUS(1) { @Override public double operate(double num1, double num2) { return num1 + num2; } }, MINUS(2) { @Override public double operate(double num1, double num2) { return num1 - num2; } }, TIMES(3) { @Override public double operate(double num1, double num2) { return num1 * num2; } }, DIVIDE(4) { @Override public double operate(double num1, double num2) { return num1 / num2; } }; private int index; private BasicOperation(int index) { this.index = index; } public int getIndex() { return index; } public void setIndex(int index) { this.index = index; } }
扩展接口:
public enum ExtendsOperation implements OperationInter { MOLE(5) { @Override public double operate(double num1, double num2) { return num1 % num2; } }; private int index; private ExtendsOperation(int index) { this.index = index; } public int getIndex() { return index; } public void setIndex(int index) { this.index = index; } }
39. 注解优于命名模式
40. 始终使用Override注解
这个注解只能使用在方法上面，它表明带此注解的方法声明重写了父类的声明。
如果在一个方法声明中使用该注解并且认为要重写父类声明，那么可以编译器可以保护免受很多错误的影响。但有一个例外，在具体类中，不需要注解标记你确信可以重写抽象方法声明的方法。
阿里规约也有一条:所有的覆写方法，必须加@Override 注解。
说明： getObject()与 get0bject()的问题。一个是字母的 O，一个是数字的 0，加@Override可以准确判断是否覆盖成功。另外，如果在抽象类中对方法签名进行修改，其实现类会马上编译报错。
41. 使用标记接口定义类型
标记接口不包含方法声明，只是指定(或标记)一个类实现了具有某些属性的接口。例如:Clonable、Serializable接口等。
Java 的序列化机制使用 Serializable 标记接口来指示某个类型是可序列化的。 对传递给它的对象进行序列化的 ObjectOutputStream.writeObject 方法要求其参数可序列化。 如果此方法的参数是Serializable 类型，在编译时会检测到序列化不适当对象的尝试（通过类型检查）。 编译时错误检测是标记接口的意图，但不幸的是， ObjectOutputStream.write API 没有利用 Serializable 接口：它的参数被声明为Object 类型，所以尝试序列化一个不可序列化的对象直到运行时才会失败
42. lambda表达式优于匿名类
lambda 没有名称和文档; 如果计算不是自解释的，或者超过几行，则不要将其放入 lambda表达式中。 一行代码对于 lambda 说是理想的，三行代码是合理的最大值。 如果违反这一规定，可能会严重损害程序的可读性。
对于逆序排序，匿名类如下:
public static void main(String[] args) { List<Integer> list = new ArrayList<>(); list.add(1); list.add(3); list.add(2); Collections.sort(list, new Comparator<Integer>() { @Override public int compare(Integer o1, Integer o2) { return Integer.compare(o2, o1); } }); }
使用lambda表达式如下:
public static void main(String[] args) { List<Integer> list = new ArrayList<>(); list.add(1); list.add(3); list.add(2); Collections.sort(list, (s1, s2) -> Integer.compare(s2, s1)); }
其参数s1和s2及其返回值类型int型，编译器会使用称为类型推断的过程从上下文推断出这些类型。
43. 方法引用优于lambda表达式
如果方法引用看起来更简短更清晰，就使用方法引用；否则使用lambda表达式。
通过方法引用来简写lambda表达式中已经存在的方法,这种特性就叫做方法引用(Method Reference)。比如我们用上面的:
public static void main(String[] args) { List<Integer> list = new ArrayList<>(); list.add(1); list.add(3); list.add(2); Collections.sort(list, Integer::compare); System.out.println(list); }
下面是五种方法引用:
44. 优先使用标准的函数式接口
