Java通用通配符用法

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

通配符基本上表示“我不在乎此处使用哪种类型”。 对于您的情况，您一定要小心：处理器的第一个type参数必须与execute方法中的P type相同。

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

最简单的解决方案是使您的Executor类具有泛型，而不仅仅是execute方法：

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> ，当然编译器会抱怨，因为它可能与execute() P有所不同。

您可能希望将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>绝对合法。

如果您不太在意泛型并且愿意接受糟糕的设计，那么请不要使用泛型。

只需在Executor中将Processor保持为原始类型，并禁止所有未检查的警告：

即

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);
    }
}