How to cast generic type to Object?

The code below won't compile because it can't add Task<T> to List<Task<Object>> how to fix it?

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

public class Tasks {

  private final List<Task<Object>> queue = new ArrayList<>();

  public static abstract class Task<T> {}

  public <T> List<T> process(List<Task<T>> tasks) {
    for (Task<T> task : tasks) queue.add(task); // <== problem here
  }

}

Imagine Task was exactly like List: It has an add(T item) method.

If you allowed adding a Task<T> to a List of Task<Object>, then other code could then grab an item from the list, which would have type Task<Object>, which would let you thus call the add(Object o) method, letting you add anything you want, as anything is an object.

So if you added a Task<String>, your task now has non-strings in it.

That's why this isn't allowed.

Now, presumably, your task has absolutely no opportunities to 'add' things; none of the methods have a T as parameter, the T occurs solely in a 'get' position, in academicese, as a covariant option: For example, it only shows up in return types of methods in the Task class.

Java unfortunately does not have the kind of use-site variance declaration model that makes this easy.

You have two general solutions:

1. 'uglycasting': Cast things, using the 3rd form of the cast construct, where you cast to a type that has generics, or perhaps, a raw type:

Task /* raw */ temp = task;
queue.add(temp); // this will work, but generates a warning.

then use @SuppressWarnings. Note that this does mean you're 'opting out' of the compiler checking your work, and if Task either has a method like add(T) or gets one later, you get no protections, and the end result will likely be that you end up seeing ClassCastException errors in places with zero casts in them.

2. Redefine queue.

Alternatively, redefinine queue to accept covariance. In that sense, Task<Object> is rather useless; few to no task types you'll ever make are actually assignable to this type. Try Task<? extends Object>, which can be shortened to just Task<?>. Just like with a List<? extends Whatever>, you cannot invoke add() style methods at all on such a thing; any method Task has that takes as parameter a T are now not invokable*. That's a good thing; it frees you up to assign any Task<T> regardless of what T might be to it, then.

List<Task<?>> queue = new ArrayList<>();

*) Unless you pass literally null, which is every type, and thus also fits for an unknown bound, but that's rather useless, of course.

If you are storing mixed task types, you need to use ?, since your list does not know what kind of Task is going to be passed into it.

> private final List<Task<?>> queue = new ArrayList<>();

import java.util.*;
import java.util.stream.Collectors;

public class Tasks {
    // Static classes, methods and fields

    public static abstract class Task<T> {
        private T value;
        public T getValue() { return value; }
        protected Task(T value) { this.value = value; }
        public String toString() { return String.format("Task[value=%s]", this.value);  }
    }

    // Instance fields

    private final List<Task<?>> queue = new ArrayList<>();

    // Class methods

    public List<?> process(List<Task<?>> tasks) {
        for (Task<?> task : tasks) queue.add(task);
        return queue.stream().map(Task::getValue).collect(Collectors.toList());
    }

    // Implementation

    private static class StringTask extends Task<String> {
        protected StringTask(String value) {
            super(value);
        }
    }

    private static class IntTask extends Task<Integer> {
        protected IntTask(Integer value) {
            super(value);
        }
    }

    public static void main(String[] args) {
        Tasks tasks = new Tasks();

        List<Task<?>> taskList = Arrays.asList(
            new StringTask("Hello World"),
            new IntTask(42)
        );

        tasks.process(taskList).stream().forEach(System.out::println);
    }
}