How Does Java Generics\' `super` Keyword Work with Bounded Wildcards, and What Are Its Limitations?

Java Generics' super Keyword: Understanding Its Usage and Limitations

Generics extend the power of Java collections by allowing the customization of data types without sacrificing type safety. The super keyword plays a crucial role in these generic collections.

Understanding Bounded Wildcards

When declaring a generic collection, the super keyword can be used with bounded wildcards. This type of wildcard allows a collection to hold a specific type or its supertypes. For example:

List<? super Number> list = null;

This declaration means that the list can contain Number objects or any of its superclasses, such as Object.

Adding Elements to Bounded Wildcard Collections

It's important to note that adding elements to bounded wildcard collections follows strict type safety rules. In the example above:

• list.add(new Integer(0)) is valid because Integer extends Number.
• list.add(new Object()) is invalid because Object is not a subtype of Number.

Testing the Limits of Super Wildcards

Contrary to expectations, the following code will not compile:

static void test(List<? super Number> param) {
  param.add(new Integer(2));
}

public static void main(String[] args) {
  List<String> sList = new ArrayList<String>();
  test(sList); // Compile error
}

While String is a subtype of Object, and Object is a supertype of Number, this code still fails to compile. The reason is that the wildcard captures the specific type Number (as defined in List) and its supertypes, which excludes String.

Why Java Allows But Not