Home/ Questions/Q 803601
In Process

The Archive Base Latest Questions

Editorial Team
  • 0
Asked: 2026-05-14T23:47:09+00:00

So strange! Please have a look the code first: public class A {} public

  • 0

So strange! Please have a look the code first:

public class A {}

public class B extends A {}

public class C extends A {}

public class TestMain {

    public <T extends A> void test(T a, T b) {}

    public <T extends A> void test(List<T> a, List<T> b) {}

    public void test1(List<? extends A> a, List<? extends A> b) {}

    public static void main(String[] args) {
        new TestMain().test(new B(), new C());
        new TestMain().test(new ArrayList<C>(), new ArrayList<C>());
        new TestMain().test(new ArrayList<B>(), new ArrayList<C>());
        new TestMain().test1(new ArrayList<B>(), new ArrayList<C>());
    }
}

The statement new TestMain().test(new ArrayList<B>(), new ArrayList<C>()) gets a compilation error:

Bound mismatch: The generic method test(T, T) of type TestMain is not applicable
for the arguments (ArrayList<B>, ArrayList<C>). The inferred type
ArrayList<? extends A> is not a valid substitute for the bounded parameter
<T extends A>

However:

 new TestMain().test(new B(), new C())  --> compiled ok

 new TestMain().test(new ArrayList<C>(), new ArrayList<C>()) --> compiled ok

 new TestMain().test1(new ArrayList<B>(), new ArrayList<C>()) --> compiled ok

If we define the generic before the method name, it seems the type of the second generic List parameter must be the same as that of the first. But there is no restriction if we define generic in parameters.

Is it a feature or a bug of the compile program? Is there some documentation about it?

Share

Leave an answer

You must login to add an answer.

Need An Account,

1 Answer

  1. Editorial Team

    There is absolutely no bug; you simply misunderstood the subtyping rules in generics.

    Since we have B extends A:

    • B is a subtype of A
    • an instanceof B is also an instanceof A

    Since Java arrays are covariant:

    • B[] is a subtype of A[]
    • an instanceof B[] is also an instanceof A[]

    However, Java generics are invariant:

    • List<B> is NOT a subtype of List<A>
    • a instanceof List<B> is NOT an instanceof List<A>.

    When you have the following generic method declaration:

    public <T extends A> void test(List<T> a, List<T> b)

    Then, as it’s explicitly stated here, a and b must both have the same type, List<T>, for some capture conversion of type parameter <T extends A>.

    Since List<B> and List<C> are two different types, you can’t mix them as actual arguments for test. Also, even though B and C are subtypes of A, generics are invariant, so neither List<B> nor List<C> is a List<A>.

    Thus,

    test(new ArrayList<B>(), new ArrayList<C>()); // error!!! doesn't compile!!!

    doesn’t compile, which is expected behavior.

    See also

    Related questions

    On generics typing rules:

    On using super and extends:

    On actual generic bugs:

    • 0