Java: Creating an anonymus class from a interface passed as an argument

Question

This is related to Java 8 interfaces. I have an interface which has only a default method. I can create an anonymous instance of this interface.

public interface Itest{
    default String get(){
            return "My name is ITest";
    }
}

public class A{
     Itest itest = new Itest(){};
}

I want to create an Utility function to which provided an Interface, returns the anonymous class. Something like the following

class MyUtil{
    public static <T> T get(Class<T> interface){
        // returns the anonymous class for the interface argument
        // Something like return new interface(){};
    }
}

public class A{
     Itest itest = MyUtil.get(Itest.class);
}

Some one help me if its possible and how to achieve it inside the MyUtil.get() function?

Usecase: I have few such interfaces(with default methods). Now if there is no implementation class available for these interfaces in a setup, I want to create anonymous class instance so that can call the default methods. This will save the effort to create the implementation classes when i just need these default methods itself.

Answer 1

I don't think it is possible to create instances of an interface using Class<?>. Have you tried bypassing the MyUtil class and just make all the intefaces methods static. This would enable you to call those methods without having to initiate them. For example:

public interface Itest {
    static String get() {
        return "My name is ITest";
    }
}


public class TryingItest {

    public static void main(String[] args) {
        System.out.println(Itest.get());
    }

}

This will separate the parts of your interface which need implementing and those that are static. Hope this helps.

Answer 2

This is very interesting question. The first solution that came to my mind was a simple instantiation:

public static <T> T get(Class<T> clazz) throws ... {
    return clazz.getDeclaredConstructor().newInstance();
}

But it results in:

java.lang.NoSuchMethodException: my.package.Itest.()

Remember interfaces have no constructors and cannot be instantiated directly.

Step 1: Create dynamic proxy class

You have to use java.lang.reflect.Proxy to create a dynamic proxy class representing an anonymous class implementing interface.

public static <T> T get(Class<T> clazz) {
    return (T) java.lang.reflect.Proxy.newProxyInstance(
        clazz.getClassLoader(),
        new java.lang.Class[] { clazz },
        (proxy, method, args) -> null
    );
}

Usage:

Itest itest = MyUtil.get(Itest.class);
System.out.println(itest.getClass().getName());  // com.sun.proxy.$Proxy2
System.out.println(itest instanceof Shit.Itest); // true

// all methods invokation are completely ignored (returning null)
System.out.println(itest.get());                 // null 

The lambda expression for the InvocationHandler::invoke always returns null regardless what method with whaat arguments is called as long as it is an "empty wrapper".

Step 2: Invoke default method

As long as you want to call a default method, you can use a modified simple trick answered at How do I invoke Java 8 default methods reflectively:

public static <T> T get(Class<T> clazz) {
    return (T) java.lang.reflect.Proxy.newProxyInstance(
        clazz.getClassLoader(),
        new java.lang.Class[]{clazz},
        (proxy, method, args) -> {
            if (method.isDefault()) {
                return MethodHandles.lookup()
                    .in(method.getDeclaringClass())
                    .unreflectSpecial(method,method.getDeclaringClass())
                    .bindTo(proxy)
                    .invokeWithArguments(args);
            }
            return null;
        }
    );
}

Here we go:

Itest itest = MyUtil.get(Itest.class);
System.out.println(itest.getClass().getName());  // com.sun.proxy.$Proxy2
System.out.println(itest instanceof Shit.Itest); // true

// default methods are invoked, the implementation is taken from the interface
System.out.println(itest.get());                 // My name is ITest

Answer 3

interface Itest{
    default String get(){
            return "My name is ITest";
    }
}

class ITestImpl implements Itest {

}

class MyUtil{
    public static <T extends Itest> T get(Class<T> impl) {
        try {
            return impl.newInstance();
        } catch (InstantiationException | IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            return null;
        }
    }
}

then

Itest test = MyUtil.get(ITestImpl.class);