Question

I have the following code:

public class Foo {

    interface Coo<T> {
        public T cool();
    }

    abstract class Bar<T extends Bar<T>> implements Coo<T>  {

        @SuppressWarnings("unchecked")
        T doSomething() {
            return (T) this;
        }

        @SuppressWarnings("unchecked")
        @Override
        public T cool() {
            return (T) this;
        }

    }

    class FooBar extends Bar<FooBar> {
        @Override
        public FooBar cool() {
            return super.cool();
        }

    }
}

Why is the cast to (this) object type unsafe? When Bar implements Coo, isn’t the generic saying that returned cool must be of type T, which extends Bar or its subclasses?

Answer 1

Because this in Bar has type Bar<T extends Bar<T>> but not T, the compiler generates warnings for Bar#doSomething. The following won’t generate any warnings:

abstract class Bar<T extends Bar<T>> {

    Bar<T> doSomething() {
        return this;
    }

}

The body of Bar#cool expects this to be a subtype of T which is not the case. In Bar#cool, this has type Bar<T extends Bar<T>> and is a subtype of Coo<T> but not T.