generic misunderstanding when tying to add to list

this a wildcard question.

my purpose is to make a list that contains a class that has a generic type with extended examples:

so this is the structure:

  public class Event<T extends ActionType>{
  }

  public abstract class ActionType{
  }

  //**many** classes that extends ActionType class

that's a list that hold classes that extends from ActionType

  private List<Event<ActionType>> list = ArrayList<>();

  Event<RightClick> event = new Event<>(xPosition, yPosition, delay, new RightClick(robot), clicks, robot);

  list.add(event);

I know that's I cant do this to make sure that I can add the extended items:

  private List<Event<ActionType>> list = ArrayList<>();

but what I can do to add the items to the same list.

to fix my problem I used the wildcard selector ?

 List<Event<? extends ActionType>>

Explanation

Generics are invariant. A List<Event<ActionType>> will not accept Event<RightClick>, only Event<ActionType>.

Understand generics and adjust your generic type restrictions.

If generics would be covariant, then you could give someone who expects a List<Animal> a List<Dog> and then add Cats to it. Which would cause heap corruption as dogs.get(0) could suddenly be a Cat.

An example:

List<Dog> dogs = new ArrayList<>();
dogs.add(new Dog());

List<Animal> animals = dogs; // pretend this would work
animals.add(new Cat()); // would be legit

Dog dog = dogs.get(1); // should be safe, but is cat, heap corruption

A List<Animal> explicitly says that this list must accept all animals, also cats. But a List<Dog> is restricted to dogs only. The two lists behave differently, they have different restrictions, hence you can not use one for another. Unlike a Dog who is an Animal, a List<Dog> is not an List<Animal>, that is what is meant by co- and invariance.

Solution

The correct tool to "accept any ActionType, I do not care" are wildcards. So either go with

 List<Event<? extends ActionType>>

or just

List<Event<?>>

since the Event class already specifies the T extends ActionType restriction.

With that type you will be able to add all sorts of Events to it:

Event<RightClick> rightClick = ...
Event<LeftClick> leftClick = ...
Event<MiddleClick> middleClick = ...

list.add(rightClick);
list.add(leftClick);
list.add(middleClick);

As a consequence of the ? wildcard you will not be able to know the actual type at compile-time anymore, so:

Event<?> event = list.get(0); // unknown which exact type

All you know of ? is that it is at least extends ActionType, so you will be able to use all sorts of methods that are given by ActionType, but nothing introduced only in RightClick for example. That would require an explicit cast (guarded by an instanceof check), although I would question your design if you have to use right-click specific things there.