Effective Java 第16条 : 复合优先于继承

   继承（指的是子类扩展超类，并不包含接口）是实现代码重用的有力手段，但它并不总是完成这项工作的最佳工具。不适当地使用继承会导致脆弱的软件。 

    与方法调用不同的是，继承打破了封装性。换句话说子类依赖于超类中特定功能的实现细节。超类的实现可能随着发行版本而变化，就有可能影响子类。因此，子类必须要跟着超类的更新而发展。除非超类是专门为扩展而设计的，并且具有很好的说明文档。

    

public class InstrumentedHashSet<E> extends HashSet<E>{    private int addCount = 0;    public InstrumentedHashSet()    {    }    public InstrumentedHashSet(int intCap, float loadFactor)    {        super(intCap, 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;    }}

这段代码如果打印 addCount的值的话：6。

由于 HashSet 中的 addAll方法的实现也是通过自身的add方法来实现的。这样会导致子类很脆弱，由于超类在后续的发布版本中可以获得新的方法。

上面两个问题都来源于覆盖（Override）动作。如果在扩展一个类的时候，仅仅是增加新的方法，而不是覆盖现有的方法，你可能认为是安全的。虽然这种扩展方式比较安全一些，但是也并非完全没有风险。如果超类在后续的发行版本中获得了一个新的方法，并且不幸的是跟你的方法

重名 。实际是你还是覆盖了超类的方法，因此又回到刚才的两个问题上去了 。

我们 可以不用扩展现有的类，而是在新类中增加一个私有域，它引用现有类的一个实例。这种设计被称作”复合（composition）“,因为现有类变成了新类的一个组件。

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 obj)    {        return s.equals(obj);    //To change body of overridden methods use File | Settings | File Templates.    }    @Override    public int hashCode()    {        return s.hashCode();    //To change body of overridden methods use File | Settings | File Templates.    }    @Override    public String toString()    {        return s.toString();    //To change body of overridden methods use File | Settings | File Templates.    }}

public class InstrumentedHashSet<E> extends HashSet<E>{    private int addCount = 0;    public InstrumentedHashSet()    {    }    public InstrumentedHashSet(int intCap, float loadFactor)    {        super(intCap, 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;    }}

简而言之，继承的功能非常强大，但是也存在诸多问题，因为他违背了封装原则。只有当子类和超类之间全是存在子类型关系时，使用继承才是恰当的。即便如此，如果子类和超类不在同一个包中，并且超类不是为了继承而设计的，那么继承会导致脆弱性（fragility）。为了避免这种脆弱性，可以用复合和转发机制来代替继承，尤其是在适当的接口中可以实现包装类。包装类不仅比子类更加健壮，而且功能更强大。