《复合(composition)优先于继承》

继承打破了封装性(violates encapsulation)。superclass’s的变化可能会使得subclass遭受破坏。所以子类要跟着父类更新。

比如一个继承HashSet的类，

public class InstrumentedHashSet
    
      extends HashSet
     
       {  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
       c) {    addCount += c.size();    return super.addAll(c);  }  public int getAddCount() {    return addCount;  }}复制代码

如果调用addAll方法，传入一个size = 3 的List，

InstrumentedHashSet
    
      s =new InstrumentedHashSet
     
      ();s.addAll(Arrays.asList("Snap", "Crackle", "Pop"));复制代码

然后调用getAddCount，得到的是6而不是3。解释：

在HashSet内部，addAll方法是基于add方法来实现的，即使HashSet的文档中并没有说明这一细节，这也是合理的。因此InstrumentedHashSet中的addAll方法首先把addCount增加了3，然后利用super.addAll()调用HashSet的addAll实现，在该实现中又调用了被InstrumentedHashSet覆盖了的add方法，每个元素调用一次，这三次又分别给addCount增加了1，所以总共增加了6

执行顺序：子类addAll-->父类addAll-->子类add

正确姿势：使用复合，wrapper class

//Wrapper class - use composition in place of inheritanceimport java.util.*;public class InstrumentedSet
    
      extends ForwardingSet
     
       {    private int addCount = 0;    public InstrumentedSet(Set
      
        s) {        super(s);    }    @Override public boolean add(E e) {        addCount++;        return super.add(e);    }    @Override public boolean addAll(Collection
        c) {        addCount += c.size();        return super.addAll(c);    }    public int getAddCount() {        return addCount;    }    public static void main(String[] args) {        InstrumentedSet
       
         s =            new InstrumentedSet
        
         (new HashSet
         
          ()); s.addAll(Arrays.asList("Snap", "Crackle", "Pop")); System.out.println(s.getAddCount()); }}复制代码

//Reusable forwarding class

import java.util.*;public class ForwardingSet
    
      implements Set
     
       {    private final Set
      
        s;    public ForwardingSet(Set
       
         s) { this.s = s; }    public void clear()               { s.clear();            }    public boolean contains(Object o) { return s.contains(o); }    public boolean isEmpty()          { return s.isEmpty();   }    public int size()                 { return s.size();      }    public Iterator
        
          iterator()     { return s.iterator();  }    public boolean add(E e)           { return s.add(e);      }    public boolean remove(Object o)   { return s.remove(o);   }    public boolean containsAll(Collection
          c)                                   { return s.containsAll(c); }    public boolean addAll(Collection
          c)                                   { return s.addAll(c);      }    public boolean removeAll(Collection
          c)                                   { return s.removeAll(c);   }    public boolean retainAll(Collection
          c)                                   { return s.retainAll(c);   }    public Object[] toArray()          { return s.toArray();  }    public 
         
           T[] toArray(T[] a) { return s.toArray(a); } @Override public boolean equals(Object o) { return s.equals(o); } @Override public int hashCode() { return s.hashCode(); } @Override public String toString() { return s.toString(); }}复制代码

这样的话执行顺序是: InstrumentedSet的addAll-->ForwardingSet的addAll--->Set的addAll--->ForwardingSet的add---> Set的add

最终都会指向Set，不会再调用InstrumentedSet的addAll。所以s.getAddCount结果是3. 不过这个过程是我猜的，我没有debug跟一下，有空需要走一遍验证一下。

另外不安全的地方是父类的方法可能改变。

如果不去override函数，会安全一点。但有种情况，如果父类更新了一个签名相同返回值不同的方法，子类就无法编译通过。

使用继承的时候，一定要问自己子类父类是不是is-A的关系，是不是每个子类都是父类。

reference: http://www.jianshu.com/p/4fd0345054cc http://blog.csdn.net/democreen/article/details/50158485