Java Generics why do we need wildcard (question mark)?

Question

I am trying to understand why do we need the wildcard -- question mark in Java Generics, why can't we just use the normal single character T or E etc. as the type? Look at the following example:

public class App {

public static void main(String[] args) {
    App a = new App();
    List<String> strList = new ArrayList<String>();
    strList.add("Hello");
    strList.add("World");
    List<Integer> intList = new ArrayList<Integer>();
    intList.add(1);
    intList.add(2);
    intList.add(3);

    a.firstPrint(strList);
    a.firstPrint(intList);

    a.secondPrint(strList);
    a.secondPrint(intList);
}

public <T extends Object> void firstPrint(List<T> theList) {
    System.out.println(theList.toString());
}

public void secondPrint(List<? extends Object> theList) {
    System.out.println(theList.toString());
}

}

The result is same albeit the wildcard version is more concise. Is that the only benefit?

The wildcard means "of any type". `extends Object` is redundant in both cases. — shmosel, Apr 20 '18 at 01:56
Thanks @user202729. So doesn't work but super String> works. Why don't just make that "T" work the same way? — Yang, Apr 20 '18 at 02:00
@shmosel I know. I just use that to test syntax. Of course everything is an Object. — Yang, Apr 20 '18 at 02:02
That's another [question](https://stackoverflow.com/questions/4902723/why-cant-a-java-type-parameter-have-a-lower-bound). — user202729, Apr 20 '18 at 02:03
And... comments are only for suggesting improvements, not for extended discussion or asking another question. — user202729, Apr 20 '18 at 02:04
@user202729 Got it. Probably when we need something like this: default void forEach(Consumer super T> action) — Yang, Apr 20 '18 at 02:17
One difference is that you could refer to `T` inside the code of `firstPrint`. — Dawood ibn Kareem, Apr 20 '18 at 02:37

score 2 · Answer 1 · edited Apr 20 '18 at 07:42

The "?" is there to act as a placeholder where you are allowed to pass the different type of objects.

Normally, T and ? is used in generics as a placeholder. i.e <?> or <T>.

Use Cases:

<?>: It could be used while developer wants to allow any type of object for particular instance.

Example: List<?> listOfObject = new ArrayList<>(); Here in this case listOfObject can accept any kind of object which is extending the class Object

<T>: One of the approach to be used it complex type of Object (DTO).

i.e., Let's say if Class A can have same fields for different instances. However, there is one field which could be varied with the type of instances. Meanwhile, it could be the better approach to use Generics with

Example:

public Class A<T> {

   private T genericInstance;

   private String commonFields;

   public T getGenericInstance() {
      return this.genericInstance;
   }

   public String getCommonFields() {
      return this.commonFields;
   }

   public static void main(String args[]) {

      A<String> stringInstance = new A<>(); // In this case, 
      stringInstance.getGenericInstance();  // it will return a String instance as we used T as String.

      A<Custom> customObject = new A<>();   // In this case, 
      customObject.getGenericInstance();    // it will return a custom object instance as we used T as Custom class.
   }
}

"only allows you to pass lists of type object" - what other types of list are there? — Dawood ibn Kareem, Apr 20 '18 at 02:45

Java Generics why do we need wildcard (question mark)?

1 Answers1