Generic list type with question mark [duplicate]

Question

This question already has answers here:

What is PECS (Producer Extends Consumer Super)? (15 answers)

Closed 3 years ago.

I am having trouble interpreting/understanding the generic type of a Java List:

List<? extends Command> myVar = client.performAction(actionParams);

How is the generic type ? extends Command called, like is there a name for it? What exactly is this type? Is it a Command object? Or does this mean that it only accepts classes extending Command? What is my advantage using this sort of construct? In what Java version was this type of construct integrated?

Answer 1

Upper-bounded wildcards are used to relax the type-restriction of objects you can use. In this case you accept everything that extends/implements the Command type.

Answer 2

The important point about List<? extends Command> is that it's an abstract type. You can't write new List<? extends Command>() and expect something to get created. There are two reasons.

• List is an interface, with concrete implementations such as ArrayList, LinkedList and others.
• The wildcard in the type parameter, which means "this could be any type that's a subtype of Command, including Command itself".

That means that a variable of type List<? extends Command> can reference an object of any of these concrete types

• ArrayList<Command>
• LinkedList<SpecialCommand>
• CopyOnWriteArrayList<ImportantCommand>

and numerous other combinations. Assuming of course that SpecialCommand and ImportantCommand are subtypes of Command.

When you create an object that that variable is going to refer to, you need to be explicit about what concrete type it is. For example

List<? extends Command> myCommandList = new ArrayList<SpecialCommand>();

Once you've done that, of course, you can call some of the usual List methods on myCommandList, such as

Command firstCommand = myCommandList.get(0);

which is fine, because we know that whatever objects are in the list, they'll all be some type of Command. But you can't do things like

SpecialCommand mySpecialCommand = new SpecialCommand();
myCommandList.add(mySpecialCommand);

because the compiler has no way of knowing that you're adding the right kind of object to the list. At this point, myCommandList could equally be a LinkedList<ImportantCommand>, or similar, and adding a SpecialCommand to it needs to be prevented by the compiler.

That means you should only use the type List<? extends Command> if you have a variable where

• you don't care what kind of list it is (ArrayList, LinkedList or whatever)
• you don't care what kind of Command is in the list
• you're not going to be trying to add anything to the list.

That means you won't usually use it for a local variable or a field. It's more likely to be a method parameter, where the things passed in might be LinkedList<ImportantCommand> or whatever else; but all you'll be doing in that method is getting objects out of the list, and doing Command type operations on them.

Generics have been in Java since Java 5, including wildcards.

Answer 3

Since you have asked many questions at once, let me recapitulate:

• Generics are vital when you implement data structures, containers or algorithm that you want to use on different objects without having to rewrite the whole code
• If I remember correctly generic where introduced in Java 5.0, before having generics in Java you could still create flexible data structure containing Object objects but you would have to cast to final type and use instanceOf in a lot of places in your code. Generics were thus introduced to ease this problem and to simplify the code.
• As it has already being said by NiVeR, ? is a wildcard operator and List<? extends Command> would restrict the List to contain objects that extends or implements the class or the interface Command to enforce constraints on the object interface.

Answer 4

How is the generic type ? extends Command called, like is there a name for it?

These are called generic wildcards.

What exactly is this type? Is it a Command object?

It's only used to check variable assignments at compile time. At runtime generics are erased and interpreted as List myVar = client.performAction(actionParams);

Does this mean that it only accepts classes extending Command?

You could only say List<Command> myVar = client.performAction(actionParams); and it would accept any object that is type of Command or a subclass of command.

List<? extends Command> myVar controls the variable assignment. So you could assign only the following generics to myVar. The following assignments are all valid, assuming that SubCommand extends Command:

myVar = new ArrayList<SubCommand>
myVar = new ArrayList<Command>

When declaring collection with wildcard generic, it also can become read-only. For example myVar.add(new SubCommand()); will result a compiler error.

What is my advantage using this sort of construct?

Originally Java did not include generics. It was added in Java 5.0 to allow type restriction of Java collections, like List, Set, Map, etc.

Answer 5

List<? extends Command> is called upper-bound wildcard (which many answers had already addressed this). In general, no one would declare his or her list like this; this is mainly used in methods (more commonly, in static methods).

List<? extends Command> refers to a list that holds one specific type of Command (i.e. one particular subclass). Since it's an unknown subclass type, at compile time, you will not be able to add anything. Your IDE will probably resolve add method to add(null e).

List<Command>, though seemingly similar, refers to a list that holds anything, as long it is a Command (or subclassed from Command).

Example:

List<? extends Command> commands = new ArrayList<FooCommand>();
commands.add(new FooCommand()); // Not allowed at compile time

List<Command> commands = new ArrayList<>();
commands.add(new FooCommand());
commands.add(new BarCommand());

Example of when it is used:

public static void doSomethingToCommands(List<? extends Command> commands) {
    commands.forEach(this::doSomething);
}

List<FooCommand> fooCommands = getFooCommands();
doSomethingToComamnds(fooCommands); // Allowed

List<Command> commands = getRandomCommands();
doSomethingToComamnds(commands); // Not allowed.