第十七条、要么为继承而设计，并提供文档说明，要么就禁止继承

1. 该类的文档必须精确地描述覆盖每个方法所带来的影响，即说明它可覆盖的方法的自用性。

2. 为了继承而设计的类，对这个类会有一些实质性的限制。如：构造器决不能调用可被覆盖的方法。另一种合理的办法是确保这个类永远不会调用它的任何可覆盖的方法。

第十八条、接口优于抽象类

1. 接口和抽象类是Java用来定义允许多个实现的类型的两种机制。

   它们之间最明显的区别在于：抽象类允许包含某些方法的实现，但是接口则不允许。一个更为重要的区别在于：为了实现抽象类定义的类型，类必须成为抽象类的一个子类。而任何一个类，只要它定义了所有必要的方法，并且遵守通用约定，它就被允许实现一个接口，而不管这个类是处于类层次的哪个位置。因为Java只允许单继承，不可能有一个以上的父类，所以抽象类作为类型定义受到了极大的限制。

2. 接口的优点：

   • 现有的类很容易被更新，以实现新的接口：如果这些方法尚不存在，你需要做的只是增加必要的方法，然后在类声明中增加一个implements子句。而一般来说，无法更新现有的类来扩展新的抽象类。

   • 接口是定义mixin（混合类型）的理想选择。mixin类型是指：类除了实现它的“基本类型”之外，还可以实现这个mixin类型，以表明它提供了某种可供选择的行为。如Comparable接口，这样的接口之所以被称为mixin，是因为它允许任选的功能可被混合到类型的主要功能中。

   • 接口允许我们构造非层次结构的类型框架。有些事物是不能被整齐地组织成一个严格的层次结构。

3. 通过对你导出的每个重要接口都提供一个抽象的骨架实现类（skeletal implementation），把接口和抽象类的优点结合起来。

   接口的作用依然是定义类型，但是骨架实现类接管了所有与接口实现相关的工作。按照惯例，骨架实现类成为AbstractInterface，这里的Interface指实现的接口名。如AbstractCollection、AbstractSet等。如果设计得当，骨架实现可以使程序员很容易提供他们自己的接口实现。

    //下面是一个静态工厂方法，它包含一个完整的、功能全面的List实现。
    static List<Integer> intArrayAsList(final int[] a){
        if(a == null)
            throw new NullPointerException();
        return new AbstractList<Integer>() {
            @Override
            public Integer get(int i) {
                return a[i];  //AutoBoxing
            }
            @Override
            public Integer set(int i,Integer val){
                int oldVal = a[i];
                a[i] = val;
                return oldVal;
            }
            @Override
            public int size() {
                return a.length;
            }
        };
    }
   

4. 骨架实现的美妙之处在于：它们为抽象类提供了实现上的帮助，但又不强加“抽象类被用作类型定义时”所特有的严格限制。骨架实现类能够有助于接口的实现，实现了这个接口的类可以把对于接口方法的调用，转发到一个内部私有类的实例上，这个内部私有类扩展了骨架实现类（这就是模拟多重继承）。

5. 编写骨架实现类需要认真地研究接口，首先确定哪些方法是最为基本的，其他的方法可以根据它们来实现。这些基本方法将成为骨架实现类中的抽象方法。然后，必须为接口中的所有其他方法提供具体的实现。下面是一个实例:

    import java.util.AbstractList;
    import java.util.List;
    import java.util.Map;
    
    /**
     * Created by laneruan on 2017/6/8.
     */
    public abstract class AbstractMapEntry<K,V>
            implements Map.Entry<K,V> {
        public abstract K getKey();
        public abstract V getValue();
    
        @Override
        public V setValue(V value) {
            throw new UnsupportedOperationException();
        }
        @Override
        public boolean equals(Object o){
            if(o == this)
                return true;
            if(!(o instanceof Map.Entry))
                return false;
            Map.Entry<?,?> arg = (Map.Entry) o ;
            return equals(getKey(),arg.getKey()) &&
                    equals(getValue(),arg.getValue());
        }
        public static boolean equals(Object o1,Object o2){
            return o1 == null ? o2 == null : o1.equals(o2);
        }
        @Override
        public int hashCode(){
            return hashCode(getKey()) ^ hashCode(getValue());
        }
        public static int hashCode(Object obj){
            return obj == null ? 0 : obj.hashCode();
        }
    }
   

6. 抽象类与使用接口相比有一个明显的优势：

   抽象类的演变比接口的演变要容易得多。如果在后续的发行版本中，你希望在抽象类中增加新方法，始终可以增加具体的包含合理的默认实现的方法。而接口是行不通的。因此，设计公有的接口要非常谨慎，接口一旦被公开发行，并且已经被广泛实现，再想改这个接口几乎是不可能的。

7. 总结：

   接口通常是定义允许多个实现类型的最佳途径，这条规则有个例外，即当演变的容易性比灵活性和功能更为重要的时候。在这种情况下，应该使用抽象类来定义类型，前提是必须理解和可以接受这些局限性。
   如果你导出一个重要的接口，就应该坚决考虑同时提供骨架实现类。最后应该尽可能谨慎地设计所有的公有接口，并通过编写多个实现来对它们进行全面的测试。

第十九条、接口只用于定义类型

当类实现接口时，接口就充当可以引用这个类的实例的类型（type），因此，类实现了接口就表明客户端可以对这个类的实例实施某种动作。
为了任何其他目的而定义接口是不恰当的，比如常量接口，这种接口没有包含任何方法，只包含静态的final域，每个域都导出一个常量。

第二十条、类层次优于标签类

1. tagged class 标签类：带有两种甚至更多种风格的实例的类，并包含表示实例风格的标签（tag）域。这种标签类有着许多缺点，过于冗长、容易出错且效率低。

2. 子类型化（sub typing)，变成类层次。它们可以用来反映类型之间本质上的层次关系，有助于增强灵活性，并进行更好的编译时类型检查。

第二十一条、用函数对象表示策略

1. 有些语言支持函数指针（function pointer）、代理（delegate）、lambda表达式，或者支持类似的机制，允许程序把“调用特殊函数的能力”存储起来并传递这种能力。这种机制通常用于允许函数的调用者通过传入第二个函数来指定自己的行为。策略模式

2. Java没有提供函数指针，但是可以用对象引用（实质上也是地址）实现同样的功能。

    class StringLengthComparator{
        public int compare(String s1,String s2){
            return s1.length() - s2.length();
        }
    }
   

   调用对象上的方法通常是执行该对象上的某项操作。然而，我们也可能定义这样一种对象，它的方法执行其他对象上这些对象被显式传递给这些方法上的操作。如果一个类仅仅导出这样的一个方法，它的实例实际上就等同于一个指向该方法的指针。这样的实例被称为函数对象（function object）。

   作为典型的具体策略类，StringLengthComparator类是无状态的（stateless）：没有域。所以这个类的所有实例在功能上都是等价，作为Singleton是非常合适的。指向StringLengthComparator对象的引用可以被当做是一个指向该比较器的函数指针，可以在任意一对字符串上被调用。即StringLengthComparator实例是用于字符串比较操作的具体策略。

3. 我们在设计具体的策略类时，还需要定义一个策略接口，具体的策略类往往使用匿名类声明。需要注意的是，以匿名类的方法，每次执行都会创建一个新的实例。

    class StringLengthComparator implements Comparator<String>{
        public int compare(String s1,String s2){
            return s1.length() - s2.length();
        }
    }
    public interface Comparator<T>{
        public int compare(T t1,T t2);
    }
    Arrays.sort(stringArray,new Comparator<String>(){
        public int compare(String s1,String s2){
            return s1.length() - s2.length();
        }
    });
   

4. 总结：

在Java中实现这种策略模式，需要声明一个接口来表示这个策略，并且为每个具体策略声明一个实现了该接口的类。当一个具体的策略只被使用一次时，通常使用匿名类来声明和实例化这个具体策略类。当一个具体策略是设计用来重复使用的时候，它的类通常就要被实现为私有的静态成员类，并通过公有的静态final域被导出，其类型为该策略接口。

第二十二条、优先考虑静态成员类

1. 嵌套类（nested class）是指被定义在一个类内部的类。存在的目的应该只是为了外围类提供服务。
   嵌套类有四种：静态成员类、非静态成员类、匿名类和局部类。除了第一种类，其他三种都被称为内部类（inner class）

2. 静态成员类是最简单的一种嵌套类，它可以访问外围类的所有成员，它遵守同样的可访问性规则。

   一种常见的用法是作为公有的辅助类。如果声明成员类不要求访问外围实例，就要始终把static修饰符放在它的声明中。如果不？每个实例都将包含一个额外的指向外围对象的引用，耗时又占空间。

3. 非静态成员类的每个实例都隐含着与外围类的一个实例相关:

   如果嵌套类的实例可以在它的外围类实例之外独立存在，则必须是静态成员类。
   当非静态成员类的实例被创建的时候，它和外围实例之间的关联也随之被建立起来，而且这种关联关系以后不能被修改。
   非静态成员类的一种常见用法是定义一个Adapter，它允许外部类的实例被看作是另一个不相关的类的实例。

4. 匿名类不与其他的成员一起被声明和实例化，只有在使用的同时被声明和实例化。可以出现在任何允许存在表达式的地方。

   匿名类的常见用法：动态地创建函数对象、创建过程对象（如Runable、Thread等实例）和在静态工厂方法的内部。

5. 局部类用的最少。在任何可以声明局部变量的地方都可以声明局部类。

6. 总结：

   四种嵌套类有各自的用途：
   如果一个嵌套类需要在单个方法之外依然是可见的、或者太长，就应该使用成员类。
   如果成员类的每个实例都需要一个指向其外围实例的引用，就要把成员类做成非静态，否则就是静态的。假设这个嵌套类属于一个方法的内部.
   如果你只需要在一个地方创建实例，并且已经有了一个预置的类型可以说明这个类的特征，就把它做成匿名类，否则就是局部类。