Java中的通用类型和通配符

Question

I have the following class created with generics in Java and I have several doubts about this:

 public class Averias<T, E> {

    private ArrayList<T> averias;
    private E prueba;
    private ArrayList<? extends T> animal;

    public Averias(ArrayList<T> averias, E prueba, ArrayList<? extends T> animal) {
        this.averias = averias;
        this.prueba = prueba;
        this.animal = animal;
    }

    public ArrayList<T> getAverias() {
        return averias;
    }

    public void setAverias(ArrayList<T> averias) {
        this.averias = averias;
    }

    public E getPrueba() {
        return prueba;
    }

    public void setPrueba(E prueba) {
        this.prueba = prueba;
    }

    public ArrayList<? extends T> getAnimal() {
        return animal;
    }

    public void setAnimal(ArrayList<? extends T> animal) {
        this.animal = animal;
    }
}

This is my class, and now the first doubt I have is: when I want to use this class, do I have to infer all types or can I use just one?

private Averias<Integer, String> averias;

If I infer all types works, but I think a lot of code that every time I want to use it, I have to infer the type, then I don't know if there is some simpler way that I don't know.

In the class I have an ArrayList with a wildcard: private ArrayList animal;. I still don't have very clear how wildcards work, I know that it can be put alone, with extensions or with super, and depending on how it works, but I don't know when it would be useful to use them.

Answer 1

Inference can work, but if you go with inference, it's all or nothing. You can't specify half of the generics parameters and leave the other half inferred. To use inference, you need the diamond operator. For example, given:

void foo(Averias<String, Integer> a);

you can write:

thingie.foo(new Averias<>());

and it'll infer the <String, Integer> bit. For static methods with type args, you get inference without any additional syntax, so no need for <> there.

For fields, inference cannot be used; in private Averias<Integer, String> averias it cannot be avoided.

For wildcards:

With generics the inheritance rules are more strict. For example, this:

Number x = new Integer(5);

is legal java. But if we genericsify this:

List<Number> x = new ArrayList<Integer>();

it is NOT LEGAL – generics are 'invariant', meaning only if the same thing is on both the left and right side, it'd work. Only List<Number> x = new ArrayList<Integer>() works. That may strike you as weird, but it is correct: The thing is, with lists, you can also write to them. And, you can write a double into a List<Number> (after all, a double is a number), but.. a double isn't an integer. Hence why it works like this.

If you NEED covariance, you can still do that, that's where wildcards come in. This IS legal:

List<? extends Number> x = new ArrayList<Integer>();

So what happens with the 'add a double' problem? Easy: You cannot add anything to a List<? extends whatever> List<? extends whatever> . (Well, except null which is always okay).

super is for contravariance. The effective notion of Integer x = new Number . With contravariance you can add things to a list, but if you get from it, you'll always get a type of Object out:

List<? super Integer> x = new ArrayList<Number>(); // legal
x.add(new Integer(10)); // Okay
x.add(someNumber); // illegal
Object z = x.get(0); // that works; anything other than Object would not

super is by far the most rare.