Java枚举和注解

30、 用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条中“如果不想定义类型就不要使用接口”的说法相反。本科目最接近的意思是说：“如果想要定义类型，一定要使用接口”。