Here's my first cut at the solution, but it seems very verbose and a bit awkward, especially compared to the elegance of the C++ solution. Perhaps people have ideas for improvements.

//: generics/Mixins.java
import java.util.*;

interface TimeStamped {
  long getStamp();
}

class TimeStampedImp implements TimeStamped {
  private final long timeStamp;
  public TimeStampedImp() {
    timeStamp = new Date().getTime();
  }
  public long getStamp() { return timeStamp; }
}

interface SerialNumbered {
  long getSerialNumber();
}

class SerialNumberedImp implements SerialNumbered {
  private static long counter = 1;
  private final long serialNumber = counter++;
  public long getSerialNumber() { return serialNumber; }
}

class Basic {
  private String value;
  public void set(String val) { value = val; }
  public String get() { return value; }
}

class Mixin extends Basic
implements TimeStamped, SerialNumbered {
  private TimeStamped timeStamp = new TimeStampedImp();
  private SerialNumbered serialNumber =
    new SerialNumberedImp();
  public long getStamp() { return timeStamp.getStamp(); }
  public long getSerialNumber() {
    return serialNumber.getSerialNumber();
  }
}

public class Mixins {
  public static void main(String[] args) {
    Mixin mixin1 = new Mixin(), mixin2 = new Mixin();
    mixin1.set("test string 1");
    mixin2.set("test string 2");
    System.out.println(mixin1.get() + " " +
      mixin1.getStamp() +  " " + mixin1.getSerialNumber());
    System.out.println(mixin2.get() + " " +
      mixin2.getStamp() +  " " + mixin2.getSerialNumber());
  }
} /* Output:
test string 1 1129845639046 1
test string 2 1129845639046 2
*///:~

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Date;
import java.util.HashMap;
 
interface TimeStamped {
  long getStamp();
}
 
class TimeStampedImp implements TimeStamped {
  private final long timeStamp;
  public TimeStampedImp() {
    timeStamp = new Date().getTime();
  }
  public long getStamp() { return timeStamp; }
}
 
interface SerialNumbered {
  long getSerialNumber();
}
 
class SerialNumberedImp implements SerialNumbered {
  private static long counter = 1;
  private final long serialNumber = counter++;
  public long getSerialNumber() { return serialNumber; }
}
 
class Basic {
  private String value;
  public void set(String val) { value = val; }
  public String get() { return value; }
}
 
class Mixin extends Basic {
  private TimeStamped timeStamp = new TimeStampedImp();
  private SerialNumbered serialNumber =
    new SerialNumberedImp();
  public TimeStamped getTimeStamped() { return timeStamp; }
  public SerialNumbered getSerialNumbered() {
    return serialNumber;
  }
}
 
 
class MixinProxy implements InvocationHandler {
 
    HashMap<String, Method> delegates = new HashMap<String, Method>();
    Object target;
    
    public MixinProxy(Object o, Class[] interfaces) throws SecurityException, NoSuchMethodException {
        
        this.target = o;
        for (Class clazz : interfaces) {
            Method delegateMethod = o.getClass().getMethod("get" + clazz.getSimpleName(), new Class[0]);
            for (Method m : clazz.getMethods()) {
                String methodName = m.getName();
                delegates.put(methodName, delegateMethod);
            }
        }
        
    }
    
    public Object invoke(Object proxy, Method m, Object[] args) throws Throwable {
        
        Method delegateMethod = delegates.get(m.getName());
        Object delegate = delegateMethod.invoke(target);
        return m.invoke(delegate);
    }
    
    public static Object newInstance(Object target, Class[] interfaces) throws IllegalArgumentException, SecurityException, NoSuchMethodException {
        ClassLoader cl = target.getClass().getClassLoader();
        return Proxy.newProxyInstance(cl, interfaces, new MixinProxy(target, interfaces));
    }
 
}
 
public class Test {
 
    public static void main(String[] args) throws IllegalArgumentException, SecurityException, NoSuchMethodException {
        Mixin m = new Mixin();
        Class[] interfaces = { TimeStamped.class, SerialNumbered.class };
        Object o = MixinProxy.newInstance(m, interfaces);
        TimeStamped t = (TimeStamped) o;
        SerialNumbered s = (SerialNumbered) o;
        System.out.println(t.getStamp());
        System.out.println(s.getSerialNumber());
        
    }
}

   public class MapWrapper extends DynamicDelegator implements Runnable {

       public MapWrapper(Object o) {
           super(o);
       }

       public Object put(Object key, Object value) {
           System.out.println("Put called!");
           return ((Map)wrapped).put(key,value);
       }

       public void run() {
          System.out.println("Whoohoo!");
       }
   }

      Map m = (Map) new MapWrapper(new HashMap()).getProxy();
      m.put("foo","bar");
      System.out.println( m.get("foo"));
      ((Runnable)m).run();

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
 
interface TimeStamped {
    long getStamp();
}
 
class TimeStampedImp implements TimeStamped {
    private final long timeStamp;
 
    public TimeStampedImp() {
        timeStamp = new Date().getTime();
    }
 
    public long getStamp() {
        return timeStamp;
    }
}
 
interface SerialNumbered {
    long getSerialNumber();
}
 
class SerialNumberedImp implements SerialNumbered {
    private static long counter = 1;
 
    private final long serialNumber = counter++;
 
    public long getSerialNumber() {
        return serialNumber;
    }
}
 
interface Basic {
    public void set(String val);
 
    public String get();
}
 
class BasicImp implements Basic {
    private String value;
 
    public void set(String val) {
        value = val;
    }
 
    public String get() {
        return value;
    }
}
 
class MixinProxy implements InvocationHandler {
 
    Map<String,Object> delegatesByMethod;
    
    public MixinProxy(Pair... pairs) {
        delegatesByMethod = new HashMap<String,Object>();
        
        for (Pair pair : pairs) {
            for (Method method : pair.cls.getMethods()) {
                String methodName = method.getName();
                // The first interface in the map is the one that implements
                // The method.
                if (!delegatesByMethod.containsKey(methodName)) {
                    delegatesByMethod.put(methodName, pair.obj);
                }
            }
        }
    }
    
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        String methodName = method.getName();
        Object delegate = delegatesByMethod.get(methodName);
        return method.invoke(delegate, args);
    }
 
    public static Object newInstance(Pair... pairs) {
        
        Class[] interfaces = new Class[pairs.length];
        
        for (int i = 0; i < pairs.length; i++) {
            interfaces[i] = pairs[i].cls;
        }
        
        ClassLoader cl = pairs[0].obj.getClass().getClassLoader();
        return Proxy.newProxyInstance(cl, interfaces, new MixinProxy(pairs));
    }
}
 
class Pair {
    Object obj;
    Class cls;
    public Pair(Object obj, Class cls) {
        this.obj = obj;
        this.cls = cls;
    }
}
 
 
public class MixinTest {
 
    public static void main(String[] args) {
        
        Object mixin = MixinProxy.newInstance(
                new Pair(new BasicImp(), Basic.class),
                new Pair(new TimeStampedImp(), TimeStamped.class),
                new Pair(new SerialNumberedImp(), SerialNumbered.class)
        );
        
        Basic b = (Basic) mixin;
        TimeStamped t = (TimeStamped) mixin;
        SerialNumbered s = (SerialNumbered) mixin;
        b.set("Hello");
        System.out.println(b.get());
        System.out.println(t.getStamp());
        System.out.println(s.getSerialNumber());
    }
}