I am going through Effective Java, Item-16 Favor composition over inheritance
. I looked at the Forwarding class
example below.
I am wondering what's the point of having a ForwardingSet
class? InstrumentedSet
can very well implement Set
and have a private instance of it which invokes all the methods.
Is it to promote re-use and prevent redundancy if we end up having more InstrumentedSet
like classes in the future which just need to do something in addition to the base behavior? Is it just future-proofing the design or is there something else to it that I am missing?
// Reusable forwarding class
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); }
...
}
// Wrapper class - uses 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);
}
...
}
ForwardingSet
is a framework.If you have to write several Set
s that work with other Set
s internally but provide different functionalities on top of the "vanilla" Set
, you'd better write the common part once and not several times.
Joshua Bloch, in Effective Java refers to it as "composition", though the actual implementation looks more like the decorator pattern.
An actual implementation is readily available in Guava, as a class named ForwardingSet
.
Is it to promote re-use and prevent redundancy if we end up having more InstrumentedSet like classes in the future which just need to do something in addition to the base behavior?
Yes.
Is it just future-proofing the design?
Yes.
or is there something else to it that I am missing?
No, you're not missing anything.