A java method with both variable return type and variable input arguments

Question

I have an abstract java class "BaseOperation". This class only has a single abstract method:

public abstract T execute()
{
    ...

    return T;
}

Subclasses of BaseOperation must implement this method:

public class GetUsersOperation extends BaseOperation<GetUsersResponse>
{
    ...

    @Override
    public GetUsersResponse execute()
    {

        ...

        return GetUsersResponse;
    }

}

This is a great way to put all common "operation" logic in the BaseOperation class, but still have every concrete subclass's execute() method have a different return type.

Now I need to change this structure to allow the execute() methods to have a variable amount of arguments. For example, one concrete subclass would require:

execute(String, int)

and another would need:

execute(Date, Date, String)

This is tricky, because the execute method is declared in the base class. Simply overloading the execute methods in the base is not ideal. Firstly, the amount of overloads would be huge. Secondly, every subclass will only ever use one of the execute methods, what's the point of all the others?

The (in my opinion) easiest solution would be to declare the execute method with varargs:

execute(Object... arguments)

And then downcast all arguments in the subclasses:

execute(Object... arguments)
{
    String s = (String) arguments[0];
    ...
}

Obviously this has 2 major downsides:

• Reduced performance because of all the downcasting operations
• Calling the execute() methods is no longer strictly typed because any amount of objects can be passed witout compiler warnings.

Are there patterns or other solutions that could don't have these disadvantages?

Answer 1

You could use a bean holding the parameters:

public interface BaseOperation<T, U> {
    T execute(U input);
}

public class GetUsersOperation implements BaseOperation<GetUsersResponse, UserInput> {

    @Override
    public GetUsersResponse execute(UserInput input) {
        Date date = input.getDate();
        return new GetUsersResponse(date);
    }

}

Your abstract class only has one single abstract method: better use an interface. You can implement several interfaces while you can extend only one class.