开心一笑
提出问题
项目中如何使用枚举和注解???
解决问题
用enum替换int常量
例如:下面是公司项目的一个标准的enum实例。
package com.evada.de.common.enums;
/**
* 状态枚举
* @author Ay
*/
public enum StatusEnum {
/** 0：已删除 */
DELETED("0","已删除"),
/** 1：启用 */
ENABLE("1","启用"),
/** 2：禁用 */
DISABLE("2","禁用");
/** 状态值 */
private final String code;
private final String name;
private StatusEnum(String code, String name) {
this.code = code;
this.name = name;
}
@Override
public String toString() {
return code;
}
public String getName() {
return name;
}
}
注意，与枚举常量关联的行为，最好被实现成私有的或者包级私有的方法。
例如：
package com.evada.de;
/**
* Created by Ay on 2016/10/2.
*/
public enum Operation {
PLUS,MINUS,TIMES,DIVIDE;
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("Unknow op: " + this);
}
}
上面代码是很脆弱的，如果添加一种类型，却忘记给switch添加相应的条件，枚举仍然可以编译，但是当你试图运用新的运算时，就会运行失败。
修改过后的实例：
package com.evada.de;
/**
* Created by Ay on 2016/10/2.
*/
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;
Operation(String symbol){this.symbol = symbol;}
@Override
public String toString() { return this.symbol;}
abstract double apply(double x,double y);
}
下面看一个嵌套枚举实例：个人感觉这段代码很优雅，贴出来相互学习下：
如果多个枚举常量同时共享相同的行为，则考虑策略枚举(嵌套枚举)。
/**
* Created by Ay on 2016/10/2.
*/
public enum PayrollDay {
MonDAY(PayType.WEEKDAY),
WEEKDAY(PayType.WEEKDAY),
TUESDAY(PayType.WEEKDAY),
WENDESDAY(PayType.WEEKDAY),
THURSDAY(PayType.WEEKDAY),
FRIDAY(PayType.WEEKDAY),
SATURDAY(PayType.WEEKEND),
SUNDAY(PayType.WEEKEND);
private PayType payType;
PayrollDay(PayType payType){ this.payType = payType;}
double pay(double hoursWorked,double payRate){
return payType.pay(hoursWorked,payRate);
}
//这里是嵌套枚举
private enum PayType{
WEEKDAY{
@Override
double overtimePay(double hrs, double payRate) {
return 0;
}
},WEEKEND{
@Override
double overtimePay(double hrs, double payRate) {
return 0;
}
};
private static final int HOURS_PRE_SHIFT = 8;
abstract double overtimePay(double hrs,double payRate);
double pay(double hoursWorked,double payRate){
double basePay = hoursWorked * payRate;
return basePay + overtimePay(hoursWorked,payRate);
}
}
}
枚举有个小小的性能缺点，即装载和初始化枚举时会有空间和时间成本。
总而言之，与int常量相比，枚举类型的优势是不可言喻的。枚举要易读得多，也更加安全，功能更加强大。
用实例域替换序数
例如：
enum Ensemble{
SOLO,DUET,TRIO,QUARTET,QUINTET,SEXTET,SEPTEX,OCTEX,NONET,DECTET;
public int numberOfMusicians(){
return ordinal() + 1;//ordinal()用来返回枚举常量在类型中的数字位置。
}
}
永远不要根据枚举的序数导出与它关联的值，而是要将它保存在一个实例域中：
正确做法是：
enum Ensemble{
SOLO(1),DUET(2),TRIO(3),QUARTET(4),QUINTET(5),
SEXTET(6),SEPTEX(7),OCTEX(8),NONET(9),DECTET(10);
private final int numberOfMusicians;
Ensemble(int size){
this.numberOfMusicians = size;
}
public int numberOfMusicians(){
return ordinal() + 1;
}
}
Enum规范中写道：大多数程序员都不需要这个方法。除非你在编写的是这种数据结构，否则最好避免使用original方法。
用EnumSet代替位域
用OR位运算，将几个常量合并到一个集合中，称为位域。
class Text{
public static final int STYLE_BOLE = 1 << 0;
public static final int STYLE_ITALIC = 1 <<1;
public static final int STYLE_UNDERLINE = 1 <<2;
public static final int STYLE_STRIKETHROUGH = 1 <<3;
public void applyStyles(int styles){ ... }
}
将前一个范例改为用枚举代替位域后的代码为：
class Text{
public enum Style{BOLE,ITALIC,UNDERLINE,STRIKETHROUGH}
public void applyStyles(Set<Style> styles){}
}
总而言之，正是因为枚举类型要用在集合中，所以没有理由用位域来表示它。
用EnumMap代替序数索引
说白了，就是类似于key和value形式，具体可以看《Effective Java》的具体实例。
总而言之，最好不要用序数来索引数组，而要使用EnumMap。如果你所表示的这种关系是多维的，就使用EnumMap<...,EnumMap<...>>。运用程序的程序员在一般情况下都不使用Enum.oridinal,即使要用也很少，因此这是一种特殊情况。
用接口模拟可伸缩的枚举
例如：
public interface Operation{
double apply(double x,double y);
}
public enum BasicOperation implements Operation{
PLUS("+"){
public double apply(double x,double y){ return x + y;}
},
MINUS("-"){
public double apply(double x,double y){ return x - y;}
},
TIMES("*"){
public double apply(double x,double y){ return x * y;}
},
DIVIDE("/"){
public double apply(double x,double y){ return x / y;}
};
private final String symbool;
BasicOperation(String symbool){ this.symbool = symbool}
@Override
public String toString() {
return symbool;
}
@Override
public double apply(double x, double y) {
return 0;
}
}
上面例子有很好的扩展性，假设你想要定义一个上述操作类型的扩展，由求幂和求余操作组成，你需要做的就是编写一个枚举类型，让它实现Operation接口：
public interface Operation{
double apply(double x,double y);
}
public enum BasicOperation implements Operation{
PLUS("^"){
public double apply(double x,double y){ return Math.pow(x,y);}
},
MINUS("%"){
public double apply(double x,double y){ return x % y;}
};
private final String symbool;
BasicOperation(String symbool){ this.symbool = symbool}
@Override
public String toString() {
return symbool;
}
@Override
public double apply(double x, double y) {
return 0;
}
}
总而言之，虽然无法编写可扩展的枚举类型，却可以通过编写接口以及实现该接口的基础枚举类型，对它进行模拟。这样允许客户端编写自己的枚举来实现接口。如果API是根据接口编写的，那么在可以使用基础枚举类型的任何地方，也都可以使用这些枚举。
注解优先于命名模式
命名模式：表明有些程序元素需要通过某种工具或者框架进行特殊处理。例如，Junit测试框架原本要求它的用户一定要用test作为测试方法名称的开头。
例如：
@Test
public void testLove(){
System.out.println("I love you!!!");
}
总而言之,使用注解而不是命名模式
坚持使用Override注解
@Override只能用在方法声明中，它表示被注解的方法声明覆盖了超类型中的一个声明。如果坚持使用这个注解，可以防止一大类的非法错误。
在你想要覆盖超类声明的每个方法声明中使用Override注解。
总而言之，如果在你想要的每个方法声明中使用Override注解来覆盖超类声明，编译器就可以防止大量的错误，但有一个例外。在具体的类中，不必标注你确信覆盖了抽象方法声明的方法。
用标记接口定义类型
标记接口：是没有包含方法声明的接口，而只是指明一个类实现了具有某种属性的接口。例如：Serializable.
标记接口胜过标记注解:标记接口定义的类型是由被标记类的实例实现的；标记注解则没有定义这样的类型。
标记注解胜过标记接口：它可以通过默认的方式添加一个或者多个注解类型的元素，给已被使用的注解类型添加更多的信息。
那么该如何选择？
如果标记是运用到任何程序元素而不是类或者接口，就必须使用注解，因为只有类和接口可以用来实现或者扩展接口。如果标记只运用给类和接口，就要问问自己：我要编写一个还是多个只接受有这种标记的方法？如果是这种情况，就应该优先使用标记接口而非注解。这样你就可以用接口作为相关方法的参数类型，它真正可以为你提供编译时进行类型检查的好处。
读书感悟
来自亦舒《流金岁月》
- 无论做什么，记得为自己而做，那就毫无怨言。
- 那种难得的朋友。我成功，她不嫉妒。我委靡，她不轻视。人生得一知己足矣。
- 快乐是要去寻找的，很少有天生幸福的人。
- 你看得起你自己就好，管谁看不起你，肯帮固然好，不帮拉倒。
- 气质，读书的唯一的用途是增加气质。世上确有气质这回事。
其他
如果有带给你一丝丝小快乐，就让快乐继续传递下去，欢迎转载，点赞，顶，欢迎留下宝贵的意见，多谢支持！
