34. 使用枚举类型替代整型常量
常量的语义表达不清晰，只能靠前面的名称来区分。枚举具有可读性、更安全、更强大等优势。而且枚举类型对象之间的值比较可以使用==来比较值是否相等的，不是必须使用equals方法。
要将数据与枚举常量相关联，首先需要声明实例属性并编写一个构造方法，构造方法带有数据并将数据保存在属性中。枚举本质上是不变的，所有的属性都应设为final。
如下:
一个原始的常量类保存int值:
public classConstants {public static final int APPLE_FUJT = 1;public static final int APPLE_PIPPIN = 2;public static final int APPLE_other = 3;
}
改装为枚举类型后的类如下:
public enumApples {
APPLE_FUJT(1), APPLE_PIPPIN(2), APPLE_other(3);final intnumber;private Apples(intnumber) {this.number =number;
}
}
测试代码:
public classClient {public static voidmain(String[] args) {
System.out.println(Constants.APPLE_FUJT);
System.out.println(Apples.APPLE_FUJT.number);
}
}
JDK中的枚举类型代替整形的例子:RoundingMode类和BigDecimal紧密关联
public enumRoundingMode {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 intoldMode;
private RoundingMode(intoldMode) {this.oldMode =oldMode;
}
public static RoundingMode valueOf(intrm) {switch(rm) {caseBigDecimal.ROUND_UP:returnUP;caseBigDecimal.ROUND_DOWN:returnDOWN;caseBigDecimal.ROUND_CEILING:returnCEILING;caseBigDecimal.ROUND_FLOOR:returnFLOOR;caseBigDecimal.ROUND_HALF_UP:returnHALF_UP;caseBigDecimal.ROUND_HALF_DOWN:returnHALF_DOWN;caseBigDecimal.ROUND_HALF_EVEN:returnHALF_EVEN;caseBigDecimal.ROUND_UNNECESSARY:returnUNNECESSARY;default:throw new IllegalArgumentException("argument out of range");
}
}
}
BigDecimal中设置scale:
public BigDecimal setScale(intnewScale, RoundingMode roundingMode) {returnsetScale(newScale, roundingMode.oldMode);
}
35. 使用实例属性代替序数
也就是说枚举类的ordinal()方法返回的序号尽量不要使用。ordinal方法返回枚举常量的序数(它在枚举声明中的位置，其中初始常量序数为零)。
public classClient {public static voidmain(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 enumOperation {
PLUS(1) {
@Overridedouble operate(double num1, doublenum2) {return num1 +num2;
}
},
MINUS(2) {
@Overridedouble operate(double num1, doublenum2) {return num1 -num2;
}
},
TIMES(3) {
@Overridedouble operate(double num1, doublenum2) {return num1 *num2;
}
},
DIVIDE(4) {
@Overridedouble operate(double num1, doublenum2) {return num1 /num2;
}
};private intindex;private Operation(intindex) {this.index =index;
}abstract double operate(double num1, doublenum2);public intgetIndex() {returnindex;
}public void setIndex(intindex) {this.index =index;
}
}
测试代码:
public classClient {public static voidmain(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 voidmain(String[] args) {
eatFruits(Constants.APPLE_FUJT|Constants.APPLE_PIPPIN);}static void eatFruits(intfruit) {
System.out.println(fruit);
}
我们在eatFruits知道参数是3，所以知道是1和2.
public static voidmain(String[] args) {
EnumSet enumSets =EnumSet.of(Apples.APPLE_FUJT, Apples.APPLE_PIPPIN);
eatFruits(enumSets);
}static voideatFruits(Set fruit) {
System.out.println(fruit);
}
结果:
[APPLE_FUJT, APPLE_PIPPIN]
37. 使用EnumMap替代序数索引
使用序数来索引数组很不合适，改用EnumMap。如果代表的关系是多维的，用EnumMap<...>>。程序员应该很少用Enum.ordinal。
如下植物类:
/*** 植物类
*
*@authorAdministrator
**/
public classPlant {enumLifeCycle {//1年生, 永久, 两年生
ANNUAL, PERENNIAL, BIENNIAL;
}finalString name;finalLifeCycle lifeCycle;publicPlant(String name, LifeCycle lifeCycle) {super();this.name =name;this.lifeCycle =lifeCycle;
}publicString getName() {returnname;
}publicLifeCycle getLifeCycle() {returnlifeCycle;
}
@OverridepublicString toString() {returnname;
}
}
现在假设有一组植物代表一个花园，想要列出这些由声明周期组织的植物(一年生、多年生、两年生)。
如下:普通程序的做法是构建三个集合，每个声明周期作为一个花园，并且从植物数组中筛选植物组成一个花园，筛选的时候根据ordinal()确定对应的花园。
importjava.util.HashSet;importjava.util.Set;public classClient {public static voidmain(String[] args) {//3个数组
Set[] plantsByLifeCycle = newSet[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>)
importjava.util.EnumMap;importjava.util.HashSet;importjava.util.Map;importjava.util.Set;public classClient {public static voidmain(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> 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 interfaceOperationInter {double operate(double num1, doublenum2);
}
public enum BasicOperation implementsOperationInter {
PLUS(1) {
@Overridepublic double operate(double num1, doublenum2) {return num1 +num2;
}
},
MINUS(2) {
@Overridepublic double operate(double num1, doublenum2) {return num1 -num2;
}
},
TIMES(3) {
@Overridepublic double operate(double num1, doublenum2) {return num1 *num2;
}
},
DIVIDE(4) {
@Overridepublic double operate(double num1, doublenum2) {return num1 /num2;
}
};private intindex;private BasicOperation(intindex) {this.index =index;
}public intgetIndex() {returnindex;
}public void setIndex(intindex) {this.index =index;
}
}
扩展接口:
public enum ExtendsOperation implementsOperationInter {
MOLE(5) {
@Overridepublic double operate(double num1, doublenum2) {return num1 %num2;
}
};private intindex;private ExtendsOperation(intindex) {this.index =index;
}public intgetIndex() {returnindex;
}public void setIndex(intindex) {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 voidmain(String[] args) {
List list = new ArrayList<>();
list.add(1);
list.add(3);
list.add(2);
Collections.sort(list,new Comparator() {
@Overridepublic intcompare(Integer o1, Integer o2) {returnInteger.compare(o2, o1);
}
});
}
使用lambda表达式如下:
public static voidmain(String[] args) {
List 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 voidmain(String[] args) {
List list = new ArrayList<>();
list.add(1);
list.add(3);
list.add(2);
Collections.sort(list, Integer::compare);
System.out.println(list);
}
下面是五种方法引用:
44. 优先使用标准的函数式接口
1356
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
