Why Are Java Generics Not Covariant?

Java Generics and Covariance: Understanding the Limitations

Covariance in generics refers to the ability for a subtype to be substituted for its supertype without violating type safety. However, in Java, generics are not covariant, meaning that subtypes cannot be assigned to supertype variables.

To illustrate this concept, consider the following code snippet:

List<Integer> li = new ArrayList<Integer>();
List<Number> ln = li; // illegal
ln.add(new Float(3.1415));

Here, ln is aliased with li, which means ln refers to the same list as li. However, ln is declared as a List, indicating it can hold any type that extends Number. This includes Float, which is not an Integer.

If covariance were allowed, the code above would be legal, but it would violate type safety. By assigning a List (i.e., li) to a List (i.e., ln), we could potentially add non-integer values to the list, which would compromise its integrity as a list of integers.

Therefore, to maintain type safety, Java generics are not covariant. This limitation ensures that subtypes cannot be used interchangeably with supertypes in generic contexts, preventing potential type errors.

The above is the detailed content of Why Are Java Generics Not Covariant?. For more information, please follow other related articles on the PHP Chinese website!