正如Joshua Bloch所描述的那样，拥有一个包装类是如何等同于作文的呢

Question

我正在读约书亚·布洛赫的《有效的java》一书。在"偏爱组合而非继承"的第16项中，他给出了一个使用HashSet并查询自创建以来添加了多少元素的示例（不要与当前大小混淆，当前大小在删除元素时会下降）。他提供了以下代码，这里的getAddCount返回6，我可以理解。这实际上应该返回3。（这是因为HashSet的addAll方法是在其add方法之上实现的）

import java.util.HashSet;
public class InstrumentedHashSet<E> extends HashSet<E> {
    // The number of attempted element insertions
    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;
    }
    public static void main(String[] args) {
        InstrumentedHashSet<String> s = new InstrumentedHashSet<String>();
        s.addAll(Arrays.asList("Snap", "Crackle", "Pop"));
        System.out.println(s.getAddCount());
    }
} 

现在，他解释了一种解决此问题的方法，即使用包装器类（组合和转发）。这就是我很难理解的地方。他提供以下两类

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

和

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

这是怎么回事？在main方法中，我创建了HashSet的一个实例，并使用addAll方法添加了list的所有元素。但是HashSet调用了它的addAll方法（它反过来使用它的add方法），这应该与第一个正确的例子中的方法相同，我应该得到值6，但这给了我3。

Answer 1

在中

public class InstrumentedHashSet<E> extends HashSet<E> {

您直接添加到HashSet，因为addAll()正在委派给超级实现

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

addAll()在内部调用add()，由于多态性，它推迟了add()的@Override实现

@Override
public boolean add(E e) {
    addCount++;
    return super.add(e);
}

其递增计数并打印CCD_ 7（3+1+1+1）。

在中

public class InstrumentedSet<E> extends ForwardingSet<E> {

您正在添加到

private final Set<E> s;

因为addAll()正在委派给它，所以

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

并打印CCD_ 9。这里add()是在Set<E> s上调用的，而不是在您的实例上。

结论是，如果你在继承，你需要了解副作用。super方法调用是否在内部调用任何其他方法调用？如果是这样，你需要采取适当的行动。

继承（从底部开始）

s.add() // s is your InstrumentedHashSet instance, because of polymorphism (inheritance), this adds to the count
this.add() // this is the internal call inside the HashSet#addAll()
super.addAll(...) // this calls the HashSet implementation of addAll which calls add() internally
s.addAll(Arrays.asList("Snap", "Crackle", "Pop")); // s is your InstrumentedHashSet instance

成分

this.add() // this is the internal call to add() inside the Set implementation
s.addAll() // s is the Set<E> instance
super.addAll(...) // this calls the ForwardingSet implementation of addAll()
s.addAll(Arrays.asList("Snap", "Crackle", "Pop")); // s is your InstrumentedSet instance

Answer 2

InstrumentedSet#getAddCount()返回6，因为数组（3）的大小被添加了两次！

//InstrumentedSet
public boolean addAll(Collection<? extends E> c) {
    addCount += c.size(); //here
    return super.addAll(c); //and here!
}

super.addAll(c);调用add()方法。

更详细：

InstrumentedSet#addAll->ForwardingSet#addAll（因为super.addAll）->HashSet#addAll（因为这是你在主目录中给出的）->InstrumentedSet#add（因为多态性）

如果您想要修复：删除addCount += c.size();

InstrumentedSet#addAll返回3，因为它调用这个：

InstrumentedSet#addAll（）（adds 3）->ForwardingSet#addAll（因为super）->HashSet#addAll（因为ForwardingSet有一个HashSet类型的字段）->HashSet#add