Java：将类名传递给函数

Question

I have three very similar functions and want to refactor. However, the functions use a function from a class, thus, I wonder if there is a way to pass the class / class name to the function?

new GenericClass1 = genericClass1;
new GenericClass2 = genericClass2;
new GenericClass3 = genericClass3;

public ReturnsClass1 myFunction1 (){
    return genericClass1.functionFromClass(paramter);
}
public ReturnsClass2 myFunction2 (){
    return genericClass2.functionFromClass(paramter);
}
public ReturnsClass3 myFunction3 (){
    return genericClass3.functionFromClass(paramter);
}

To illustrate I would like something like this:

public ReturnsClass myFunction (classInstance) {
    return classInstance.functionFromClass(parameter);
}

Answer 1

You can make GenericClass* implement a common generic interface, in which the method returns an instance of the generic type parameter.

interface GenericInterface<T> {
    T functionName(Object parameter); //change parameter type
}

This can then be extended by GenericClass* :

class GenericClass1 implements GenericInterface<ReturnsClass1> {
    public ReturnsClass1 functionName(Object parameter) {
        ...
    }
}

In the same manner, GenericClass2 will implement GenericInterface<ReturnsClass2> and GenericClass3 will implement GenericInterface<ReturnsClass3> .

Your method will then look like this:

public <T> T myFunction (GenericInterface<T> classInstance) {
    return classInstance.functionName(parameter);
}

Answer 2

You could try using java.util.function.Function<T, R> .

It may look like this:

public <R> R myFunction (Function<Object, R> func) {
    return func.apply(parameter);
}

Usage:

ReturnClass1 rc1 = myFunction(genericClass1::functionFromClass);
ReturnClass2 rc2 = myFunction(genericClass2::functionFromClass);

The pros of this approach is that you don't need your generic classes to share an interface and all refactoring goes into myFunction . This interface is a functional interface that was introduced in Java 8, you can read more about it in the docs . Simply what it does, it defines a function that accept a single agrument of type T and returns a value of type R .

And the wierd looking :: is a method reference