我的问题不容易用文字解释，幸运的是它不太难演示。所以，请耐心等待:

public interface Command<R>
{
    public R execute();//parameter R is the type of object that will be returned as the result of the execution of this command
}

public abstract class BasicCommand<R> implements Command<R>
{
}

public interface CommandProcessor<C extends Command<?>>
{
    public <R> R process(C<R> command);//this is my question... it's illegal to do, but you understand the idea behind it, right?
}

//constrain BasicCommandProcessor to commands that subclass BasicCommand
public class BasicCommandProcessor<C extends BasicCommand<?>> implements CommandProcessor<C>
{
    //here, only subclasses of BasicCommand should be allowed as arguments but these
    //BasicCommand object should be parameterized by R, like so: BasicCommand<R>
    //so the method signature should really be 
    //    public <R> R process(BasicCommand<R> command)
    //which would break the inheritance if the interface's method signature was instead:
    //    public <R> R process(Command<R> command);
    //I really hope this fully illustrates my conundrum
    public <R> R process(C<R> command)
    {
        return command.execute();
    }
}

public class CommandContext
{
    public static void main(String... args)
    {
        BasicCommandProcessor<BasicCommand<?>> bcp = new BasicCommandProcessor<BasicCommand<?>>();
        String textResult = bcp.execute(new BasicCommand<String>()
        {
            public String execute()
            {
                return "result";
            }
        });
        Long numericResult = bcp.execute(new BasicCommand<Long>()
        {
            public Long execute()
            {
                return 123L;
            }
        });
    }
}

基本上，我希望通用“过程”方法指示 Command 对象的通用参数类型。目标是能够将 CommandProcessor 的不同实现限制为实现 Command 接口(interface)的某些类，同时能够调用任何实现 CommandProcessor 接口(interface)的类的 process 方法并让它返回由参数化命令对象。我不确定我的解释是否足够清楚，所以如果需要进一步解释，请告诉我。我想，问题是“这完全可以做到吗？”如果答案是“否”，最好的解决方法是什么(我自己想到了几个，但我想要一些新鲜的想法)

最佳答案

不幸的是，你不能这样做。由于您希望根据 Command 定义 CommandProcessor 接口(interface)，因此您的实现必须准备好接受任何类型的 Command 实例 - 泛型不能将其限制为 BasicCommand - 如果可以，则 BasicCommandProcessor 子类将不会实现 CommandProcessor 接口(interface)。

或者，从另一个角度来看，给定一个 CommandProcessor 接口(interface)，泛型不可能确保它只被 BasicCommand 实例调用。要做到这一点需要知道实现，并且会违背多态性和接口(interface)的观点。

您可以参数化命令的结果，但不能参数化命令的具体类。

public interface Command<R>
{
    public R execute();//parameter R is the type of object that will be returned as the result of the execution of this command
}

public abstract class BasicCommand<R> implements Command<R>
{
}

public interface CommandProcessor
{
    public <R> R process(Command<R> command);
}

public class BasicCommandProcessor implements CommandProcessor
{
    public <R> R processBasicCommand(BasicCommand<R> command)
    {
       return command.execute();
    }

    public <R> R process(Command<R> command)
    {
       return processBasicCommand((BasicCommand<R>)command);
    }
}

最简单的方法是提供一个接受您需要的特定类型的方法，并在泛型方法中调用它。 (参见上面的 BasicCommandProcessor。)

关于java - 如何正确混合泛型和继承以获得预期的结果？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/3029766/