Java 为什么不编译以下带有循环泛型的代码？

下面是我的代码

class A<B2 extends B, A2 extends A<B2, A2>> {
    C<B2, A2> c;

    void test() {
        c.acceptParameterOfTypeA(this);
    }

}

class B {

}

class C<B2 extends B, A2 extends A<B2, A2>> {
    void acceptParameterOfTypeA(A2 a) {

    }
}

A类{
C C；
无效测试（）{
c、 acceptParameterOfTypeA（this）；
}
}
B类{
}
C类{
类型a的无效接受参数（A2 a）{
}
}

错误发生在

c.acceptParameterOfTypeA（此）

错误是

类型C中的方法acceptParameterOfTypeA（A2）不可用
适用于参数（A）

据我所见，方法
acceptParameterOfTypeA
需要一个类型为a的参数，而给出错误的行中的
this
是类型a的参数

我做错了什么？如何解决这个问题

如果重要的话，我将使用Java8，我将再次重命名您的类，这样所有内容都更可读。那么，让我们有：

public class First<T extends Second, U extends First<T, U>> {
    Third<T, U> c;

    void test() {
        c.acceptParameterOfTypeA(this);
    }

}

class Second {

}

public class Third<X extends Second, Y extends First<X, Y>> {
    void acceptParameterOfTypeA(Y a) {

    }
}

什么是
U
U
是
First
的子类型

但是，如果类型擦除后
U
可以替换为
First
，这将意味着
首先扩展了First
，这是不正确的，因为
U
代表
First
的子类型，该子类型由
Second
和
First
的一些具体子类型参数化

为了获得
U
，您可以应用所谓的
获取此
方法

首先，由于您需要
U
，这是
First
的子类型，但无法从
First
获取它，因此可以引入一个
abstract
方法来返回它：

abstract class First<T extends Second, U extends First<T, U>> {
    Third<T, U> c;

    void test() {
        c.acceptParameterOfTypeA(getU());
    }

    abstract U getU();

}

在
getU（）
因为这将返回超级类中
U
的正确替代项

更多信息：




简单地说，
c.acceptParameterOfTypeA（）
接受
A2
此
的类型为
A
，不知道该类型是否扩展了
A2
。只知道
A2
扩展了
A
根据
kocko
的回答，原来的问题有相同的解决方案：

public class Main {
    abstract class A<A2 extends A<A2, B2>, B2 extends B<A2, B2>> {
        B2 b;

        void test() {
            b.testMethod(getThis()); //getThis() instead of this;
        }

        abstract A2 getThis();
    }

    class B<A2 extends A<A2, B2>, B2 extends B<A2, B2>> {
        void testMethod(A2 a) {

        }
    }

    public void execute() {

    }

    public static void main(String[] args) {
        Main main = new Main();
        main.execute();
    }
}

公共类主{
抽象A类{
b2b；
无效测试（）{
b、 testMethod（getThis（））；//用getThis（）代替此；
}
抽象A2 getThis（）；
}
B类{
无效测试方法（A2 a）{
}
}
public void execute（）{
}
公共静态void main（字符串[]args）{
Main Main=新Main（）；
main.execute（）；
}
}
我们可以通过删除不导致问题的
B
部分来简化它-

class A<T extends A<T>>
{
    void test(C<T> c)
    {
        c.acceptParameterOfTypeA(this);  // ERROR
    }
}

class C<T extends A<T>>
{
    void acceptParameterOfTypeA(T a) {}
}

A类
{
空隙试验（C）
{
c、 acceptParameterOfTypeA（this）；//错误
}
}
C类
{
void acceptParameterOfTypeA（ta）{}
}

此
类型为
A
；问题是
A
B类{
在那里，
A
参数对我来说是否是原始的。@EpicPandaForce是的，我想我可能得到了错误的示例。我将尝试看看我是否可以改进。谢谢！@EpicPandaForce谢谢，我用我面临的实际场景更新了问题。你可以将问题简化为：
A类{void test（）{A2 x=this；}}
public class Main {
    abstract class A<A2 extends A<A2, B2>, B2 extends B<A2, B2>> {
        B2 b;

        void test() {
            b.testMethod(getThis()); //getThis() instead of this;
        }

        abstract A2 getThis();
    }

    class B<A2 extends A<A2, B2>, B2 extends B<A2, B2>> {
        void testMethod(A2 a) {

        }
    }

    public void execute() {

    }

    public static void main(String[] args) {
        Main main = new Main();
        main.execute();
    }
}

class A<T extends A<T>>
{
    void test(C<T> c)
    {
        c.acceptParameterOfTypeA(this);  // ERROR
    }
}

class C<T extends A<T>>
{
    void acceptParameterOfTypeA(T a) {}
}