《复合(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);
}
@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;
}
}
如果调用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
