Java Generics return type issue

Question

I have the following method:

public <T extends Result> T execute(Command<T> command)
{
     return new LoginResult();
}

Here, Result is an interface, and the class LoginResult does implement this interface. However, I'm getting the error:

Incompatible types, required: T, found: com.foo.LoginResult

Yet if I change the method signature to:

public Result execute(Command<T> command)

Then the same return line works fine, without any error.

What's the issue here? And how can I return LoginResult from this method?

Edit: The reason I want to use generics, is so I can do something like the following:

Command<LoginResult> login = new Command<>();
 LoginResult result = execute( login );

Answer 1

You can't do this because the compiler can't confirm that LoginResult is of type T, since it's inferred at the call site (i.e. the caller decides which type parameter will be used).

Answer 2

To answer your edited question,

there's no way to do that without an explicit cast. So the simplest (yet brutal) solution would be:

public <T extends Result> T execute(Command<T> command) {
    return (T) new LoginResult();
}

But this way you take the full responsibility for instantiating the right result for the right command, as the compiler won't help you any more.

The only thing that could help you instantiate things dynamically would be a reference to the actual Class<T>.

So if you add a method like Class<T> getResultType() to your command, you would be able to write:

return command.getResultType().newInstance(); // instead of new SpecificResult()

This of course implies that you have a default constructor in each Result implementation and so on...

A more OO friendly approach (no reflection) would be to let the command instantiate its own result (with a factory method T instantiateResult()):

return command.instantiateResult();

Answer 3

Expanding on SimonC's answer a little bit.

Consider you have classes:

Result

LoginResult extends Result

OtherResult extends Result

If your type T is OtherResult then trying to return a LoginResult is nonsense. The compiler will only compile it if it can GUARANTEE sensibility at compile time. As it stands it cannot, since T can be an incompatible type with LoginResult.

A return type of <T extends Result> does NOT mean that you have to return something that is a Result. It means that you need to return something that is a T, but T has to be a subclass of Result

Regarding your edit

Edit: The reason I want to use generics, is so I can do something like the following:

Command<LoginResult> login = new Command<>();
 LoginResult result = execute( login );

I'm not sure exactly what execute should do, but my first thought is to make execute an instance method of Command.

Then you would have

public T execute()
{

}

The problem is you need a way to instantiate LoginResult. This is where we need more information into your specific problem to give a detailed answer.

I would make a static method in Result called newInstance. Then since you know T is some subclass of result you can call T.newInstance(). Then your would-be constructor for loginResult can be private, and you call it through it's newInstance method.

This requires your Command to be defined as:

public class Command<T extends Result>

And Result must have a method with signature:

public static Result newInstance()

Another concern that may arise is that you don't want to constrain Command to Results. That's fine, you can make a new class:

public class ResultCommand<T extends Result> extends Command

Answer 4

The safer solution than an unchecked cast:

public <T extends Result> T execute(Command<T> command, Class<T> cls)
{
    return cls.cast(new LoginResult());
}

LoginResult result = execute(loginCommand, LoginResult.class);

The rationale behind having both parameters is that the contract of execute is implied to be:

• Either use a method of Command to obtain a result of type T to return it.
• Or create a result in some other way, but ensure it is of type T by downcasting it.

With Java's generics, only parameters to a generic method of the form <T> T foo(Bar<T>, Baz<T>) can safely "create" an object of the type T. Thus, if in your case, you're not creating the result using the command parameter, you need another parameter that can take care of the type check.

Answer 5

The compiler needs to know the return value will match type T and it can't. It will match if you pass Command as parameter but it may not if you pass Command since T will be defined to that other type.

You can cast it at runtime and it will throw ClassCastException if the object you are returning does not match T.

public <T extends Result> T execute(Command<T> command, Class<T> type)
{

     return type.cast( new LoginResult() );
}

You would call it this way:

Command<LoginResult> login = new Command<>();
LoginResult result = execute( login, LoginResult.class );

Note the redundant information here but it is needed since generics are lost in compilation.