Effective Java 学习笔记

枚举中的switch语句适合于给外部的枚举类型增加特定于常量的行为.

    public static Operation inverse(Operation op) {
        switch (op) {
            case PLUS:
                return Operation.MINUS;
            case MINUS:
                return Operation.PLUS;
            case TIMES:
                return Operation.DIVIDE;
            case DIVIDE:
                return Operation.TIMES;
            default:
                throw new AssertionError("Unknown op: " + op);
        }
    }

什么时候使用枚举类型?

每当需要一组固定常量, 并且在编译时就知道其成员的时候, 就应该使用枚举, 枚举类型中的常量集并不一定要始终保持不变.

35.用实例域代替序数

许多枚举天生和一个单独的int值相关 所有的枚举都有一个ordinal方法, 返回每个枚举常量在类型中的数字位置:

public enum Ensemble {
    SOLO, DUET, TRIO, QUARTET, QUINTET,
    SEXTET, SEPTET, OCTET, NONET, DECTET;
    
    public int numberOfMusicians() {
        return ordinal() + 1;
    }
}

上诉代码, 如果常量重新排序, 则numberOfMusicians方法就会遭到破坏. 如果要再添加一个与已经用过的int值关联的枚举常量, 那是做不到的.要是没有给所有的这些int值添加常量, 也无法给某个int值添加常量.(对于11位演奏家组成的合奏曲没有标准的术语, 因此只好给没用过的int值11添加一个虚拟dummy常量)

有很简单的方法解决: 永远不要根据枚举的序数导出与它相关联的值, 而是要将它保存在一个实例域中:

public enum Ensemble {
    SOLO(1), DUET(2), TRIO(3), QUARTET(4), QUINTET(5),
    SEXTET(6), SEPTET(7), OCTET(8), NONET(9), DECTET(10),
    DOUBLE_QUARTET(8), TRIPLE_QUARTET(12),
    ;
    
    private final int numberOfMusicians;
    
    Ensemble(int size) {
        this.numberOfMusicians = size;
    }
    
    public int numberOfMusicians() {
        return this.numberOfMusicians;
    }
}

36.用EnumSet代替位域

如果一个枚举类型的元素主要用在集合中, 一般使用int枚举模式.

public class Text {

    public static final int STYLE_BOLD = 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) {

    }


}

这种表示法可用OR运算符将几个常量合并到一个集合中, 称作位域(bit field). 位域表示法允许使用位操作, 有效地执行union(联合) 和 intersection(交集) 这样的集合操作.

public static void main(String[] args) {
    Text text = new Text();
    text.applyStyles(STYLE_BOLD | STYLE_ITALIC);
}

位域的缺点:

1. 当位域以数字形式打印时, 翻译位域比翻译简单的int枚举常量要困难.
2. 遍历位域表示的所有元素没有很容易的方法.
3. 编写API时, 就必须先预测最多需要多少位, 同时还要给位域选择对应的类型(int或long), 一旦选好类型, 在没有改变API的情况下, 将不能超出其位宽度(int32位, long64位).

可使用EnumSet类来有效地表示从单个枚举类型中提取的多个值的多个集合.优点:

1. 该类实现Set接口, 提供了丰富的功能, 类型安全性, 以及可用从任何其他Set实现中得到的互用性.
2. 内部实现上, 每个EnumSet内部都表示为位矢量.
3. 如果底层的枚举类型有64个或更少的元素, 整个EnumSet使用单个long表示, 性能比得上位域.
4. 批处理操作, removeAll和retainAll都是利用位算法来实现的, 可避免手工位操作是容易出现的错误和丑陋的代码.

public class Text {

    public enum Style {BOLD, ITALIC, UNDERLINE, STRIKETHROUGH}
    
    public void applyStyles(Set<Style> styles) {}
    
    public static void main(String[] args) {
        Text text = new Text();
        text.applyStyles(EnumSet.of(Style.BOLD, Style.ITALIC));
    }
}

37.用EnumMap代替序数索引

有时会利用ordinal方法来索引数组或列表的代码.

public class Plant {
    enum LifeCycle {
        // 每年
        ANNUAL,
        // 多年的
        PERENNIAL,
        // 两年一次的
        BIENNIAL
    }

    private final String name;

    private final LifeCycle lifeCycle;

    public Plant(String name, LifeCycle lifeCycle) {
        this.name = name;
        this.lifeCycle = lifeCycle;
    }

    @Override
    public String toString() {
        return name;
    }
}

现在假设有一个香草的数组, 表示一座花园中的植物, 你想按照类型(LifeCycle)进行组织之后将这些植物列出来, 需要构建三个集合, 每种类型各一个, 并遍历整座花园, 将每种香草放到相应的集合中, 有些会将这些集合放到一个按照类型的序数进行索引的数组中来实现:

    public static void main(String[] args) {
        Set<Plant>[] plantsByLifeCycle = (Set<Plant>[]) new Set[Plant.LifeCycle.values().length];
        for (int i = 0; i < plantsByLifeCycle.length; i++) {
            plantsByLifeCycle[i] = new HashSet<>();
        }

        Plant[] garden = new Plant[3];
        garden[0] = new Plant("玫瑰", LifeCycle.ANNUAL);
        garden[1] = new Plant("康乃馨", LifeCycle.PERENNIAL);
        garden[2] = new Plant("菊花", LifeCycle.BIENNIAL);

        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]);
        }
    }

上诉代码的问题:

1. 数组不能与泛型兼容, 程序需要进行未受检的转换, 并不能正确无误地进行编译.
2. 因为数组不知道它的索引代表着什么, 必须手工标注这些索引的输出.
3. 当你访问一个按照枚举的序数进行索引的数组是, 使用正确的int值是你的职责, int不能提供枚举的类型安全.有可能会抛出ArrayIndexOutOfBoundException异常.

使用EnumMap改写后的程序:

    public static void main(String[] args) {
        Plant[] garden = new Plant[3];
        garden[0] = new Plant("玫瑰", LifeCycle.ANNUAL);
        garden[1] = new Plant("康乃馨", LifeCycle.PERENNIAL);
        garden[2] = new Plant("菊花", LifeCycle.BIENNIAL);
        // 这里EnumMap的构造器是采用键类型的Class对象, 提供了运行时的泛型信息.
        Map<LifeCycle, Set<Plant>> plantsByLifeCycle = new EnumMap<>(LifeCycle.class);
        for (LifeCycle lc : LifeCycle.values()) {
            plantsByLifeCycle.put(lc, new HashSet<>());
        }

        for (Plant plant : garden) {
            plantsByLifeCycle.get(plant.lifeCycle).add(plant);
        }
        System.out.println(plantsByLifeCycle);
    }

使用EnumMap的优点:

1. 程序更简短, 更清楚, 更加类型安全, 没有不安全的转换.
2. 运行速度可用和使用序数的程序相媲美.因为内部实现使用了数组.
3. 不必手工标注这些索引的输出, 因为映射键知道如何将自身翻译成可打印字符串的枚举.
4. 计算数组索引时也不可能出错.

基于Stream的代码:

System.out.println(Arrays.stream(garden).collect(Collectors.groupingBy(p -> p.lifeCycle)));

上诉代码的问题在于映射的实现不是一个EnumMap, 需使用有三种参数形式的Collectors.groupingBy方法, 它允许利用mapFactory参数定义映射实现:

System.out.println(Arrays.stream(garden).collect(Collectors.groupingBy(p -> p.lifeCycle,
                () -> new EnumMap<>(LifeCycle.class), toSet())));

基于Stream版本的行为和EnumMap的版本稍有不同, EnumMap的版本总是给每一个植物生命周期都设计一个嵌套映射, 基于Stream版本则仅当花园中包含了一种或多种植物带有该生命周期时才会设计一个嵌套映射.比如花园中没有两年生植物, plantsByLifeCycle在EnumMap的版本中的数量是3中, 而在基于Stream版本中都是两种.

        Plant[] garden = new Plant[2];
        garden[0] = new Plant("玫瑰", LifeCycle.ANNUAL);
        garden[1] = new Plant("康乃馨", LifeCycle.PERENNIAL);

        Map<LifeCycle, Set<Plant>> plantsByLifeCycle = new EnumMap<>(LifeCycle.class);
        for (LifeCycle lc : LifeCycle.values()) {
            plantsByLifeCycle.put(lc, new HashSet<>());
        }

        for (Plant plant : garden) {
            plantsByLifeCycle.get(plant.lifeCycle).add(plant);
        }
        System.out.println(plantsByLifeCycle);

        System.out.println(Arrays.stream(garden).collect(Collectors.groupingBy(p -> p.lifeCycle,
                () -> new EnumMap<>(LifeCycle.class), toSet())));

// 打印结果
{ANNUAL=[玫瑰], PERENNIAL=[康乃馨], BIENNIAL=[]}
{ANNUAL=[玫瑰], PERENNIAL=[康乃馨]}

按照序数进行索引两次的数组的数组例子:

public enum Phase {
    // 固体 液体 气体
    SOLID, LIQUID, GAS;

    // 过渡
    public enum Transition {
        // 熔化 冷冻 沸腾 浓缩 升华 沉淀
        MELT, FREEZE, BOIL, CONDENSE, SUBLIME, DEPOSIT;

        private static final Transition[][] TRANSITIONS = {
                {null, MELT, SUBLIME},
                {FREEZE, null, BOIL},
                {DEPOSIT, CONDENSE, null},
        };

        public static Transition from(Phase from, Phase to) {
            return TRANSITIONS[from.ordinal()][to.ordinal()];
        }
    }
}

上诉代码的问题:

1. 编译器无法知道序数和数组索引之间的关系
2. 如果在TRANSITIONS中出了错, 或在修改Phase或Transition枚举类型的时候忘记更新, 程序会在运行时失败.
3. 这张TRANSITIONS的大小是阶段数的平方, 即使非空项的数量比较少.

使用EnumMap改造, 因为每个过渡阶段都是通过一对阶段枚举进行索引的, 最好将这种关系表示为一个映射, 这个映射的键是一个枚举(起始阶段), 值为另一个映射, 第二个映射的键为第二个枚举(目标阶段), 它的值为结果(阶段过渡), 即Map(起始阶段, Map(目标阶段, 阶段过渡))这种形式, 一个阶段过渡所关联的两个阶段, 最好通过数据与阶段过渡枚举之间的关系来获取, 之后用该阶段过渡枚举初始化EnumMap:

public enum Phase {
    // 固体 液体 气体
    SOLID, LIQUID, GAS;

    // 过渡
    public enum Transition {
        // 熔化 冷冻 沸腾 浓缩 升华 沉淀
        MELT(SOLID, LIQUID), FREEZE(LIQUID, SOLID),
        BOIL(LIQUID, GAS), CONDENSE(GAS, LIQUID),
        SUBLIME(SOLID, GAS), DEPOSIT(GAS, SOLID);

        private final Phase from;

        private final Phase to;

        Transition(Phase from, Phase to) {
            this.from = from;
            this.to = to;
        }

        private static final Map<Phase, Map<Phase, Transition>> M = Stream.of(values())
                .collect(Collectors.groupingBy(t -> t.from,
                        () -> new EnumMap<>(Phase.class),
                        Collectors.toMap(t -> t.to, t -> t,
                                (x, y) -> y, () -> new EnumMap<>(Phase.class))));

        public static Transition from(Phase from, Phase to) {
            return M.get(from).get(to);
        }
    }
}

如果要添加一个新阶段: plasma(离子), 只有两个过渡和这个阶段相关,: 电离化(ionization)将气体变成离子, 消电离化(deionization)将离子变成气体. 必须给Phase添加一种新常量, 给Phase.Transition添加两种新常量. 如果是基于数组的版本, 给数组添加的元素过多或过少, 或者元素位置放置不妥当, 程序会运行失败; 如果是基于EnumMap的版本, 只需将PLASMA添加到Phase列表, 并将IONIZE(GAS, PLASMA)和DEIONIZE(PLASMA, GAS)添加到Phase.Transition中, 程序会自行处理其他的事情, 几乎没有出错的可能:

public enum Phase {
    // 固体 液体 气体 电离
    SOLID, LIQUID, GAS, PLASMA;

    // 过渡
    public enum Transition {
        // 熔化 冷冻 沸腾 浓缩 升华 沉淀
        MELT(SOLID, LIQUID), FREEZE(LIQUID, SOLID),
        BOIL(LIQUID, GAS), CONDENSE(GAS, LIQUID),
        SUBLIME(SOLID, GAS), DEPOSIT(GAS, SOLID),
        IONIZE(GAS, PLASMA), DEIONIZE(PLASMA, GAS);

        private final Phase from;

        private final Phase to;

        Transition(Phase from, Phase to) {
            this.from = from;
            this.to = to;
        }

        private static final Map<Phase, Map<Phase, Transition>> M = Stream.of(values())
                .collect(Collectors.groupingBy(t -> t.from,
                        () -> new EnumMap<>(Phase.class),
                        Collectors.toMap(t -> t.to, t -> t,
                                (x, y) -> y, () -> new EnumMap<>(Phase.class))));

        public static Transition from(Phase from, Phase to) {
            return M.get(from).get(to);
        }
    }
}

38.用接口模拟可扩展的枚举

可伸缩的枚举类型用例: 操作码(operation code), 也作opcode, 它的元素表示在某种机器上的那些操作.有时要尽可能地让API的用户提供它们自己的操作, 这样可以有效地扩展API所提供的操作集.

枚举类型可以通过给操作码类型和枚举定义接口来实现上诉效果:

public interface Operation {
    double apply(double x, double y);
}

public enum BasicOperation implements Operation {

    PLUS("+") {
        @Override
        public double apply(double x, double y) {
            return x + y;
        }
    },

    MINUS("-") {
        @Override
        public double apply(double x, double y) {
            return x - y;
        }
    },

    TIMES("*") {
        @Override
        public double apply(double x, double y) {
            return x * y;
        }
    },

    DIVIDE("/") {
        @Override
        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;
    }
}

虽然枚举类型BasicOperation是不可扩展的, 但接口类型Operation却是可扩展的, 你可以定义另一个枚举类型, 实现这个接口, 并利用这个新类型的实例代替基本类型. 比如, 你要定义上述操作类型的扩展, 由求幂(exponentiation)和求余(remainder)操作组成:

public enum ExtendedOperation implements Operation {

    EXP("^") {
        @Override
        public double apply(double x, double y) {
            return Math.pow(x, y);
        }
    },

    REMAINDER("%") {
        @Override
        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;
    }
}

这样在可以使用基础操作的地方, 都可以使用新的操作, 只要API是写成采用接口类型Operation而非实现BasicOperation.

不仅可以在任何需要基本枚举的地方单独传递一个扩展枚举的实例, 而且可以传递完整的扩展枚举类型, 并使用它的元素:

第一种方法:

    public static void main(String[] args) {
        double x = Double.parseDouble(args[0]);
        double y = Double.parseDouble(args[1]);
        test(ExtendedOperation.class, x, y);
    }
// T extends Enum<T> & Operation 确保了Class对象既表示枚举又表示Operation的子类型
    private static <T extends Enum<T> & Operation> void test(Class<T> opEnumType, double x, double y) {
        for (Operation op : opEnumType.getEnumConstants()) {
            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(Arrays.asList(ExtendedOperation.values()), x, y);
    }

    private static void test(Collection<? extends Operation> opSet, double x, double y) {
        for (Operation op : opSet) {
            System.out.printf("%f %s %f = %f%n", x, op, y, op.apply(x, y));
        }
    }

有个小小的不足: 无法将实现从一个枚举类型继承到另一个枚举类型. 如果实现代码不依赖于任何状态, 可将缺省实现放在接口中.如果共享的功能比较多, 则可以将它封装在一个辅助类或静态辅助方法中.

39.注解优先于命名模式

命名模式(naming pattern, 使用方法或类的名称来进行某些特殊处理)的缺点:

1. 文字拼写错误会导致失败, 且没有任何提示.
2. 无法确保它们只用于相应的程序元素上.
3. 没有提供将参数值与程序元素关联起来的好方法.

注解很好地解决了这些问题. 定义一个注解类型来指定简单的测试, 它们自动运行, 并在抛出异常时失败:

// 只用于无参的静态方法
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Test {
}

Test注解声明通过Retention和Target注解进行了注解. 注解类型声明中的这种注解成为元注解(meta-annotation).@Retention(RetentionPolicy.RUNTIME)表明Test注解在运行时也应该存在, @Target(ElementType.METHOD)表明Test注解只在方法声明中才是合法的, 不能应用到类声明, 域声明或其他程序元素上.

Test注解上的注释, 如果编译器能强制这一限制最好, 如果做不到, 除非编写一个注解处理器(annotation processor), 让它来完成. 如果没有注解处理器, 如果将Test注解放在实例方法的声明中, 或者放在带有一个或多个参数的方法中, 测试程序还是可以编译, 让测试工具在运行时来处理这个问题.

现实应用中的Test注解, 称作标记注解(marker annotation), 因为它没有参数, 只是标注被注解的元素.如果程序拼错了Test或将Test注解应用到其他程序元素而非方法声明, 程序就无法编译.

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() {

    }
}

Test注解对Sample类的语义没有直接的影响, 注解只负责提供信息供相关程序使用, 注解永远不会改变被注解代码的语义, 但是使它可以通过工具提供进行特殊的处理:

public class RunTests {
    public static void main(String[] args) throws Exception {
        int tests = 0;
        int passed = 0;
        Class<?> testClass = Class.forName("io.ms.scloud.tools.study.Sample");
        for (Method m : testClass.getDeclaredMethods()) {
            // isAnnotationPresent告知该工具类运行那些方法
            if (m.isAnnotationPresent(Test.class)) {
                tests++;
                try {
                    m.invoke(null);
                    passed++;
                    // 测试方法抛出异常, 会封装在InvocationTargetException中
                } catch (InvocationTargetException e) {
                    Throwable ex = e.getCause();
                    System.out.println(m + " failed: " + ex);
                    // 第二个catch块用于捕捉Test注解用法错误
                } catch (Exception e) {
                    e.printStackTrace();
                    System.out.println("Invalid @Test: " + m);
                }
            }
        }
        System.out.printf("Passed: %d, Failed: %d%n", passed, (tests - passed));
    }
}

现在要针对只在抛出特殊异常时才成功的测试添加支持, 添加新注解类型:

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface ExceptionTest {
    Class<? extends Throwable> value();
}

实际应用中注解:

public class RunTests {
    public static void main(String[] args) throws Exception {
        int tests = 0;
        int passed = 0;
        Class<?> testClass = Class.forName("io.ms.scloud.tools.study.Sample2");
        for (Method m : testClass.getDeclaredMethods()) {
            if (m.isAnnotationPresent(ExceptionTest.class)) {
                tests++;
                try {
                    m.invoke(null);
                    System.out.printf("Test %s failed: no exception%n", m);
                } catch (InvocationTargetException e) {
                    Throwable ex = e.getCause();
                    Class<? extends Throwable> exType = m.getAnnotation(ExceptionTest.class).value();
                    // 如果是注解中value指定的抛出的异常的实例,则表明测试通过
                    if (exType.isInstance(ex)) {
                        passed++;
                    } else {
                        System.out.printf("Test %s failed: excepted %s, got %s%n", m, exType.getName(), ex);
                    }

                } catch (Exception e) {
                    System.out.println("Invalid @Test: " + m);
                }
            }
        }
        System.out.printf("Passed: %d, Failed: %d%n", passed, (tests - passed));
    }
}

上述代码和处理Test注解的代码不同: 提取了注解参数的值, 并用它检验该测试抛出的异常是否为正确的类型.

再深入一点, 测试可以在抛出任何一种指定异常时都能够通过, 将ExceptionTest注解的参数类型改为Class对象的一个数组:

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface ExceptionTest {
    Class<? extends Exception>[] value();
}

注解中数组参数的语法十分灵活, 是进行过优化的单元素数组, 使用了ExceptionTest新版的数组参数之后, 之前的所有ExceptionTest注解仍然有效, 并产生单元素数组. 为了指定多元素数组, 要用花括号将元素包围起来, 并用逗号隔开:

    @ExceptionTest({IndexOutOfBoundsException.class,
            NullPointerException.class})
    public static void doublyBad() {
        List<String> list = new ArrayList<>();
        list.addAll(5, null);
    }

修改测试运行工具类处理新的ExceptionTest:

public class RunTests {
    public static void main(String[] args) throws Exception {
        int tests = 0;
        int passed = 0;
        Class<?> testClass = Class.forName("io.ms.scloud.tools.study.Sample2");
        for (Method m : testClass.getDeclaredMethods()) {
            if (m.isAnnotationPresent(ExceptionTest.class)) {
                tests++;
                try {
                    m.invoke(null);
                    System.out.printf("Test %s failed: no exception%n", m);
                } catch (InvocationTargetException e) {
                    Throwable ex = e.getCause();
                    Class<? extends Exception>[] exTypes = m.getAnnotation(ExceptionTest.class).value();
                    for (Class<? extends Exception> exType : exTypes) {
                        // 如果是注解中value指定的抛出的异常的实例,则表明测试通过
                        if (exType.isInstance(ex)) {
                            passed++;
                            break;
                        } else {
                            System.out.printf("Test %s failed: excepted %s, got %s%n", m, exType.getName(), ex);
                        }
                    }
                } catch (Exception e) {
                    System.out.println("Invalid @Test: " + m);
                }
            }
        }
        System.out.printf("Passed: %d, Failed: %d%n", passed, (tests - passed));
    }
}

Java 8 另一种多值注解方式, 用@Repeatable元注解对注解的声明进行注解, 表示该注解可以被重复地应用给单个元素, 它唯一的参数是注解类型数组.

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@Repeatable(ExceptionTestContainer.class)
public @interface ExceptionTest {
    Class<? extends Exception> value();
}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface ExceptionTestContainer {
    ExceptionTest[] value();
}
// 使用新的多值注解方式后
@ExceptionTest(IndexOutOfBoundsException.class)
@ExceptionTest(NullPointerException.class)
public static void doublyBad() {
    List<String> list = new ArrayList<>();
    list.addAll(5, null);
}

处理可重复的注解要非常小心, 重复的注解ExceptionTestContainer会产生一个包含注解类型ExceptionTest的合成注解.getAnnotationsByType方法覆盖了这个事实, 可以用于访问可重复注解类型ExceptionTest的重复和非重复的注解.但isAnnotationPresent使它变成了显示的, 重复的注解ExceptionTest不是注解类型(而是所包含的注解类型ExceptionTestContainer)的一部分.如果一个元素具有某种类型的重复注解, 并且用isAnnotationPresent方法检验该元素是否具有该类型的注解, 会发现它没有.用isAnnotationPresent方法检验是否存在包含的注解类型, 会导致程序默默地忽略掉非重复的注解.

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];
    }

    @ExceptionTest(ArithmeticException.class)
    public static void m3() {
    }

    @ExceptionTest(IndexOutOfBoundsException.class)
    @ExceptionTest(NullPointerException.class)
    public static void doublyBad() {
        List<String> list = new ArrayList<>();
        list.addAll(5, null);
    }
}

// 将ExceptionTest注解改为可重复注解时, 进行测试
public class RunTests {
    public static void main(String[] args) throws Exception {
        int tests = 0;
        int passed = 0;
        Class<?> testClass = Class.forName("io.ms.scloud.tools.study.Sample2");
        for (Method m : testClass.getDeclaredMethods()) {
            // 这里是ExceptionTest注解
            if (m.isAnnotationPresent(ExceptionTest.class)) {
                tests++;
            }
        }
        // 这时tests的值为3, 而不是4或5
        System.out.printf("Passed: %d, Failed: %d%n", passed, (tests - passed));
    }
}

// 将ExceptionTest注解改为可重复注解时, 进行测试
public class RunTests {
    public static void main(String[] args) throws Exception {
        int tests = 0;
        int passed = 0;
        Class<?> testClass = Class.forName("io.ms.scloud.tools.study.Sample2");
        for (Method m : testClass.getDeclaredMethods()) {
            // 这里是ExceptionTestContainer注解
            if (m.isAnnotationPresent(ExceptionTestContainer.class)) {
                tests++;
            }
        }
        // 这时tests的值为1, 而不是4或5
        System.out.printf("Passed: %d, Failed: %d%n", passed, (tests - passed));
    }
}

为了利用isAnnotationPresent检测重复和非重复的注解, 必须检测注解类型ExceptionTest及其包含的注解类型ExceptionTestContainer.

public class RunTests {
    public static void main(String[] args) throws Exception {
        int tests = 0;
        int passed = 0;
        Class<?> testClass = Class.forName("io.ms.scloud.tools.study.Sample2");
        for (Method m : testClass.getDeclaredMethods()) {
            if (m.isAnnotationPresent(ExceptionTest.class)
                    || m.isAnnotationPresent(ExceptionTestContainer.class)) {
                tests++;
                try {
                    m.invoke(null);
                    System.out.printf("Test %s failed: no exception%n", m);
                } catch (InvocationTargetException e) {
                    Throwable ex = e.getCause();
                    ExceptionTest[] exTests = m.getAnnotationsByType(ExceptionTest.class);
                    for (ExceptionTest exTest : exTests) {
                        // 如果是注解中value指定的抛出的异常的实例,则表明测试通过
                        if (exTest.value().isInstance(ex)) {
                            passed++;
                            break;
                        } else {
                            System.out.printf("Test %s failed: excepted %s, got %s%n", m, exTest.value().getName(), ex);
                        }
                    }
                } catch (Exception e) {
                    System.out.println("Invalid @Test: " + m);
                }
            }
        }
        System.out.printf("Passed: %d, Failed: %d%n", passed, (tests - passed));
    }
}

加入可重复的注解, 提升了源代码的可读性, 逻辑上是将同一个注解类型的多个实例应用到了一个指定的程序元素.

如果是在编写一个需要程序员给源文件添加信息的工具, 就要定义一组适当的注解类型, 没有理由使用命名模式.

除了工具铁匠(toolsmiths, 即平台框架程序员)之外, 大多数程序员都不必定义注解类型, 但是所有的程序员都应该使用Java平台提供的预定义的注解类型.

40.坚持使用Override注解

@Override注解只能用在方法声明中, 表示注解的方法声明覆盖了超类型中的一个方法声明.坚持使用该注解, 可以防止一大类的非法错误.

public class Bigram {
    private final char first;

    private final char second;

    public Bigram(char first, char second) {
        this.first = first;
        this.second = second;
    }

    public boolean equals(Bigram b) {
        return b.first == first && b.second == second;
    }

    public int hashCode() {
        return 31 + first + second;
    }

    public static void main(String[] args) {
        Set<Bigram> s = new HashSet<>();
        for (int i = 0; i < 10; i++) {
            for (char ch = 'a'; ch <= 'z'; ch++) {
                s.add(new Bigram(ch, ch));
            }
        }
        // 预期打印出的结果是26, 但运行后打印出的是260
        System.out.println(s.size());
    }
}

出现和预期结果不一致的原因:

Bigram类的创建者原本想覆盖equals方法, 同时还记得覆盖了hashCode方法, 但是没能覆盖equals方法, 而是将它重载了.为了覆盖equals方法, 必须定义一个参数类型是Object的equals方法, 但Bigram类的equals方法的参数并不是Object类型, 因此Bigram继承了Object的equals方法.

使用@Override注解, 编译器(或IDE)会告知你覆盖的equals方法不对:

@Override
~~~~~~~~ // Method does not override method from its superclass
public boolean equals(Bigram b) {
	return b.first == first && b.second == second;
}
// 然后将equals方法修改为:
    @Override
    public boolean equals(Object o) {
        if (!(o instanceof Bigram)) {
            return false;
        }
        Bigram b = (Bigram) o;
        return b.first == first && b.second == second;
    }
// 这时打印出的结果是26

应该在你想要覆盖超类声明的每个方法声明中使用Override注解.

41.用标记接口定义类型

标记接口(marker interface)是不包含方法声明的接口, 它只是指明(或标明)一个类实现了具有某种属性的接口, 比如Serializable接口, 实现接口表明类的实例可以被序列化.

标记接口有两点胜过标记注解:

1. 标记接口定义的类型是由被标记类的实例实现的, 标记注解则没有定义这样的类型.
2. 标记接口类型的存在, 允许你在编译时就能捕捉到在使用标记注解的情况下要到运行时才能捕捉到的错误.
3. 标记接口可以被更加精确地进行锁定, 如果注解类型用目标ElementType.TYPE声明, 则可以被应用于任何类或者接口.假设有一个标记只适用于特殊接口的实现, 如果将它定义成一个标记接口, 就可以用它将唯一的接口扩展成它适用的接口, 确保所有被标记的类型也都是该唯一接口的子类型.

Set接口可以说就是这种有限制的标记接口(restricted marker interface), 它只适用于Collection子类型, 但是它不会添加除了Collection之外的方法.这种标记接口可以描述整个对象的某个约束条件, 或者表明实例能够利用其他某个类的方法进行处理.

标记注解胜过标记接口的最大优点, 标记注解是更大的注解机制的一部分.标记注解在那些支持注解作为编程元素之一的框架中同样具有一致性.

如果标记是应用于任何程序元素而不是类或接口, 就必须使用标记注解, 因为只有类和接口可以用来实现或者扩展接口.如果标记只应用于类和接口, 要编写一个或多个只接受这种标记的方法, 就应该优先使用标记接口, 这样你就可以用接口作为相关方法的参数类型, 可以真正为你提供编译时进行类型检查的好处.如果你确信自己永远不需要编写一个只接受带有标记的对象, 那么或许最好使用标记注解.此外, 如果标记是广泛使用注解的框架的一个组成部分, 则显然应该选择标记注解.