疯狂java


您现在的位置: 疯狂软件 >> 新闻资讯 >> 正文

Java编程枚举和注解


 

 
   用enum代替int常量
 
枚举类型是指由一组固定的常量组成合法值的类型,例如一年中的季节或一副牌中的花色。在没引入枚举时,一般是声明一组int常量,每个类型成员一个常量:
public static final int APPLE_FUJI = 0;
public static final int APPLE_PIPPIN = 1;
public static final int APPLE_GRANNY_SMITH = 2;
public static final int ORANGE_NAVEL = 0;
public static final int ORANGE_TEMPLE = 1;
public static final int ORANGE_BLOOD = 2;
 
这种方法称作int枚举模式,存在很多不足,不具有类型安全与使用方便性。如果你将apple传到一个想要接收orange的方法中,编译器也不会出现警告,而且还可以使用==来比较apple与orange。
 
注意每个apple常量都以APPLE_作为前缀,每个orange常量都以ORANGE_作为前缀,这是因为可以防止名称冲突。
 
采用int枚举模式的程序是十分脆弱,因为int枚举是编译时常量,被编译到使用它们的客户端中。如果与枚举常量关联的int发生了变化,客户端就必须重新编译,如果不重新编译,程序还是可以运行,但不是最新的值了。
 
另外从使用方便性来看,没有便利的toString方法,打印出来的为数字,没有多大的用处。要遍历一组中所有的int枚举常量,也没有可靠的方法。
 
既然int枚举常量有这么多的缺点,那使用String枚举常如何?同样也不是我们期望的。虽然在可以打印字符串,但它会导致性能问题,因为它依赖于字符串的比较操作。另外与int枚举常量一样会编译到客户端代码中,编译时难以发现,但会在运行时出错。
 
幸运的是1.5版本开始,枚举可以避免int和String枚举模式的缺点,并提供许多额外的好处。下面是最简单的形式:
public enum Apple{FUJI,PIPPIN,GRANNY_SMITH}
public enum Orange{NAVEL,TEMPLE,BLOOD}
 
Java枚举类型背后的基本想法很简单:本质上是int值,它们是通过公有的静态final域为每个枚举常量导出实例的类。因为没有可以访问的构造器,枚举类型是真正的final。因为客户端即不能创建枚举类型的实例,也不能对它进行扩展,因此对它进行实例化,而只有声明过的枚举常量。换句话说,枚举类型是实例受控的。它们是单例的泛型化,本质上是单元素的枚举。
 
枚举提供了编译时类型安全。如果声明一个参数的类型为Apple,就可以保证,被传到该参数上的任何非null的对象引用一定属于三个有效的Apple值之一。试图传递类型错误的值时,会导致编译时错误,就像试图将某种枚举类型的表达式赋值给另一种枚举类型的变量,或者试图利用==操作符比较不同枚举类型的值一样,都会出错。
 
枚举提供了单独的命名空间,同一系统中可以有多个同名的枚举类型变量。你可以增加或者重新排序枚举类型常量,而无需重新编译它的客户端代码,因为导出常量的域在枚举类型和它的客户端之间提供了一个隔离层:常量值并没有被编译到客户端代码中,而是在int枚举模式之中。最终,可以通过调用toString方法,将枚举转换成可打印的字符串。
 
除了完善了int枚举模式不足外,枚举还允许添加任意的方法和域,并实例任意接口,它们提供了所有Object(见第3章)的高级实现,实现了Comparable和Serializable接口,并针对枚举型的可任意改变性设计了序列化方式。
 
如果一个枚举具有普遍适用性,它就应该成为一个顶层类,如果它只是被用在一个特定的顶层类中,它就应该成为该顶层类的一个成员类。
 
可以为枚举类型添加数据域与方法,下面是一个算术运行的枚举类:
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) {//构造函数,存储操作符供toString打印使用
              this.symbol = symbol;
       }
 
       @Override
       //重写Enum中的打印name的性为
       public String toString() {
              return symbol;
       }
 
       //抽像方法,不同的常量具有不同的功能,需在每个常量类的主体里重写它
       abstract double apply(double x, double y);
 
       /*
        *  初始化时,存储操作符与枚举常量的对应关系,用来实现 fromString 方法
        *  这样我们就可以通过 操作符来获取到对应的枚举常量,有点像valueOf方法,
        *  只不过它是通过枚举常量的名字name来获取常量的。这种通用的方法还可以
        *  应用到其他枚举类中
        */
       private static final Map<String, Operation> stringToEnum = new HashMap<String, Operation>();
       static { // 从name到枚举常量转换到从某个域到枚举常量的转换
              for (Operation op : values())
                     stringToEnum.put(op.toString(), op);
       }
 
       // 根据操作符来获取对应的枚举常量,如果没有返回null,模拟valueOf方法
       public static Operation fromString(String symbol) {
              return stringToEnum.get(symbol);
       }
 
       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));
 
              for (Operation op : Operation.values())
                     System.out.printf("%f %s %f = %f%n", x, op, y, Operation
                                   .fromString(op.toString()).apply(x, y));
       }
}
在opr包下会看见Operation.class、Operation$4.class、Operation$2.class、Operation$3.class 、Operation$1.class这样几个类,Operation$X.class都是继承自Operation类,而Operation又继承自Enum类,下面是反编译这些类的代码:
public abstract class opr.Operation extends java.lang.Enum{
    public static final opr.Operation PLUS;
    public static final opr.Operation MINUS;
    public static final opr.Operation TIMES;
    public static final opr.Operation DIVIDE;
    private final java.lang.String symbol;
    private static final java.util.Map stringToEnum;
    private static final opr.Operation[] ENUM$VALUES;
    static {};
    private opr.Operation(java.lang.String, int, java.lang.String);
    public java.lang.String toString();
    abstract double apply(double, double);
    public static opr.Operation fromString(java.lang.String);
    public static void main(java.lang.String[]);
    public static opr.Operation[] values();
    public static opr.Operation valueOf(java.lang.String);
    opr.Operation(java.lang.String, int, java.lang.String, opr.Operation);
}
class opr.Operation$1 extends opr.Operation{
    opr.Operation$1(java.lang.String, int, java.lang.String);
    double apply(double, double);
}
 
枚举构造器不可以访问枚举的静态域,除了编译时常量域之外,这一限制是有必要的,因为构造器运行的时候,这些静态域还没有被初始化。
 
枚举常量中的方法有一个美中不足的地方,它们使用在枚举常量中共享代码变得更加因难了。例如,考虑用一个枚举来实现星期中的工资数。算法是这样的,在五个工作日中,除正常的工作时间外,算加班;在双休日中,所有工作时数都算加班时间,下面是第一次简单的实现:
public enum PayrollDay {
       MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY;
       private static final int HOURS_PER_SHIFT = 8;//正常工作时数
 
       /**
        * 工资计算
        * @param hoursWorked 工作时间(小时)
        * @param payRate 每小时工资
        * @return
        */
       double pay(double hoursWorked, double payRate) {
              //基本工资,注这里使用的是double,真实应用中请不要使用
              double basePay = hoursWorked * payRate;
 
              double overtimePay;//加班工资,为正常工资的1.5倍
              switch (this) {
              case SATURDAY:
              case SUNDAY://双休日加班工资
                     overtimePay = hoursWorked * payRate / 2;
              default: //正常工作日加班工资
                     overtimePay = hoursWorked <= HOURS_PER_SHIFT ? 0
                                   : (hoursWorked - HOURS_PER_SHIFT) * payRate / 2;
                     break;
              }
              return basePay + overtimePay;//基本工资+加班工资
       }
}
不可否认,这段代码很简单,但是从维护来看,非常危险。假设将一个元素添加到枚举中,如一个假期的特殊值,但忘了给switch语句添加相应的case,这时会计算出错。
为了针对不同的常量有不同的安全计算工资法,你必须重复每个常量的加班工资,或者将计算移到两个辅助方法中(一个用来计算工作日,一个用来计算双休日),并从每个常量调用相应的辅助方法。这任何一种方法都会产生很多的重复的样板代码,第二次如下实现:
public enum PayrollDay {
       MONDAY() {
              @Override
              double overtimePay(double hoursWorked, double payRate) {
                     return weekdayPay(hoursWorked, payRate);
              }
       },
       TUESDAY {
              @Override
              double overtimePay(double hoursWorked, double payRate) {
                     return weekdayPay(hoursWorked, payRate);
              }
       },
       WEDNESDAY {
              @Override
              double overtimePay(double hoursWorked, double payRate) {
                     return weekdayPay(hoursWorked, payRate);
              }
       },
       THURSDAY {
              @Override
              double overtimePay(double hoursWorked, double payRate) {
                     return weekdayPay(hoursWorked, payRate);
              }
       },
       FRIDAY {
              @Override
              double overtimePay(double hoursWorked, double payRate) {
                     return weekdayPay(hoursWorked, payRate);
              }
       },
       SATURDAY {
              @Override
              double overtimePay(double hoursWorked, double payRate) {
                     return weekendPay(hoursWorked, payRate);
              }
       },
       SUNDAY {
              @Override
              double overtimePay(double hoursWorked, double payRate) {
                     return weekendPay(hoursWorked, payRate);
              }
       };
       private static final int HOURS_PER_SHIFT = 8;//正常工作时数
 
       //抽象出加班工资计算
       abstract double overtimePay(double hoursWorked, double payRate);
 
       //计算工资
       double pay(double hoursWorked, double payRate) {
              double basePay = hoursWorked * payRate;//公用
              return basePay + overtimePay(hoursWorked, payRate);
       }
 
       //双休日加班工资算法
       double weekendPay(double hoursWorked, double payRate) {
              return hoursWorked * payRate / 2;
       }
 
       //正常工作日加班工资
       double weekdayPay(double hoursWorked, double payRate) {
              return hoursWorked <= HOURS_PER_SHIFT ? 0
                            : (hoursWorked - HOURS_PER_SHIFT) * payRate / 2;
       }
}
上面设计中存在很多的样板代码,如正常工作日都是调用weekdayPay方法来完成的,而双休都是调用weekendPay来完成的,有没有一种可以减少这些重复样板代码呢?请看下面:
enum PayrollDay {
       MONDAY(PayType.WEEKDAY), TUESDAY(PayType.WEEKDAY), WEDNESDAY(
                     PayType.WEEKDAY), THURSDAY(PayType.WEEKDAY), FRIDAY(PayType.WEEKDAY), SATURDAY(
                     PayType.WEEKEND), SUNDAY(PayType.WEEKEND);
       private final PayType payType;//策略枚举类
 
       PayrollDay(PayType payType) {
              this.payType = payType;
       }
 
       double pay(double hoursWorked, double payRate) {
              //计算委托给策略类
              return payType.pay(hoursWorked, payRate);
       }
 
       // 嵌套的枚举策略类
       private enum PayType {
              WEEKDAY {//工作日枚举策略实例常量
                     double overtimePay(double hours, double payRate) {
                            return hours <= HOURS_PER_SHIFT ? 0 : (hours - HOURS_PER_SHIFT)
                                          * payRate / 2;
                     }
              },
              WEEKEND {//双休日枚举策略实例常量
                     double overtimePay(double hours, double payRate) {
                            return hours * payRate / 2;
                     }
              };
              private static final int HOURS_PER_SHIFT = 8;
 
              abstract double overtimePay(double hrs, double payRate);
 
              double pay(double hoursWorked, double payRate) {
                     double basePay = hoursWorked * payRate;
                     return basePay + overtimePay(hoursWorked, payRate);
              }
       }
}
虽然这种模式没有前面两种那么简单,便更加安全,也更加灵活。
 
从上面加班工资计算三种实现来看,如果多个枚举常量同时共享相同的行为时,则考虑策略枚举。
 
枚举适用于一组固定常量,当然枚举类型中的常量集并不一定要始终保持不变。
31、      不要使用ordinal,用实例域代替序数
 
永远不要根据枚举序数ordinal()导出与它关联的值,即不要依赖于枚举序数,否则重新排序这些枚举或添加新的常量,维护起来将是很困难的:
public enum Ensemble {
       SOLO, DUET, TRIO, QUARTET, QUINTET, SEXTET, SEPTET;
       public int numberOfMusicians() {
              return ordinal() + 1;
       }
}
我们要将它保存在一个实例域中:
public enum Ensemble {
       SOLO(1), DUET(2), TRIO(3), QUARTET(4), QUINTET(5), SEXTET(6), SEPTET(7);
       private final int numberOfMusicians;
 
       Ensemble(int size) {
              this.numberOfMusicians = size;
       }
 
       public int numberOfMusicians() {
              return numberOfMusicians;
       }
}
 
Enum规范中谈到ordinal时这么定道:“大多数程序员都不需要这个方法。它是设计成用于像EunmSet和EnumMap这种基于枚举的通用数据结构”,除非你在编写的是这种数据结构,否则最好完全避免使用ordinal方法。
32、      用EnumSet代替位域
 
如果一个枚举类型的元素主要用在集合(组合)中,一般就使用int枚举模式,做法是将1向左移位来实现,这样就会有很多的组合形式,下面是四种字体样式的应用,可以组合出 2^4 – 1 = 15种样式来:
class Text{
       public static final int STYLE_BOLD = 1 << 0;//1 字体加粗
       public static final int STYLE_ITALTC = 1 << 1;// 2 斜体
       public static final int STYLE_UNDERLINE = 1 << 2;//4 下划线
       public static final int STYLE_STRIKETHROUGH = 1 << 3;//8 删除线
     
       //应用样式
       public void applyStyles(int styles){
              //...
       }
       public static void main(String[] args) {
              //应用粗体与斜体组合样式
              new Text().applyStyles(STYLE_BOLD|STYLE_ITALTC);
       }
}
位域表示法允许利用位操作,有效地执行了像组合和交集这样的集合操作。但位域有着int枚举常量的所有缺点,甚至更多,如当位域以数字形式打印时,翻译位域比翻译简单的(单个的)枚举常要困难得多。那么有没有一种好的方案来代替上面的设计呢?使用EnumSet类来有效地表示从单个枚举类型中提取的多个值的多个集合。EnumSet内容都表示为位矢量,如果底层的枚举类型有64个或者更少的元素——大多如此——整个EnumSet就是用单个long来表示,因此它的性能比得上位域的性能。批处理,如removeAll和retainAll,都是利用位算法来实现的,就像手工替位域实现那样,但可以避免手工位操作时容易出现的错误以及复杂的代码。
 
下面是前一个实例改用枚举代替位域后的代码,它更加简短、清楚、安全:
public class Text {
       public enum Style {
              BOLD, ITALIC, UNDERLINE, STRIKETHROUGH
       }
 
       /*
        *  这里使用的Set接口而不是EnumSet类,最好还是使用接口
        *  类型而非实现类型,这样还可以传递一些其他的Set实现
        */
       public void applyStyles(Set<Style> styles) {
            
       }
 
       // Sample use
       public static void main(String[] args) {
              Text text = new Text();
              text.applyStyles(EnumSet.of(Style.BOLD, Style.ITALIC));
       }
}
 
总之,正是因为枚举类型可用在集合EnumSet中,所以没有理由用位域来表示它。EnumSet类集位域的简洁和性能优势及第30条中所述的枚举类型的所有优点于一身,用EnumSet代替位域就是理所当然的了。
33、      用EnumMap代替序数索引
 
EnumMap:与枚举类型键一起使用的专用 Map 实现。枚举映射中所有键都必须来自单个枚举类型,该枚举类型在创建映射时显式或隐式地指定。枚举映射在内部表示为数组。此表示形式非常紧凑且高效。
 
先来看一个能植物分类的实例,分类的标准是按照某枚举类型来分的:
public class Herb {
       // 植物各类:一年生、多年生、两年生
       static public enum Type {
              ANNUAL, PERENNIAL, BIENNIAL
       }
 
       private final String name;//植物名字
       private final Type type;//植物各类
 
       Herb(String name, Type type) {
              this.name = name;
              this.type = type;
       }
 
       @Override
       public String toString() {
              return name;
       }
 
       public static void main(String[] args) {
              //现有这样一些植物集合
              Herb[] garden = { new Herb("Basil", Type.ANNUAL),
                            new Herb("Carroway", Type.BIENNIAL),
                            new Herb("Dill", Type.ANNUAL),
                            new Herb("Lavendar", Type.PERENNIAL),
                            new Herb("Parsley", Type.BIENNIAL),
                            new Herb("Rosemary", Type.PERENNIAL) };
              //数组的索引与枚举Type对应 //问题一:需要进行未受检的转换
              Set<Herb>[] herbsByType = (Set<Herb>[]) new Set[Herb.Type.values().length];
              //初始化
              for (int i = 0; i < herbsByType.length; i++) {
                     herbsByType[i] = new HashSet<Herb>();
              }
              //开始分类操作
              for (Herb h : garden) {
                     //根据序数取出对应的容器再放入
                     herbsByType[h.type.ordinal()].add(h);
              }
 
              //输出
              for (int i = 0; i < herbsByType.length; i++) {
                     System.out//问题二:手工输出类别,还有可能引发数组越界
                                   .printf("%s: %s%n", Herb.Type.values()[i], herbsByType[i]);
              }
       }
}
输出:
ANNUAL: [Basil, Dill]
PERENNIAL: [Rosemary, Lavendar]
BIENNIAL: [Carroway, Parsley]
 
使用EnumMap对上面进行改进:
Herb[] garden =...
// 使用EnumMap并按照植物种类(枚举类型)来分类
Map<Herb.Type, Set<Herb>> herbsByType = new EnumMap<Herb.Type, Set<Herb>>(
              Herb.Type.class);
for (Herb.Type t : Herb.Type.values())//初始化
       herbsByType.put(t, new HashSet<Herb>());
for (Herb h : garden)//进行分类
       herbsByType.get(h.type).add(h);
System.out.println(herbsByType);//输出
 
EnumMap在内部使用数组实现,在性能上与数组相当。但是它对程序员隐藏了实现细节,集Map的丰富功能和类型安全与数组的快速于一身。
34、      用接口模拟可伸缩的枚举
 
枚举类型是不能被扩展的(继承),但使用接口可以解决这一问题,解决办法是让枚举类实现同一接口,在应用的地方以接口类型来传递参数,但这样会失去Enum类的某些特性:
// 枚举接口
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 symbol;
 
       BasicOperation(String symbol) {
              this.symbol = symbol;
       }
       @Override
       public String toString() {
              return symbol;
       }
}
//扩展运算
public enum ExtendedOperation implements Operation {
       EXP("^") {
              public double apply(double x, double y) {
                     return Math.pow(x, y);
              }
       },
       REMAINDER("%") {
              public double apply(double x, double y) {
                     return x % y;
              }
       };
       private final String symbol;
 
       ExtendedOperation(String symbol) {
              this.symbol = symbol;
       }
 
       @Override
       public String toString() {
              return symbol;
       }
}
测试:
private static <T extends Enum<T> & Operation> void test(Class<T> opSet,
              double x, double y) {
       for (Operation op : opSet.getEnumConstants())//失去Enum特性,使用反射
              System.out.printf("%f %s %f = %f%n", x, op, y, op.apply(x, y));
}
public static void main(String[] args) {
       double x = Double.parseDouble(args[0]);
       double y = Double.parseDouble(args[1]);
       test(BasicOperation.class, x, y);
       test(ExtendedOperation.class, x, y);
}
输出:
4.000000 + 2.000000 = 6.000000
4.000000 - 2.000000 = 2.000000
4.000000 * 2.000000 = 8.000000
4.000000 / 2.000000 = 2.000000
4.000000 ^ 2.000000 = 16.000000
4.000000 % 2.000000 = 0.000000
 
总之,虽然无法编写可扩展的枚举类型,却可以通过编写接口以及实现该接口的基础枚举类型,对它进行模拟。这样,客户端就能够编写自己的枚举来实现接口,如果API是根据接口编写的,那么在可以使用基础枚举类的地方,也都可以敷衍这些枚举。
35、      注解优先于命名模式
 
命名模式,表示有些程序元素需要通过某种工具或者框架进行特殊处理。例如,Junit框架原本要求它的用户一定要使用test作为测试方法名称的开头。
 
下面是一个简单的测试框架,使用注解来实现:
//专用于普通测试注解,该注解只适用于静态的无参方法,
//如果使用地方不正确由注解工具自己把握
@Retention(RetentionPolicy.RUNTIME)//注解信息保留到运行时,这样工具可以使用
@Target(ElementType.METHOD)//只适用于方法
public @interface Test {}
 
//专用于异常测试的注解
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface ExceptionTest {
       //测试方法可能抛出多个异常
       Class<? extends Exception>[] value();
}
下面应用上面定义的注解:
public class Sample {
       @Test
       public static void m1() {} // 测试应该通过
       public static void m2() {}
       @Test
       public static void m3() { // 测试应该失败
              throw new RuntimeException("Boom");
       }
       public static void m4() {}
       @Test//不应该使用在这里,但应该由注解工具自己处理这种不当的使用
       public void m5() {} // 错误使用: 非静态方法
       public static void m6() {}
       @Test
       public static void m7() { // 测试应该失败
              throw new RuntimeException("Crash");
       }
       public static void m8() {}
}
public class Sample2 {
       @ExceptionTest(ArithmeticException.class)
       public static void m1() { // 测试应该要通过,因为抛出了算术异常
              int i = 0;
              i = i / i;
       }
       @ExceptionTest(ArithmeticException.class)
       public static void m2() { // 测试应该不通过,因为抛出的异常为数组越界异常
              int[] a = new int[0];
              int i = a[1];
              System.out.println(i);
       }
       @ExceptionTest(ArithmeticException.class)
       public static void m3() {
       } // 测试应该不通过,因为没有抛也异常
 
       // 可能抛出多个异常,使用{}括起来,如果是单个可以省略
       @ExceptionTest( { IndexOutOfBoundsException.class,
                     NullPointerException.class })
       public static void doublyBad() {
              List<String> list = new ArrayList<String>();
              //这里会抛出空指针错误,测试应该会通过
              list.addAll(5, null);
       }
}
T注解对应用类的语义没有直接的影响。注解永远不会改变被注解代码的语义,但是使用它可以通过工具进行特殊的处理,如下面注解工具实现类:
public class RunTests {
       public static void main(String[] args) throws Exception {
              int tests = 0;//需要测试的数量
              int passed = 0;//测试通过的数量
              //加载被注解的类,即被测试的类
              Class<?> testClass = Class.forName(args[0]);
              //遍历测试类的所有方法
              for (Method m : testClass.getDeclaredMethods()) {
                   
                     //Test注解实现工具
                     if (m.isAnnotationPresent(Test.class)) {
                            tests++;
                            try {
                                   m.invoke(null);//没有参数,表示调用的是静态方法
                                   passed++;//如果方法调用成功则表示测试通过
                            }//表示测试方法本身抛出了异常
                            catch (InvocationTargetException wrappedExc) {
                                   Throwable exc = wrappedExc.getCause();
                                   //打印测试方法抛出的异常信息
                                   System.out.println(m + " failed: " + exc);
                            }//如果抛异常表示注解使用错误,不应使用在非静态或带参数的方式上 
                            catch (Exception exc) {
                                   //打印测试未通过的方法信息
                                   System.out.println("使用@Test注解错误的方法 : " + m);
                            }
                     }
                   
                     // ExceptionTest注解实现工具
                     if (m.isAnnotationPresent(ExceptionTest.class)) {
                            tests++;
                            try {
                                   m.invoke(null);
                                   //如果注解工具运行到这里,则测试方法未抛出异常,但属于测试未通过
                                   System.out.printf("Test %s failed: no exception%n", m);
                            } catch (Throwable wrappedExc) {
                                   //获取异常根源
                                   Throwable exc = wrappedExc.getCause();
                                   //取出注解的值
                                   Class<? extends Exception>[] excTypes = m.getAnnotation(
                                                 ExceptionTest.class).value();
                                   int oldPassed = passed;
                                   //将根源异常与注解值对比
                                   for (Class<? extends Exception> excType : excTypes) {
                                          //如果测试方法抛出的异常与注解中预期的异常匹配则表示测试通过
                                          if (excType.isInstance(exc)) {//使用动态的instance of
                                                 passed++;
                                                 break;
                                          }
                                   }
                                   //打印测试没有通过的方法信息
                                   if (passed == oldPassed)
                                          System.out.printf("Test %s failed: %s %n", m, exc);
                            }
                     }
              }
              //打印最终测试结果,通过了多少个,失败了多少个
              System.out.printf("Passed: %d, Failed: %d%n", passed, tests - passed);
       }
}
下面是两次运行输出结果(前面的为测试Sample类,后面是测试Sample1类):
public static void Item35.Sample.m3() failed: java.lang.RuntimeException: Boom
使用@Test注解错误的方法 : public void Item35.Sample.m5()
public static void Item35.Sample.m7() failed: java.lang.RuntimeException: Crash
Passed: 1, Failed: 3
 
Test public static void Item35.Sample2.m2() failed: java.lang.ArrayIndexOutOfBoundsException: 1
Test public static void Item35.Sample2.m3() failed: no exception
Passed: 2, Failed: 2
 
本条目中开发的测试框架只是一个试验,但它清楚地示范了注解优于命名模式,这只是揭开注解功能的冰山一角。如果在编写一个需要程序员给源文件添加信息的工具,就要定义一组适当的注解类型。另外,我们要考虑使用Java平台提供的预定义的标准注解类型(见第36条)。
36、      坚持使用Override注解
 
当你打算重写一个方法时,有可能写成重载,这时如果@Override注解就可以防止出现这个问题。
这个经典示例涉及equals方法,程序员可以编写如下代码:
public boolean equals (Foo that){…}
当你应当把他们编写成如下时:
public Boolean equals(Object that)
这也是合法的,但是类Foo从Object继承了equals实现,最终成了重载,而原本是重写的,这时我们可以使用@Override在重写的方法前,这样如果在没有重写的情况下,编译器则会提示我们。
 
注,@Override不能用在实现父接口中的方法前面,因为这叫实现不叫重写了,这与可以加在实现父抽象类中方法前是不一样的。
 
总之,如果在你想要的每个方法声明中使用Override注解来覆盖超类声明,编译器可以替你防止大量的错误,但有一个例外,在具体的类中,不必标注你确认覆盖了抽象方法声明的方法,虽然这么做也没有什么坏处。
37、      用标记接口定义类型
 
标记接口是没有包含方法声明的接口,而只是指明(或者“标明”)一个类实现了具有某种属性的接口。如,Serializable接口,通过实现这个接口,表明它的实例可以被写到ObjectOutputStream中(或者“被序列化”)。
 
标记注解,没有参数,只是“标注”被注解的元素,如果第 35 条的@Test就是一个标记注解。
 
标记注解并不能替代标记接口。标记接口有两点胜过标记注解。最重要的一点是,标记接口定义的类型是由被标记类的实例实现的;标记注解则没有定义这样的类型。标记接口在编译时就会被检测是否有错误,而标记注解则要到运行时期(但也并非如此,就Serializable标记接口而言,如果它的参数没有实现该接口,ObjectOutputStream.write(Object)方法将会失败,但令人不解的是,ObjectOutputStream API的创建者在声明Write方法时并没有利用Serializable接口,该方法的参数类型应该为Serializable而非Object,因此,试着在没有实现Serializable的对象上调用ObjectOutputStream.write,只会在运行时出错,所以也并不是像前面说的那样)。
 
HYPERLINK "mailto:如果你正在编写的是目标为@Target(ElementType.TYPE)" 如果你正在编写的是目标为@Target(ElementType.TYPE)的标记注解类型,就要考虑使用标记接口来实现呢。
 
总之,接口是用来定义类型的,而注解是用来辅助分析类元素信息的。
 
从某种意义上说,本条目与第19条中“如果不想定义类型就不要使用接口”的说法相反。本科目最接近的意思是说:“如果想要定义类型,一定要使用接口”。