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

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

比如一个继承HashSet的类，

public class InstrumentedHashSet<E> extends HashSet<E> {private int addCount = 0;public InstrumentedHashSet() {}public InstrumentedHashSet(int initCap, float loadFactor) {super(initCap, loadFactor);}@Overridepublic boolean add(E e) {addCount ++;return super.add(e);}@Overridepublic boolean addAll(Collection<? extends E> c) {addCount += c.size();return super.addAll(c);}public int getAddCount() {return addCount;}
}
复制代码

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

InstrumentedHashSet<String> s =
new InstrumentedHashSet<String>();
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 inheritance
import java.util.*;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", "Crackle", "Pop"));    System.out.println(s.getAddCount());}
}复制代码

//Reusable forwarding class

import java.util.*;public class ForwardingSet<E> implements Set<E> {private final Set<E> s;public ForwardingSet(Set<E> 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<E> 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<? extends E> 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> 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