How do I make a class, which I can't change, implement an interface?

Question

I have a class from another library that is closed-source, but I want to be able to use an interface for it. The reason being that I don\'t want to do instanceof ch

Answer 1

There are two approaches:

1. Using an adapter pattern
2. Using Proxy

The adapter approach will be simpler but less flexible, and the Proxy approach will be more complex but more flexible. Even though the Proxy approach is more complex, that complexity is all restricted to a couple of classes.

---

Adapter

The adapter pattern is simple. For your example, it would just be one class, like so:

public class QuietFooAdapter implements Foo {

    private QuietFoo quietFoo;

    public QuietFooAdapter(QuietFoo quietFoo) {
        this.quietFoo = quietFoo;
    }

    public void bar() {
        quietFoo.bar();
    }
}

Then to use it:

Foo foo = new QuietFooAdapter(new QuietFoo());
foo.bar();

This is good, but if you have more than one class to make an adapter for, this can be tedious since you'll need a new adapter for each class you have to wrap.

---

Java's Proxy Class

Proxy is a native Java class that's part of the reflection libraries that will allow you to create a more generic, reflective solution. It involves 3 parts:

1. The interface (in this case, Foo)
2. The InvocationHandler
3. Creation of the proxy (Proxy.newProxyInstance)

We already have the interface, so we're fine there.

The InvocationHandler is where we do our "auto-adapting" via reflection:

public class AdapterInvocationHandler implements InvocationHandler {

    private Object target;
    private Class targetClass;

    public AdapterInvocationHandler(Object target) {
        this.target = target;
        targetClass = target.getClass();
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        try {
            Method targetMethod = targetClass.getMethod(method.getName(), method.getParameterTypes());
            if (!method.getReturnType().isAssignableFrom(targetMethod.getReturnType()))
                throw new UnsupportedOperationException("Target (" + target.getClass().getName() + ") does not support: " + method.toGenericString());
            return targetMethod.invoke(target, args);
        } catch (NoSuchMethodException ex) {
            throw new UnsupportedOperationException("Target (" + target.getClass().getName() + ") does not support: " + method.toGenericString());
        } catch (IllegalAccessException ex) {
            throw new UnsupportedOperationException("Target (" + target.getClass().getName() + ") does not declare method to be public: " + method.toGenericString());
        } catch (InvocationTargetException ex) {
            // May throw a NullPointerException if there is no target exception
            throw ex.getTargetException();
        }
    }
}

The important code here is in the try block. This will handle the process of adapting any method calls that are called on the proxy to the inner target object. If a method is called on the interface that isn't supported (non-public, wrong return type, or just flat out doesn't exist), then we throw an UnsupportedOperationException. If we catch an InvocationTargetException, we rethrow the exception that caused it via InvocationTargetException.getTargetException. This occurs when the method we called reflectively throws an exception. Java wraps it in a new exception and throws that new exception.

Next, we need something to create the adapters:

public class AdapterFactory {

    public static  T createAdapter(Object target, Class interfaceClass) {
        if (!interfaceClass.isInterface())
            throw new IllegalArgumentException("Must be an interface: " + interfaceClass.getName());
        return (T) Proxy.newProxyInstance(null, new Class[] { interfaceClass }, new AdapterInvocationHandler(target));
    }
}

You could also nest the AdapterInvocationHandler class in the AdapterFactory class, if you like, so that everything is self-contained in AdapterFactory.

Then to use it:

Foo foo = AdapterFactory.createAdapter(new QuietFoo(), Foo.class);
foo.bar();

This approach requires more code than implementing a single adapter, but will be generic enough that it can be used to create auto-adapters for any class and interface pair, not just the QuietFoo and Foo example. Granted, this method uses reflection (the Proxy class uses reflection, as does our InvocationHandler), which can be slower, but recent improvements in the JVM have made reflection much faster than it used to be.