如何返回扩展某些东西的泛型类型 T 的列表

Question

I have a problem with returning a list of a generic type T that extends something.

I have a base class, called A, and 2 subclasses, B and C. I want to return from a method either a list of B's or a list of C's depending on some context, but I cannot get the compiler to agree with it.

What I mean is:

import java.util.List;
import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        List<B> ls1 = new Main().method1();
        List<C> ls2 = new Main().method2(); // Won't work,
                                            // have to cast to it
        // i.e. List<C> ls2 = (List<C>) new Main().method2();

        System.out.println(ls1);
        System.out.println(ls2);
    }

    <T extends A> List<T> method1() {
        List<B> ls = new ArrayList<>();
        ls.add(new B());
        return ls; // Doesn't work now, compiler error
                   // works if I explicitly cast to it, but says
                   // unsafe or unchecked operation
                   // return (List<T>) ls;
    }

    List<? extends A> method2() {
        List<C> ls = new ArrayList<>();
        ls.add(new C());
        return ls;
    }
}

class A {
}

class B extends A {
}

class C extends A {
}

As you can see, I tried both a wildcard and an actual type T, but neither of them gets rid of the compiler error: "incompatible types".

Any help would be much appreciated, thank you.

Answer 1

To fix compile error with

List<C> ls2 = new Main().method2();

You can just do

List<? extends A> ls2 = new Main().method2();

Note, that this cannot be List<C> , it is list of something that extends A . Using cast (List<C>) is wrong here, because there is no guarantee that method2 returns list of only C, it can be, for example, a mix of C and B objects.

Upd: regarding method1 it is also wrong to do a cast to (List<T>) ls for s similar reason. Imagine you implement method1 like this

<T extends A> List<T> method1() {
    List<C> ls = new ArrayList<>();
    ls.add(new C());
    return (List<T> ) ls;
}

Then in your main method you can do following and compiler won't complain

    List<B> ls1 = new Main().method1();
    B b = ls1.get(0);
   

But you'll get a runtime ClassCastException on the line B b = ls1.get(0);

Answer 2

It is dangerous to say a list holds items of type B and allow an item of type C to exist inside of it. It is safer to say that the list contains an interface or super-class instead.

Here is a dangerous example that throws a runtime exception.

import java.util.*;

public class Main {
    public static class A {
        public String getA() { return "A"; }
        @Override public String toString() { return getA(); }
    };
    public static class B extends A {
        public String getB() { return "B"; }
        @Override public String toString() { return getB(); }
    }
    public static class C extends A {
        public String getC() { return "C"; }
        @Override public String toString() { return getC(); }
    }

    public static void main(String[] args) {
        List<B> ls1 = new Main().method3();
        List<C> ls2 = new Main().method3();

        // Will work, because toString() for each class is handled by each class.
        System.out.println(ls1);
        System.out.println(ls2);

        // Runtime errors!
        ls1.stream().map(B::getB).forEach(System.out::println);
        ls2.stream().map(C::getC).forEach(System.out::println);
    }

    public static <T extends A> List<T> method3() {
        return Arrays.asList((T) new A(), (T) new B(), (T) new C());
    }
}

The type of your list should be a common ancestor eg List<A> ls1 so that you can safely call common methods as you iterate through the list.

public static void main(String[] args) {
    List<A> ls3 = new Main().method3();

    ls3.stream().map(A::toString).forEach(System.out::println);
}