阅读经典——《Effective Java》07

继承（inheritance）是实现代码重用的有力手段，但并非总是最好的选择。继承打破了封装性，因为子类依赖于超类中特定功能的实现细节。超类的实现有可能随着发行版本的不同而有所变化，导致子类遭到破坏。

1. 子类遭到破坏的案例
2. 使用复合和转发

子类遭到破坏的案例

假设有一个程序使用HashSet，为了查看它自创建以来曾经添加过多少个元素，我们可以通过继承扩展HashSet，重写add和addAll方法。

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;
  }
}

这段代码看上去没什么问题，假如执行下面的程序，我们期望getAddCount返回3，但它实际上返回的是6。

InstrumentedHashSet<String> s = new InstrumentedHashSet<String>();
s.addAll(Arrays.asList("Snap", "Crackle", "Pop"));
System.out.println(s.getAddCount());

哪里出错了？

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

因此，使用继承扩展一个类很危险，父类的具体实现很容易影响子类的正确性。而复合优先于继承告诉我们，不用扩展现有的类，而是在新类中增加一个私有域，让它引用现有类的一个实例。这种设计称为复合（Composition）。

使用复合和转发

使用复合来扩展一个类需要实现两部分：新的类和可重用的转发类。转发类用于将所有方法调用转发给私有域。这样得到的类非常稳固，不依赖于现有类的实现细节。请看下面的例子。

//Wrapper class - use composition in place of inheritance
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;
    }
}

//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.retainAll(c);}

    @Override
    public void clear() {s.clear();}
    
}

现在，使用InstrumentedSet不会再出上面的问题了，因为无论是add方法还是addAll方法都转发给了私有域s来处理，这些方法对于s来说总是一致的，不会受InstrumentedSet的影响。另一个好处是此时的包装类InstrumentedSet可以用来包装任何Set实现，有了更广泛的适用性。例如

Set<Date> s = new InstrumentedSet<Date>(new TreeSet<Date>(cmp));
Set<E> s2 = new InstrumentedSet<E>(new HashSet<E>(capacity));

只有当子类和超类之间确实存在父子关系时，才可以考虑使用继承。否则都应该用复合，包装类不仅比子类更加健壮，而且功能也更加强大。

关注作者或文集《Effective Java》，第一时间获取最新发布文章。