Effective Java学习--第16条：复合优先于继承

在系统分析设计这门课中某王就不停地强调一点，就是ISA(is a 原则)。都知道继承是面向对象的一大要素，但是哪里使用复合哪里使用继承，其实还是有讲究的。

可以简单的用ISA原则概括。有一个具备一定功能类，我们要对其功能进行拓展，到底是采用复合呢还是继承呢？当新类与旧类的关系是从属关系是，即cat is an animal，English book is a book，我们优先使用继承；当新类是旧类的组成部分之一时，即hand is a part of body，jiangsu is a part of China，我们优先使用复合。

理由如下：当我们要扩展一个类时，特别是一个别人写好的类，一个类库的类，我们往往关心的仅仅是单个api的功能，而不关心他的实现，但是存在的一个问题就是，同一个类的各个方法直接可能存在联系，可能一个方法的实现依赖于另一个方法，这就意味着，当我们调用一个我们想要操作的方法时，“继承”会隐式的调用另一个方法，这就可能存在问题。

经典的例子是Set中add()和addAll()的内在联系。

需求：新建一个集合类，维护一个addCount变量，记录，一共添加了多少次新值。分别用继承，复合实现。

先看继承：

MySet.java

package cczu.edu.test2;

import java.util.Collection;
import java.util.HashSet;

public class MySet<E> extends HashSet<E>{
    private int addCount = 0;

    public MySet() {
    }

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

}

Test

@Test
    public void test1(){
        MySet<String> set = new MySet<String>();
        List<String> list = new ArrayList<String>();
        list.add("abc");
        list.add("def");
        list.add("ghi");

        set.addAll(list);
        System.out.println(set.getAddCount());
        //the ans is 6
    }

因为，在hashSet的addAll()实现中，是循环调用add()方法的，所以导致3*2。当然你也可以重写addAll()方法，但是这样就失去了继承的意义。

使用复合：

ForwardingSet.java

package cczu.edu.test2;

import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class ForwardingSet<E> implements Set<E> {

    private final Set<E> s;

    public ForwardingSet(Set<E> s) {
        this.s = s;
    }

    public ForwardingSet(){
        this.s = new HashSet<E>();
    }

    @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) {
        // TODO Auto-generated method stub
        return false;
    }

    @Override
    public boolean retainAll(Collection<?> c) {
        return s.retainAll(c);
    }

    @Override
    public boolean removeAll(Collection<?> c) {
        return s.removeAll(c);
    }

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

}

Myset2.java

package cczu.edu.test2;

import java.util.Collection;

public class MySet2<E> extends ForwardingSet<E>{
    private int addCount = 0;

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

}

Test

@Test
    public void test2(){
        MySet2<String> set = new MySet2<String>();
        List<String> list = new ArrayList<String>();
        list.add("abc");
        list.add("def");
        list.add("ghi");

        set.addAll(list);
        System.out.println(set.getAddCount());
        //the ans is 3
    }

增加一个ForwardingSet.java，作用仅仅就是实现转发。

回过头来看，复合可以将旧类完全地包裹起来，以至于我们不需要关注旧类的实现，同时达到可以调用旧类方法的效果，避免了旧类各个方法之间存在的联系，再加入旧类如果还有其他的权限问题，复合也可以隐藏缺陷。

自我总结：其实设计模式中例如代理模式，适配器模式，装饰器模式，和继承、复合都有些联系，以至于我都有一点混淆，毕竟，设计模式是死的，思想是活的。