Force an object expose an interface at runtime, through a generated proxy class. It must implement all required methods.
Requires BCEL.

UPDATED: does verification at bridge generation time.
expose(Object, Class) will search for the correct public target type to use.
UPDATED: performance hacks.

Example usage:

public class BridgeTest {
  public interface CharList {
    public int length();
    public char charAt(int i);
  }
  void print(CharList l) {
    for(int i=0; i<l.length(); i++)
      System.out.print(l.charAt(i));
  }
  public static void main(String args[]) {
    CharList list = Bridge.expose("Hello world\n", CharList.class);
    print(list);
  }
}

Bridge.java:

/* Make an object expose an interface at runtime */

import org.apache.bcel.generic.*;
import org.apache.bcel.Constants;

import java.lang.reflect.Method;
import java.util.*;

public abstract class Bridge<C,I> {
	protected C __target; // the implementation of the interface
	private final void __init(Object target) { this.__target = (C)target; }

	// cache already-generated bridges
	private static HashMap<Class, HashMap<Class, Class>> cache 
		= new HashMap<Class, HashMap<Class, Class>>();
	// allow injection of classes from byte arrays
	private static InjectingClassLoader loader = new InjectingClassLoader();

	private static final void cacheSet(Class key1, Class key2, Class value) {
		HashMap<Class,Class> intermediate = cache.get(key1);
		if(intermediate == null)
			cache.put(key1, intermediate = new HashMap<Class,Class>());
		intermediate.put(key2, value);
	}
	private static final Class cacheGet(Class key1, Class key2) {
		HashMap<Class,Class> intermediate = cache.get(key1);
		if(intermediate == null)
			return null;
		return intermediate.get(key2);
	}

	// returns [ [ifaceMethods...] [fromMethods...] ]
	private static Method[][] getMapping(Class from, Class iface) throws NoSuchMethodException,IllegalAccessException {
		if(!iface.isInterface())
			throw new IllegalArgumentException(iface.getName()+" is not an interface");
		if(!java.lang.reflect.Modifier.isPublic(from.getModifiers()))
			throw new IllegalAccessException(from.getName()+" is not public");
		java.lang.reflect.Method[][] map = new java.lang.reflect.Method[2][];
		map[0] = iface.getMethods();
		map[1] = new java.lang.reflect.Method[map[0].length];

		for(int i=0;i<map[0].length;i++) {
			try {
				Method match = from.getMethod(map[0][i].getName(), map[0][i].getParameterTypes());
				if(!map[0][i].getReturnType().isAssignableFrom(match.getReturnType()))
					throw new NoSuchMethodException("Return type "+match.getReturnType().getName()+
						" of "+toString(match)+" is not compatible with return type "+
						map[0][i].getReturnType().getName()+" of "+toString(map[0][i]));
				map[1][i] = match;
			} catch (NoSuchMethodException e) {
				throw new NoSuchMethodException("Couldn't find "+toString(map[0][i])+" in "+
					from.getName());
			}			
		}
		return map;
	}
	private static String toString(Method m) {
		StringBuffer sb = new StringBuffer(m.getDeclaringClass().getName());
		sb.append(".").append(m.getName()).append("(");
		boolean first=true;
		for(Class c : m.getParameterTypes()) {
			if(!first)
				sb.append(", ");
			sb.append(c.getName());	
			first=false;
		}
		sb.append(")");
		return sb.toString();
	}

	private static <C,I> Class<? extends Bridge<C,I>> create(Class<C> from, Class<I> iface) {
		try {
			Method[][] map = getMapping(from, iface);

			String bridgeName = "Bridge_"+from.getSimpleName()+"_"+iface.getSimpleName();
			// public class Bridge_Thing_Mungible extends Bridge<Thing,Mungible> implements Mungible
			ClassGen cg = new ClassGen(
				bridgeName,
				Bridge.class.getName(), // superclass name
				"<generated>", // source file name
				Constants.ACC_PUBLIC | Constants.ACC_FINAL | Constants.ACC_SUPER, // flags
				new String [] { iface.getName() } // interfaces
			);

			ConstantPoolGen cpg = cg.getConstantPool();
			InstructionFactory factory = new InstructionFactory(cg, cpg);

			ReferenceType targetType = (ReferenceType)Type.getType(from);

			for(int i=0; i<map[0].length; i++) {
				Method imeth = map[0][i];
				Method fmeth = map[1][i];

				Type 	ireturnType = Type.getType(imeth.getReturnType()),
					freturnType = Type.getType(fmeth.getReturnType());
				Class[]	iargs = imeth.getParameterTypes(), 
					fargs = fmeth.getParameterTypes();
				Type[] 	iargsT = new Type[iargs.length],
					fargsT = new Type[fargs.length];
				String[] argNames = new String[iargs.length];
				for(int j=0; j<iargs.length; j++) {
					iargsT[j] = Type.getType(iargs[j]);
					fargsT[j] = Type.getType(fargs[j]);
					argNames[j] = "arg"+i;
				}

				InstructionList il = new InstructionList();
				// public int munge(Object arg0, int arg1) {
				MethodGen mg = new MethodGen(
					Constants.ACC_PUBLIC,
					ireturnType,
					iargsT,
					argNames,
					imeth.getName(),
					bridgeName,
					il, cpg);

				// (Thing)this.__target
				il.append(new ALOAD(0));
				il.append(factory.createFieldAccess(
					Bridge.class.getName(), 
					"__target", 
					Type.OBJECT, 
					Constants.GETFIELD));
				il.append(factory.createCheckCast(targetType));
				
				// .munge(arg0, arg1);
				int position = 1;
				for(int j=0;j<iargs.length;j++) {
					il.append(factory.createLoad(iargsT[j], position));
					position += iargsT[j].getSize();
				}
				il.append(factory.createInvoke(
					from.getName(), 
					fmeth.getName(), 
					freturnType, 
					fargsT, 
					from.isInterface() ? Constants.INVOKEINTERFACE : Constants.INVOKEVIRTUAL));

				// return (last result, if any)
				il.append(factory.createReturn(ireturnType));

				mg.setMaxStack();
				cg.addMethod(mg.getMethod());
				il.dispose(); // Allow instruction handles to be reused
			}

			// public Bridge_Thing_Mungible() { super(); }
			cg.addEmptyConstructor(Constants.ACC_PUBLIC);

			try { cg.getJavaClass().dump("proxy.class"); } catch(Exception e) { throw new RuntimeException(e); }

			byte[] classData = cg.getJavaClass().getBytes();
			Class c = loader.load(cg.getClassName(), classData);
			return (Class<Bridge<C,I>>)c;
		} catch (IllegalAccessException e) { 
			throw new BridgeFailure(from, iface, e); 
		} catch (NoSuchMethodException e) { 
			throw new BridgeFailure(from, iface, e); 
		}
	}
	private static <C,I> Class<? extends Bridge<C,I>> get(Class<C> from, Class<I> iface) {
//		Pair<Class,Class> key = new Pair<Class,Class>(from, iface);
		Class<? extends Bridge<C,I>> bridgeClass = (Class<? extends Bridge<C,I>>)cacheGet(from, iface);
		if(bridgeClass == null) {
			bridgeClass = create(from, iface);
			cacheSet(from, iface, bridgeClass);
		}
		return bridgeClass;
	}

	// Expose interface iface by creating a proxy. 
	// the type of target must be from, a subclass of from, or a class implementing from.
	// from must be public, and must expose all methods in iface.
	public static <I> I expose(Object target, Class from, Class<I> iface) {
		try {
			Class<? extends Bridge<?,I>> c = Bridge.get(from, iface);
			Bridge<?,I> proxy = c.newInstance();
			proxy.__init(target);
			return (I)proxy;
		} catch (InstantiationException e) {
			throw new RuntimeException(e);
		} catch (IllegalAccessException e) {
			throw new RuntimeException(e);
		}
	}
	
	// Expose interface iface by creating a proxy. 
	// Tries expose(target, target.getClass(), iface) first.
	// then works up the class hierarchy. If doesn't find a public superclass 
	// that exposes all methods, it tries interfaces.
	// if you know in advance the class or interface that exposes the needed methods,
	// use expose(target, Class.forName("ExposingClass"), iface).
	public static <I> I expose(Object target, Class<I> iface) {
		Class tClass = target.getClass();

		Class from = tClass;
		do {			
			try {
				I result = expose(target, from, iface);
				if(tClass != from) // if tClass == tFrom then get() sets the cache
					cacheSet(tClass, iface, result.getClass());
				return result;
			} catch (BridgeFailure e) {
				Throwable cause = e.getCause();
				if(cause instanceof NoSuchMethodException) {
					// have traced superclass up until the interface isn't satisfied.
					// try interfaces and then give up.
					// in the case of a private implementation of a public interface, 
					// this allows you to subset the interface.
					Class[] targetIfaces = target.getClass().getInterfaces();
					for(Class targetIface : targetIfaces) 
						try {
							I result = expose(target, targetIface, iface);
							cacheSet(tClass, iface, result.getClass()); // perf hack
							return result;
							// ignore, reported exception is that for class hierarchy.
						} catch (BridgeFailure ex) {} 
					throw new BridgeFailure(target, iface, e);
				} else if(!(cause instanceof IllegalAccessException))
					throw e;
			}
			from = from.getSuperclass();
		} while(from != null);
		throw new RuntimeException("Object "+target+" ("+target.getClass().getName()+") has no public superclass");
	}
}
class BridgeFailure extends RuntimeException {
	public BridgeFailure(Class from, Class iface, Exception cause) {
		super("Could not map class "+from.getName()+" to interface "+iface.getName());
		initCause(cause);
	}
	public BridgeFailure(Object target, Class iface, Exception cause) {
		super("Could not map first public supertype of " + target +
			" (" + target.getClass().getName() + ")," +
			" or any implemented interface, to interface " + iface.getName());
		initCause(cause);
	}
}
// ClassLoader implementation to let you load classes from byte arrays
class InjectingClassLoader extends ClassLoader { 
	public InjectingClassLoader() {
		super(InjectingClassLoader.class.getClassLoader());
	}
	public Class load(String name, byte[] buffer) {  
		return defineClass(name, buffer, 0, buffer.length);  
	}  
}