第十三条、使类和成员的可访问性最小化

1. 设计良好的模块会隐藏所有的实现细节，把它的API和它的实现清晰地隔离开来。然后模块之间只通过它们的API进行通信，一个模块不需要知道其他模块的内部工作情况。（信息隐藏(infomation hiding)和封装(encapsulation))
   好处：可以有效地解除组成系统的各模块之间的耦合关系，使得这些模块可以独立地开发、测试、优化、使用、理解和修改。
   java的访问机制决定了类、接口和成员的可访问性。实体的可访问性是由该实体声明所在的位置以及访问修饰符共同决定的。

2. 对于顶层（非嵌套）的类和接口，只有两种可能的访问级别：包级私有（package-private）和公有的（public），如果用public修饰符声明了顶层类或者接口，那他就是公有的，否则它将是包级私有的。通过把类做成包级私有，它实际上成了这个包的实现部分，而不是该包导出API的一部分。如果一个包级私有的顶层类或者接口只是在某一个类的内部被用到，就应该考虑使它成为唯一使用它的那个类的私有嵌套类。

3. 对于成员（域、方法、嵌套类和嵌套接口）有四种可能的访问级别：

   • 私有的private：只有在声明该成员的顶层类内部才可以访问这个成员。
   • 包级私有的：声明该成员的包内部的任何类都可以访问这个成员。“缺省default的访问级别”
   • 受保护的protected：声明该成员的类的子类可以访问这个成员，且声明该成员的包内部的任何类也可以访问这个成员。受保护的成员是类的导出的API的一部分，必须永远得到支持。导出的类的受保护成员也代表了该类对于某个实现细节的公开承诺，应该尽量少用。
   • 公有的public：在任何地方都可以访问。

4. 如果方法覆盖了超类中的一个方法，子类中的访问级别就不允许低于超类中的访问级别。这样可以确保任何可使用超类实例的地方也都可以使用子类的实例。如果一个类实现了一个接口，那么接口中的所有类方法在这个类中也都必须被声明为公有的。（因为接口中所有的方法都隐含着公有访问级别。）

5. 除了公有静态final域的特殊情况之外，公有类都不应该包含公有域，并且要确保公有静态final域所引用的对象都是不可变的。

第十四条、在公有类中使用访问方法而非公有域

应该用包含私有域和公有访问/设置方法的类带进行封装。

第十五条、使可变性最小化

1. 不可变类只是其实例不能被修改的类。每个实例中包含的信息都必须在创建该实例的时候提供，并在对象的整个生命周期内固定不变。（比如：String、基本类型的包装类、BigInteger和BigDecimal）
   不可变类的优点：更加易于设计、实现和使用，不容易出错且更加安全。

2. 使类成为不可变遵循的五条规则：

   • 不要提供任何会修改对象状态的方法（mutator）;
   • 保证类不会被扩展。
   • 使所有的域都是final的。
   • 使所有的域都成为私有的。
   • 确保对于任何可变组件的互斥访问。

3. 一个类的实例：

    /**
     * Created by laneruan on 2017/6/7.
     * 这个类表示一个复数。
     * 这些算术运算都是创建并返回新的Complex实例，而不是修改这个实例的做法。
     * 这种被称为函数的做法，因为这些方法返回恶一个函数的结果，这些函数对操作数进行运算但不修改它。
     * 对应的是过程式或命令式的做法。
     */
    public class Complex {
        private final double re;
        private final double im;
    
        //对于频繁使用的值，为他们提供公有的的静态常量。
        public static final Complex ZERO = new Complex(0,0);
        public static final Complex ONE = new Complex(1,0);
        public static final Complex I = new Complex(0,1);
    
        public Complex(double re,double im){
            this.re = re ;
            this.im = im ;
        }
        //使类变成final的一种方式
    //    private Complex(double re,double im){
    //        this.re = re ;
    //        this.im = im ;
    //    }
        public static Complex valueOf(double re,double im){
            return new Complex(re,im);
        }
    //  Accessors with no corresponding mutators
        //基于极坐标创建复数
        public static Complex valueOfPolar(double r,double theta){
            return new Complex(r * Math.cos(theta),r * Math.sin(theta));
        }
        public double realPart(){return re;}
        public double imaginaryPart(){return im;}
    
        public Complex add(Complex c){
            return new Complex(re + c.re,im + c.re);
        }
        public Complex subtract(Complex c) {
            return new Complex(re - c.re,im - c.im);
        }
        public Complex multiply(Complex c){
            return new Complex(re*c.re-im*c.im,re*c.im+im*c.re);
        }
        public Complex divide(Complex c){
            double tmp = c.re * c.re + c.im * c.im;
            return new Complex((re*c.re+im*c.im)/tmp,(im*c.re-re*c.im)/tmp);
        }
        @Override
        public boolean equals(Object o) {
            if(o == this){
                return true;
            }
            if(!(o instanceof Complex)){
                return false;
            }
            Complex c = (Complex) o ;
            return Double.compare(re,c.re) == 0
                    && Double.compare(im,c.im) == 0;
        }
        @Override
        public int hashCode(){
            int result = 17 + hashDouble(re);
            result = 31 * result + hashDouble(im);
            return result;
        }
        private int hashDouble(double val){
            long longBits = Double.doubleToLongBits(val);
            return (int)(longBits ^ (longBits >>>32));
        }
        @Override
        public String toString(){
            return "(" + re + "+" + im+"i)";
        }
    }
   

   这个类表示一个复数。这些算术运算都是创建并返回新的Complex实例，而不是修改这个实例的做法。这种被称为函数式的做法，因为这些方法返回了一个函数的结果，这些函数对操作数进行运算但不修改它。对应的是过程式或命令式的做法。

   这种函数方法的优点带来了不可变性，不可变对象只有一种状态，即被创建时的状态。不可变对象本质上是线程安全的，不要求同步。当多个线程并发访问这样的对象，不会发生破坏，所以不可变对象可以被自由地共享。不可变对象为其他对象提供了大量的构件，如果知道一个复杂对象内部的组件不会改变，要维护它的不变性约束是比较容易的。

   不可变类的真正唯一缺点在于：对于每个不同的值都需要一个单独的对象。

4. 如何使不可变类自身不被子类化？除了使类成为final外，让类的所有构造器都变成私有的或者包级私有的，并添加共有的静态工厂来代替公有的构造器。以Complex为例：

   //这种方式虽不常用，但是最灵活。而且可以肯定不能扩展。
    private Complex(double re,double im){
        this.re = re ;
        this.im = im ;
    }
    public static Complex valueOf(double re,double im){
        return new Complex(re,im);
    }
   

5. 有关不可变类的序列化：

实现Serializable接口，并且它包含一个或者多个指向可变对象的域，就必须提供一个显式的readObject或者readResolve方法，或者使用ObjectOutPutStream.writeUnshared和ObjectInputStream.readUnshared方法，即使默认的序列化形式是可接受的。

第十六条、复合优先于继承

1. 继承(inheritance)是实现代码重用的有力手段，但是使用不当会导致软件变得很脆弱，在包的内部使用继承是非常安全的，在那里，子类和父类的实现都处在同一个程序员的控制下。然而，对于普通的具体类进行跨越包边界的继承，则是非常危险的。继承打破了封装性，子类依赖于父类中特定功能的实现细节。父类的实现有可能会随着发行版本的不同而有所变化，子类可能随之遭到破坏，因此子类也必须随着父类的更新而演变。

2. 导致子类脆弱的一个相关原因是：它们的父类在后续发行版本中可以获得新的方法。这些问题都来源于覆盖（overriding）动作。下面是一个脆弱的实例：

    import java.util.Arrays;
    import java.util.Collection;
    import java.util.HashSet;
    /**
     * Created by laneruan on 2017/6/7.
     * 需要查询HashSet。看看自从它从被创建以来曾经添加了多少个元素。
     * HashSet类中添加元素的方法：add和addAll，因此这两个方法都要覆盖，但并不能正常工作。
     * 因为在HashSet的内部，addAll方法是基于add实现的，所以通过addAll方法增加的每个元素都计算了两次。
     * 此时可以通过去掉addAll的覆盖方法来修正这个问题，但是这是十分脆弱的，它的功能正确性是需要依赖于HashSet的addAll方法是在
     * add方法上实现的，不能保证随着发行版本的不同而不发生变化。所以此时的InstrumentedHashSet是十分脆弱的。
     */
    //Broken - Inappropriate use of inheritance
    public class InstrumentedHashSet<E> extends HashSet<E> {
        private int addCount = 0 ;
        public InstrumentedHashSet(){}
        public InstrumentedHashSet(int initCap,Float loadFactor){
            super(initCap,loadFactor);
        }
        @Override
        public boolean add(E e){
            addCount ++;
            return super.add(e);
        }
        @Override
        public boolean addAll(Collection<? extends E> c){
            addCount += c.size();
            return super.addAll(c);
        }
        public int getAddCount(){
            return addCount;
        }
        public static void main(String[] args){
            InstrumentedHashSet<String> s = new InstrumentedHashSet<String>();
            s.addAll(Arrays.asList("Snap","Pop","Crackle"));
            System.out.println(s.getAddCount());//打印出来是6？
        }
    }
   

3. 复合（composition）：不用扩展现有的类，而是在新的类中增加一个私有域，它引用现有类的一个实例。因为现有的类变成了新类的一个组件。新类中的每个实例方法都可以调用被包含的现有类实例中对应的方法，并返回它的结果。这被称为转发（forwarding），新类中的方法被称为转发方法。这样新得到的类会非常稳固，不依赖于现有类的实现细节。下面是上面脆弱的实例的复合版本：

    import java.util.*;
    
    /**
     * Created by laneruan on 2017/6/8.
     * Set接口的存在使得InstrumentedSet类的设计成为可能，因为Set类保存了HashSet类的功能特性。
     * 从本质上来说这个类把一个Set变成了一个增加计数功能的Set。
     * 因为每个InstrumentedSet实例都把另一个Set实例包装起来了，所以称为wrapper class
     */
    //Wrapper class 包装类
    public class InstrumentedSet<E> extends ForwardingSet<E>{
        private int addCount = 0;
        public InstrumentedSet(Set<E> s){
            super(s);
        }
        @Override
        public boolean add(E e){
            addCount++;
            return super.add(e);
        }
        @Override
        public boolean addAll(Collection<? extends E> c){
            addCount += c.size();
            return super.addAll(c);
        }
        public int getAddCount(){
            return addCount;
        }
        public static void main(String[] args){
            InstrumentedSet<String> s = new InstrumentedSet<String>(new HashSet<String>());
            s.addAll(Arrays.asList("Snap","Pop","Crackle"));
            System.out.println(s.getAddCount());//打印出来是3
            System.out.println(s);
        }
    }
    //Reusable forwarding class
    class ForwardingSet<E> implements Set<E>{
        private final Set<E> s;
        public ForwardingSet(Set<E> s){this.s = s;}
        @Override
        public int size() {
            return s.size();
        }
        @Override
        public boolean isEmpty() {
            return s.isEmpty();
        }
        @Override
        public boolean contains(Object o) {
            return s.contains(o);
        }
        @Override
        public Iterator<E> iterator() {
            return s.iterator();
        }
        @Override
        public Object[] toArray() {
            return s.toArray();
        }
        @Override
        public <T> T[] toArray(T[] a) {
            return s.toArray(a);
        }
        @Override
        public boolean add(E e) {
            return s.add(e);
        }
        @Override
        public boolean remove(Object o) {
            return s.remove(o);
        }
        @Override
        public boolean containsAll(Collection<?> c) {
            return s.containsAll(c);
        }
        @Override
        public boolean addAll(Collection<? extends E> c) {
            return s.addAll(c);
        }
        @Override
        public boolean retainAll(Collection<?> c) {
            return s.retainAll(c);
        }
        @Override
        public boolean removeAll(Collection<?> c) {
            return s.removeAll(c);
        }
        @Override
        public void clear() {
            s.clear();
        }
        @Override
        public boolean equals(Object o) {
            return s.equals(o);
        }
        @Override
        public int hashCode() {
            return s.hashCode();
        }
        @Override
        public String toString() {
            return s.toString();
        }
    }
   

4. 什么时候使用继承?

只有当子类真正是父类的子类型(subtype)时，即当两者之间确实存在“is-a”关系时，类B才应该扩展A。如果不能确定每个B确实都是A，通常情况下，B应该包含A的一个私有实例，而且暴露一个较小的、较简单的API: A本质上不是B的一部分，只是它的实现细节而已。