java - 为什么这不起作用而这不起作用？ (Java 泛型，命名泛型类型与未命名)

Question

很抱歉，除了举个例子，我不知道如何用其他方式表达我的问题:

public interface IStuff<GenericParameter>{}

public interface IWorkWithStuff<GenericParameter>
{
    void doSomethingWithStuff(IStuff<GenericParameter> stuff);
}

public interface IBoth<GenericParameter>
extends IStuff<GenericParameter>, IWorkWithStuff<GenericParameter>
{}

public class Test<Both extends IBoth<?>>
{
    Both _myBoth;
    void test(final Both otherBoth)
    {
        _myBoth.doSomethingWithStuff(otherBoth);
    }
}

这不编译，有人可以解释为什么吗？错误是:

The method doSomethingWithStuff(IStuff) in the type IWorkWithStuff is not applicable for the arguments (Both)

另一方面，如果我给参数命名，它会起作用:

public class Test<NamedParameter, Both extends IBoth<NamedParameter>>
{
    Both _myBoth;
    void test(final Both otherBoth)
    {
        _myBoth.doSomethingWithStuff(otherBoth);
    }
}

这看起来和我很相似(除了第二种解决方案在我遇到这个问题的实际情况下对我来说不可行)，有人能解释一下这有什么不同吗？

非常感谢!

---

我补充说我用 Java 1.6 和 Java 1.8 测试过

编辑

来自 awsome 的回答给了我 一个解决方案 。

在the link he pointed有一个部分名称 "Capture helpers"解释避免此类问题的方法。

在我的例子中，这段代码有效:

public class WorkingTest<Both extends IBoth<?>>
{
    Both _myBoth;

    void test(final Both otherBoth)
    {
        final IBoth<?> myBoth = _myBoth;
        final IBoth<?> _otherBoth = otherBoth;
        rebox(myBoth, _otherBoth);
    }

    protected <Something, SomethingElse> void rebox(final IBoth<Something> both, final IBoth<SomethingElse> otherBoth)
    {
        both.doSomethingWithStuff(both);
    }
}

它在类型有效时有效，在类型无效时失败。

谢谢!

编辑

糟糕，我的“解决方案”中有一个错误:

我写了

        both.doSomethingWithStuff(both);

代替

        both.doSomethingWithStuff(otherBoth);

这不起作用(并且有意义)。

我现在找到的唯一解决方案是使用 cast :

public class WorkingTest<Both extends IBoth<?>>
{
    Both _myBoth;

    public WorkingTest(final Both myBoth)
    {
        _myBoth = myBoth;
    }

    void test(final Both otherBoth)
    {
        deboxrebox(_myBoth, otherBoth);
    }

    @SuppressWarnings("unchecked")
    protected <CommonParent> void deboxrebox(final Both first, final Both second)
    {
        final IBoth<CommonParent> _first = (IBoth<CommonParent>) first;
        final IBoth<CommonParent> _second = (IBoth<CommonParent>) second;
        _first.doSomethingWithStuff(_second);
    }
}

至少，它封装了 Actor 阵容，但仍然不是很令人满意。

您认为使用“捕获助手”可以找到更好的解决方案吗？

Answer 1

这里对您的示例进行了一些修改，以了解您面临的问题

    public class Test<Both extends IBoth<?>> {

    IBoth<?> hello;

    void test(final Both otherBoth) {
        hello.doSomethingWithStuff(hello);  // The method doSomethingWithStuff(IStuff<capture#1-of ?>) in the type IWorkWithStuff<capture#1-of ?> is not applicable for the arguments (IBoth<capture#2-of ?>)
        hello.doSomethingWithStuff(hello); // The method doSomethingWithStuff(IStuff<capture#3-of ?>) in the type IWorkWithStuff<capture#3-of ?> is not applicable for the arguments (IBoth<capture#4-of ?>)
    }
}

interface IStuff<S> {
}

interface IWorkWithStuff<T> {
    void doSomethingWithStuff(IStuff<T> stuff);
}

interface IBoth<U> extends IStuff<U>, IWorkWithStuff<U> {
}

我还写了 doSomethingWithStuff 方法调用的错误。您会看到每次进行新调用时都会捕获#xxx 更改。这里的数字xxx表示这是一种新的未知类型。 更多关于通配符的信息可以在这里阅读 http://www.ibm.com/developerworks/java/library/j-jtp04298/index.html