Why Can't I Add a `Parent` Instance to a `List

Wildcard Generic Type Complications

Java wildcard generics provide a way to represent types without committing to a specific concrete type. While this flexibility can be powerful, it can also lead to unexpected behavior.

Consider the following example, where a Java list of an unknown subtype of the Parent interface is defined:

List extends Parent> list = ...;

Java's type system, however, will not allow adding a Parent instance to this list:

Parent p = factory.get();   // returns concrete implementation
list.set(0, p);   // compilation error

This apparent contradiction arises from the concept of type safety. Allowing the addition of a Parent instance to the list would compromise the integrity of the wildcard generic type. Here's why:

Imagine if this addition were permitted. Suppose we have a list of Child instances, which are a concrete subtype of Parent:

List<child> childList = new ArrayList<child>();
childList.add(new Child());</child></child>

If we were to assign this childList to our list with the wildcard generic type, it would appear that we have a list of Parent instances:

List extends Parent> parentList = childList;

However, we could then potentially add a Parent instance to this parentList:

parentList.set(0, new Parent());

This would cause a catastrophic type safety violation. When retrieving the item at index 0 from the childList later on, we would expect it to be a Child instance, but it would actually be a Parent instance, leading to unexpected behavior.

To prevent this type safety violation, Java enforces the rule that you can only add instances of the wildcard generic type itself to the list, even though you can retrieve instances of its supertype. This restriction ensures the integrity of the type parameter and prevents potential bugs.

The above is the detailed content of Why Can't I Add a `Parent` Instance to a `List. For more information, please follow other related articles on the PHP Chinese website!