Normally (i. e. in the non-proxy case), one would do something like this:

protected Object invokeDelegated( Method m, Object[] args,
                                   Object delegate ) throws Exception
{
   // m is a method from an interface that is not implemented by delegate
   // find the corresponding method in delegate interface and invoke
   Class<?>[] parameterTypes = new Class[args.length];
   for( int i = 0; i < args.length; i++ ) {
     parameterTypes[i] = args[i].getClass();
   }
   Method meth = delegate.getClass().getMethod( m.getName(),
                                                parameterTypes );
   return meth.invoke( delegate, args );

import java.lang.reflect.*;

public class GetProxyClass {
     public static void main(String[] args) throws Exception {
         ClassLoader classLoader =
             ClassLoader.getSystemClassLoader();
         InvocationHandler behaviour = new InvocationHandler() {
                 public Object invoke(Object proxy, Method method,
                                      Object[] args) {
                     System.out.println("Called " + method);
                     return null;
                 }
             };
         Object proxy =
             Proxy.newProxyInstance(classLoader,
                                    new Class<?>[] { Runnable.class },
                                    behaviour);
         Class<?>  proxyClass = proxy.getClass();
         System.out.println("Proxy class is: " + proxyClass);

         Method m = proxyClass.getMethod("run", new Class<?>[0]);
         ((Runnable) proxy).run();
         m.invoke(proxy);
     }

Proxy class is: class $Proxy0
Called public abstract void java.lang.Runnable.run()
Called public abstract void java.lang.Runnable.run()

It also demonstrates a method on the implemented interface being looked
up and invoked.