But, consider a case like this:

public interface Foo {
  public Foo meth1();
  public void meth2();
}

public class FooImpl implement Foo {
  public Foo meth1() {
  // .. do something
  return this;
  }

  public void meth2() {
  // .. do something
  }
}

If I had implementation inheritance, I could do:

public class BarImpl1 extends Foo {
  public void meth2() {
  super.meth2();
  // .. do something extra
  }
}

If you use composition for this, you end up with:

public class BarImpl2 implements Foo {
  private Foo f = null; // .. initalized somewhere

  public void meth2() {
  f.meth2();
  // .. do something extra
  }

  public Foo meth1() {
  return f.meth1(); // DICEY!
  }
}

Bar2 looks OK, except until some client calls:
  bar.meth1().meth2();

The “extra” stuff you added in Bar2 would not be invoked! In general, to use this technique the base class should not pass itself outside.

In general, I have noticed that,
1. composition is more useful than inheritance
2. interface inheritance is often more appropriate than implementation inheritance

Good Luck on your project!

Cheerio,
Binil

PS: How do I format code, besides resorting to clunky en-bee-es-pee’s? This app needs to provide a help link on comment entry page!