Question

这与java通用外卡有关。

我有这样的界面。

public interface Processer<P, X> {
    void process(P parent, X result);
}

这样的实现。

public class FirstProcesser implements Processer<User, String> {
    @Override
    public void process(User parent, String result) {

    }
}

我正在使用处理器。

public class Executor {
    private Processer<?, String> processer;

    private  int i;
    public void setProcesser(Processer<?, String> processer) {
        this.processer = processer;
    }

    private String generateString() {
        return "String " + i++;
    }

    public <P> void execute(P parent) {
        processer.process(parent, generateString());
    }

    public static void main(String[] args) {
        Executor executor = new Executor();
        executor.setProcesser(new FirstProcesser());
        User user = new User();
        executor.execute(user);
    }
}

但是这里

public <P> void execute(P parent) {
    processer.process(parent, generateString());
}

它给出编译错误错误：（18,27）java：不兼容类型：P无法转换为捕获＃1的？

我需要理解为什么会出错。也解决方案。

Answer 1

通配符基本上意味着“我不关心这里使用哪种类型”。在您的情况下，您肯定会关注：处理器的第一个类型参数必须与execute方法中的P类型相同。

使用当前代码，您可以调用execute(1)，它会尝试使用整数作为参数调用FirstProcesser，这显然没有意义，因此编译器禁止它。

最简单的解决方案是使您的Executor类成为通用的，而不仅仅是执行方法：

public class Executor<P> {
    private Processer<P, String> processer;

    private int i;
    public void setProcesser(Processer<P, String> processer) {
        this.processer = processer;
    }

    private String generateString() {
        return "String " + i++;
    }

    public void execute(P parent) {
        processer.process(parent, generateString());
    }

    public static void main(String[] args) {
        Executor executor = new Executor<User>();
        executor.setProcesser(new FirstProcesser());
        User user = new User();
        executor.execute(user);
    }
}

Answer 2

因为processor可以有任何东西的第一个类型参数。您可能已为其分配了Process<Foo, String>，当然编译器会抱怨，因为它可能与P中的execute()不同。

您可能希望将Executor作为通用类：

class Executor<T> {
    private Processer<T, String> processer;

    public void setProcesser(Processer<T, String> processer) {
        this.processer = processer;
    }

    public void execute(T parent) {
        processer.process(parent, generateString());
    }
}

，您的main将如下所示：

    Executor<User> executor = new Executor<User>();
    executor.setProcesser(new FirstProcesser());
    User user = new User();
    executor.execute(user);

回应评论：

这里没有正确使用泛型的正确解决方案，因为你所做的是矛盾的：一方面你说你不关心Processor的第一类型参数（因此private Processor<?, String> processor），但另一方面，你真的关心它（你的execute）。编译器只是正确地完成其工作，因为为您分配Processor<Foo,String>绝对合法。

如果你真的不关心仿制药，并且愿意设计不好，那就不要使用仿制药。

在Processor中保留Executor原始类型，并取消所有未经检查的警告：

即。

class Executor {
    private Processor processor;

    @SuppressWarnings("unchecked")
    public void setProcessor(Processor<?, String> processor) {
        this.processor = processor;
    }

    // your generic method does not do any meaningful check.
    // just pass an Object to it
    @SuppressWarnings("unchecked")
    public void execute(Object parent) {
        processor.process(parent, "");
    }
}

如果是我，我会更进一步：

提供经过适当设计的执行程序（例如，将其称为TypedExecutor）。所有新代码都应使用新设计的TypedExecutor。原始Executor是为了向后兼容而保留的，并将其工作委托给TypedExecutor。

因此看起来像：

class TypedExecutor<T> {
    private Processor<T, String> processor;

    public void setProcessor(Processor<T, String> processor) {
        this.processor = processor;
    }

    public void execute(T parent) {
        processor.process(parent, "");
    }
}

@SuppressWarnings("unchecked")
class Executor {
    private TypedExecutor executor = new TypedExecutor();

    public void setProcessor(Processor<?, String> processor) {
        this.executor.setProcessor(processor);
    }

    public void execute(Object parent) {
        this.executor.execute(parent);
    }
}

Java通用通配符用法

2 个答案: