Notes on Object Aggregation.

Question

It seems that the object aggregation mechanism vis-a-vis the Decorator pattern has some issues. Method propogation works only for those methods which are defined in an implemented interface. Specialized behavior of the "inner" classes is inaccessible. Let me illustrate.
I want to create an aggregate object out of the java.io.PushbackReader and the java.io.LineNumberReader classes. Each of these have specialized behavior, unavailable in the other. PushbackReader has unread() while LineNumberReader has getLineNumber(), et al. If I aggregate LineNumberReader inside PushbackReader, I lose access to the getLineNumber() method. Conversely, if I aggregate PushbackReader inside LineNumberReader, I lose access to the unread() method.
Clearly my goal is to have the best of both worlds but, it seems I can only have one or the other.

Answer 1

So, I'm wondering if there have been any attempts to address this issue. I'm considering checking out the OpenJDK and writing in a small language extension which would attempt to fix this problem. Consider the following:
interface Common {
  public void doCommon();
class Base implements Common {
  public Base() { ... }
  public void doCommon() { System.out.writeln("Base"); }
class A extends Common {
  private inherited Common common;
  public A(Common c) { this.common = c; ... }
  public void doCommon() { this.common.doCommon(); System.out.writeln("A"); }
  public void doA() { System.out.writeln("A"); }
class B extends Common {
  private inherited Common common;
  public B(Common c) { this.common = c; ... }
  public void doCommon() { this.common.doCommon(); System.out.writeln("B"); }
  public void doB() { System.out.writeln("B"); }
public class Aggregate {
  Common b;
  public static void main(String[] args) {
    b = new B(new A(new Base()));
    b.doCommon();  // result: "BaseAB"
    b.doA(); // result: "A"
} Here I have a class extending an interface and a new keyword, inherited. Since I haven't done any work on the javac compiler, I am assuming that using extends in the context of a class definition extending an interface would signal to the compiler that all class extending that interface may be aggregated. The keyword inherited then, does the work of aggregation by only allowing variables of the type of the extended interface to be inherited. This nicely solves the problem of aggregation without exposing class hierarchy to multiple inheritance or bloating.