You essentially have a recursive type declaration.
Foo<T extends Foo<T>>
.
So let's say you have a Foo<Foo>
. That means T
is mapped to Foo
. But Foo
is not subtype of Foo<T>
, which in this case is Foo<Foo>
, so what you're really looking for is Foo<Foo<Foo>>
. But wait a minute, the innermost Foo
isn't typed, so I guess it's Foo<Foo<Foo<Foo>>>
...oh forget it!
To put a more understandable face on it, consider if you had Foo<T extends List<T>>
. What could you possibly use for T
in a declaration/instantiation of Foo
? List<String>
? List<List>
?
Edit
It looks like you found a way to "break" the recursion cycle. You eventually need to get to a reified type. In the same way that you found that ConcreteFoo
worked for you, you could similarly for the List
example above have some class ConreteListOfItself implements List<ConreteListOfItself>
that would break the recursion cycle.
与恶龙缠斗过久,自身亦成为恶龙;凝视深渊过久,深渊将回以凝视…