[ACCEPTED]-Java Reflection: Create an implementing class-interface

Accepted answer
Score: 89

Easily, java.lang.reflect.Proxy to the rescue!

Full working example:

interface IRobot {

    String Name();

    String Name(String title);

    void Talk();

    void Talk(String stuff);

    void Talk(int stuff);

    void Talk(String stuff, int more_stuff);

    void Talk(int stuff, int more_stuff);

    void Talk(int stuff, String more_stuff);
}

public class ProxyTest {
    public static void main(String args[]) {
        IRobot robot = (IRobot) java.lang.reflect.Proxy.newProxyInstance(
                IRobot.class.getClassLoader(),
                new java.lang.Class[] { IRobot.class },
                new java.lang.reflect.InvocationHandler() {

            @Override
            public Object invoke(Object proxy, java.lang.reflect.Method method, Object[] args) throws java.lang.Throwable {
                String method_name = method.getName();
                Class<?>[] classes = method.getParameterTypes();

                if (method_name.equals("Name")) {
                    if (args == null) {
                        return "Mr IRobot";
                    } else {
                        return args[0] + " IRobot";
                    }
                } else if (method_name.equals("Talk")) {
                    switch (classes.length) {
                        case 0:
                            System.out.println("Hello");
                            break;
                        case 1:
                            if (classes[0] == int.class) {
                                System.out.println("Hi. Int: " + args[0]);
                            } else {
                                System.out.println("Hi. String: " + args[0]);
                            }
                            break;
                        case 2:
                            if (classes[0] == String.class) {
                                System.out.println("Hi. String: " + args[0] + ". Int: " + args[1]);
                            } else {
                                if (classes[1] == String.class) {
                                    System.out.println("Hi. int: " + args[0] + ". String: " + args[1]);
                                } else {
                                    System.out.println("Hi. int: " + args[0] + ". Int: " + args[1]);
                                }
                            }
                            break;
                    }
                }
                return null;
            }
        });

        System.out.println(robot.Name());
        System.out.println(robot.Name("Dr"));
        robot.Talk();
        robot.Talk("stuff");
        robot.Talk(100);
        robot.Talk("stuff", 200);
        robot.Talk(300, 400);
        robot.Talk(500, "stuff");
    }
}

0

Score: 60

Creating something which pretends to implement 7 an interface on the fly actually isn't too 6 hard. You can use java.lang.reflect.Proxy after implementing InvocationHandler to 5 handle any method calls.

Of course, you could 4 actually generate a real class with a library 3 like BCEL.

If this is for test purposes, you 2 should look at mocking frameworks like jMock and 1 EasyMock.

Score: 3

If you want to go beyond interfaces, you 6 might want to take a look at cglib and objenesis. Together, they 5 will allow you to do some pretty powerful 4 stuff, extending an abstract class and instantiating 3 it. (jMock uses them for that purpose, for example.)

If 2 you want to stick with interfaces, do what 1 Jon Skeet said :).

More Related questions