Q:

Automatically delegating all methods of a java class

Say I have a class with many of public methods:
public class MyClass {

    public void method1() {}
    public void method2() {}
    (...)
    public void methodN() {}

}

Now I would like to create a wrapper class which would delegate all the methods to wrapped instance (delegate):
public class WrapperClass extends MyClass  {
    private final MyClass delegate;

    public WrapperClass(MyClass delegate) {
        this.delagate = delegate;
    }

    public void method1() { delegate.method1(); }
    public void method2() { delegate.method2(); }
    (...)
    public void methodN() { delegate.methodN(); }

}

Now if MyClass has a lot of methods I would need to override each of them which is more or less the same code which just "delegates".  I was wondering if it is possible to do some magic to automatically call a method in Java (so the Wrapper class would need to say "Hey if you call a method on me just go to delegate object and call this method on it). 
BTW: I can not use inheritance because the delegate is not under my control. I just get its instance from elsewhere (another case would be if MyClass was final).  
NOTE: I do not want IDE generation.  I know I can do it with help of IntelliJ/Eclipse, but I'm curious if this can be done in code. 
Any suggestions how to achieve something like this? ( NOTE: I would probably be able to do it in some scripting languages like php where I could use php magic functions to intercept the call). 

A:

Perhaps the dynamic Proxy of java can help you.  It only works if you consequently use interfaces.  In this case, I will call the interface MyInterface and set up a default implementation:
public class MyClass implements MyInterface {

    @Override
    public void method1() {
        System.out.println("foo1");
    }

    @Override
    public void method2() {
        System.out.println("foo2");
    }

    @Override
    public void methodN() {
        System.out.println("fooN");
    }

    public static void main(String[] args) {
        MyClass wrapped = new MyClass();
        wrapped.method1();
        wrapped.method2();
        MyInterface wrapper = WrapperClass.wrap(wrapped);
        wrapper.method1();
        wrapper.method2();
    }

}

The wrapper class implementation would look like:
public class WrapperClass extends MyClass implements MyInterface, InvocationHandler {

    private final MyClass delegate;

    public WrapperClass(MyClass delegate) {
        this.delegate = delegate;
    }

    public static MyInterface wrap(MyClass wrapped) {
        return (MyInterface) Proxy.newProxyInstance(MyClass.class.getClassLoader(), new Class[] { MyInterface.class }, new WrapperClass(wrapped));
    }

    //you may skip this definition, it is only for demonstration
    public void method1() {
        System.out.println("bar");
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Method m = findMethod(this.getClass(), method);
        if (m ! = null) {
            return m.invoke(this, args);
        }
        m = findMethod(delegate.getClass(), method);
        if (m ! = null) {
            return m.invoke(delegate, args);
        }
        return null;
    }

    private Method findMethod(Class<? > clazz, Method method) throws Throwable {
        try {
            return clazz.getDeclaredMethod(method.getName(), method.getParameterTypes());
        } catch (NoSuchMethodException e) {
            return null;
        }
    }

}

Note that this class:

extends MyClass, to inherit a default implementation (any other would do)
implements Invocationhandler, to allow the proxy to do reflection
optionally implement MyInterface (to satisfy the decorator pattern)

This solution allows you to override special methods, but to delegate all others.  This will even work with sub classes of Wrapper class. 
Note that the method findMethod does not yet capture the special cases.  

A:

This question is 6 months old already and @CoronA's wonderful answer has satisfied and been accepted by @walkeros, but I thought I would add something here as I think this can be pushed an extra step. 
As discussed with @CoronA in the comments to his answer, instead of having to create and maintain a long list of MyClass methods in WrapperClass (i.e. public void methodN() { delegate.methodN(); }), the dynamic proxy solution moves this to the interface.  The issue is that you still have to create and maintain a long list of signatures for the MyClass methods in the interface, which is perhaps a bit simpler but doesn't completely solve the problem.  This is especially the case if you don't have access to MyClass in order to know all the methods. 
According to Three approaches for decorating your code, 

For longer classes, a programmer must choose the lesser of two evils:
  implement many wrapper methods and keep the type of decorated object
  or maintain a simple decorator implementation and sacrifice retaining
  the decorated object type. 

So perhaps this is an expected limitation of the Decorator Pattern. 
@Mark-Bramnik, however, gives an fascinating solution using CGLIB at Interposing on Java Class Methods (without interfaces).  I was able to combine this with @CoronaA's solution in order to create a wrapper that can override individual methods but then pass everything else to the wrapped object without requiring an interface. 
Here is MyClass. 
public class MyClass {

    public void method1() { System.out.println("This is method 1 - " + this); } 
    public void method2() { System.out.println("This is method 2 - " + this); } 
    public void method3() { System.out.println("This is method 3 - " + this); } 
    public void methodN() { System.out.println("This is method N - " + this); }

}

Here is WrapperClass which only overrides method2().  As you'll see below, the non-overridden methods are, in fact, not passed to the delegate, which can be a problem. 
public class WrapperClass extends MyClass {

    private MyClass delagate;

    public WrapperClass(MyClass delegate) { this.delagate = delegate; }

    @Override
    public void method2() {
        System.out.println("This is overridden method 2 - " + delagate);
    }

}

Here is MyInterceptor which extends MyClass.  It employs the proxy solution using CGLIB as described by @Mark-Bramnik.  It also employs @CononA's method of determining whether or not to send the method to the wrapper (if it is overridden) or the wrapped object (if it is not). 
import java.lang.reflect. Method;

import net.sf.cglib.proxy. MethodInterceptor;
import net.sf.cglib.proxy. MethodProxy;

public class MyInterceptor extends MyClass implements MethodInterceptor {

    private Object realObj;

    public MyInterceptor(Object obj) { this.realObj = obj; }

    @Override
    public void method2() {
        System.out.println("This is overridden method 2 - " + realObj);
    }

    @Override
    public Object intercept(Object arg0, Method method, Object[] objects,
            MethodProxy methodProxy) throws Throwable {
        Method m = findMethod(this.getClass(), method);
        if (m ! = null) { return m.invoke(this, objects); }
        Object res = method.invoke(realObj, objects);
        return res;
    }

    private Method findMethod(Class<? > clazz, Method method) throws Throwable {
        try {
            return clazz.getDeclaredMethod(method.getName(), method.getParameterTypes());
        } catch (NoSuchMethodException e) {
            return null;
        }
    }

}

Here is Main and the results you get if you run it. 
import net.sf.cglib.proxy. Enhancer;

public class Main {

    private static MyClass unwrapped;
    private static WrapperClass wrapped;
    private static MyClass proxified;

    public static void main(String[] args) {
        unwrapped = new MyClass();
        System.out.println(">>> Methods from the unwrapped object:");
        unwrapped.method1();
        unwrapped.method2();
        unwrapped.method3();
        wrapped = new WrapperClass(unwrapped);
        System.out.println(">>> Methods from the wrapped object:");
        wrapped.method1();
        wrapped.method2();
        wrapped.method3();
        proxified = createProxy(unwrapped);
        System.out.println(">>> Methods from the proxy object:");
        proxified.method1();
        proxified.method2();
        proxified.method3();
    }

    @SuppressWarnings("unchecked")
    public static <T> T createProxy(T obj) {
        Enhancer e = new Enhancer();
        e.setSuperclass(obj.getClass());
        e.setCallback(new MyInterceptor(obj));
        T proxifiedObj = (T) e.create();
        return proxifiedObj;
    }

}

>>> Methods from the unwrapped object:
This is method 1 - MyClass@e26db62
This is method 2 - MyClass@e26db62
This is method 3 - MyClass@e26db62

>>> Methods from the wrapped object:
This is method 1 - WrapperClass@7b7035c6
This is overridden method 2 - MyClass@e26db62
This is method 3 - WrapperClass@7b7035c6

>>> Methods from the proxy object:
This is method 1 - MyClass@e26db62
This is overridden method 2 - MyClass@e26db62
This is method 3 - MyClass@e26db62

As you can see, when you run the methods on wrapped you get the wrapper for the methods that are not overridden (i.e. method1() and method3()).  When you run the methods on proxified, however, all of the methods are run on the wrapped object without the pain of having to delegate them all in WrapperClass or put all of the method signatures in an interface.  Thanks to @CoronA and @Mark-Bramnik for what seems like a pretty cool solution to this problem. 

A:

Switch to Groovy :-) 
@CompileStatic
public class WrapperClass extends MyClass  {
    @Delegate private final MyClass delegate;

    public WrapperClass(MyClass delegate) {
        this.delagate = delegate;
    }

    //Done.  That's it. 

}

http://mrhaki.blogspot.com/2009/08/groovy-goodness-delegate-to-simplify.html

