Problem using self-referencing type parameter

Question

I seem to be having trouble using a self-referencing type parameter (or what's the name for it ;)
Please consider this code:
class Test<T extends Test<T>> implements ITest<T> {
     public T foo() {
          // does not work?!
          //return this;
          @SuppressWarnings("unchecked")
          T result = (T) this;
          return result;
interface ITest<T extends ITest<T>> {
     T foo();
}I need ITest.foo() to return T so that it would return the correct type when used in subinterfaces. I can see that Test.foo() must return T, so that is why I declared "T extends Test<T>".
Trouble is, why does "this", which also implements ITest<T>, not satisfy the requirement of returning T?

Answer 1

This is a common question. The problem is a flawed assumption about the declaration of ITest.
The assumption is that:
interface ITest<T extends ITest<T>>means that any implementation of ITest must be parameterized by itself. This is not the case.
Consider the following
public class Test<T extends Test<T>> implements ITest<T> {
    public static void main(String[] args){
        Bar b = new Foo().foo();
    public T foo() {
        @SuppressWarnings("unchecked")
        T result = (T) this;
        return result;
class Foo extends Test<Bar> {
class Bar extends Test<Bar>{
interface ITest<T extends ITest<T>> {
}Compiles and then fails with a classcastexception.
Look again at ITest. The generic declaration requires that implementations are parameterized by self-parameterized instances of Test. That's different than saying the implementation itself is self-parameterized. The distinction is subtle but in the end you cannot declare classes that force sublcasses to be self-parameterized.
You can, however, declare methods that force their arguments to be self-parameterized.