Inheritance of nested generics [object orientation]

Question

Idealized scenario

Let's imagine a scenario, with 2 classes like A and B where B extends A. I also have a third generic class C<T> with a method m(T t).

If I create a object C<C<A>> container and another object C obj = new C<>(); why can't I run container.m(obj)?

Full code example

public class Test {
    class A {}
    class B extends A {}
    class C<T> {
        void m(T t) {}
    }
    void test() {
        C<C<A>> container = new C<>();
        C<B> obj = new C<>();

        container.m(obj);
    }
}

Practical case

This Issue becomes apparent with nested lists where the C<A> in my simplified example would be a a List<A>.

Oracle highlights some limitations of generics, but I can't find anything describing this issue and how to deal with it.

Because `C` is not a subclass of `C`. Consider a `List` and a `List`: The first List may contain Integers, Doubles, Floats, Shorts, etc. The second list cannot be treated like a `List` because it is not allowed to contain anything other than Integer elements. — VGR, Mar 25 '23 at 16:09
PECS. Producer Extends, Consumer Super. `C> container = new C<>();` — Elliott Frisch, Mar 25 '23 at 16:10
@VGR I am not sure if I understand you correctly, but shouldn't the `List` lose the distinct properties of `Integer` and behave like `List`. I get the base argument, but isn't this inconsistent with java's normal way of implicitly type conversion? — derdilla, Mar 25 '23 at 16:21
No. `List` is **not** a subclass of `List`. It does not inherit anything from `List`. It cannot be used in place of a `List`. — VGR, Mar 25 '23 at 16:22
Related: [Is List a subclass of List? Why are Java generics not implicitly polymorphic?](https://stackoverflow.com/q/2745265) — Pshemo, Mar 25 '23 at 16:32

derdilla · Answer 1 · 2023-03-25T17:15:19.400

The issue

As VGR pointed out: C doesn't extend C<A>.

So C other than B itself, doesn't have any properties of C<A>.

This becomes more clear, when looking at what C<A> and C generate: C<A> acts like a

class D {
    void m(A t) {}
}

while C acts like a

class E {
    void m(B t) {}
}

When looking at it in this unraveled fashion, it becomes apparent, that class E doesn't extend class D.

The solution

As Elliott Frisch said, this can be avoided by changing C<A> to C<? extends A>.

Full working example:

public class Test {
    class A {}
    class B extends A {}
    class C<T> {
        void m(T t) {}
    }
    void test() {
        C<C<? extends A>> container = new C<>();
        C<B> obj = new C<>();
        container.m(obj);
    }
}