Genrecis and Wildcard

[Pooja Desai]

Hi all,
I am preparing for SCJP1.5 finding generics to be tough and a bit confusing.
Source: Kethy and Bates CD question.

import java.util.*; 
public class BackLister{ 

  //Insert code here 

  { 
    List<T> output= new linkedList<T>(); 
    for (T t:input) 
    output.add(0,T); 
    return output; 
  } 
}

Which of the following can be inserted at // Insert here.
1) public static <T> List <T>backwards ( List <T> input)
2) public static <T> List <T> backwards ( List <? extends T> input)
3) public static <T> List <T> backwards ( List <? super T> input)
4) public static <T> List <? extends T> backwards (List <T> input)
5) public static <T> List <? super T> backwards ( List <T> input)
6) public static <? extends T> List <T> backwards ( List <T> input)


Answer is : ABDE

not clear with the exact declaration syntax for Generics and how to use wildcards -extends and super in the above problem.

If anyone can help me , it will be great. Thanks in advance.

[Ruben Soto]

Hi Pooja,

A. public static <T> List <T>backwards ( List <T> input)
B. public static <T> List <T> backwards ( List <? extends T> input)
C. public static <T> List <T> backwards ( List <? super T> input)
D. public static <T> List <? extends T> backwards (List <T> input)
E. public static <T> List <? super T> backwards ( List <T> input)
F. public static <? extends T> List <T> backwards ( List <T> input) 

Let's look at the ones that are wrong (C. and F.)

C. public static <T> List <T> backwards ( List <? super T> input)
In this case, the parameter is declared as List <? super T>. The problem is that you are adding elements from input to output, which is declared as type List<T>. The real issue is that the actual type of the elements in input could be, for example, the direct superclass of T (let's call it Y), which could refer to actual objects of type X (another subclass of Y, unrelated with T.) Then, you can't add these elements to the list that holds elements of type T (output) because an X is not a T, so the compiler is stopping you from that possibility.

    Y
  /  \
T    X

F. public static <? extends T> List <T> backwards ( List <T> input)
The problem in this case is that the syntax <? extends T> for the generic type declaration is incorrect. You can't have a wildcard (?) in the generic type declaration.

[Punit Singh]

public static <T> List <T> backwards ( List <? super T> input){ 
List<T> output= new linkedList<T>(); 
for (T t:input) 
output.add(0,T); 
return output; 
} 

Why C. option is invalid?

Here we have to ensure that input contains T or its subtype objects only, not other that that. Means we have to make T as upper bound of input.

And the problem is List<? super T> input.

See I what are assignable to this List<? super T> input.

  ArrayList<Object> arrayListOfObject=new ArrayList<Object>();
	arrayListOfObject.add(new Object());
	arrayListOfObject.add(new String());
	arrayListOfObject.add(new StringBuffer());
	arrayListOfObject.add(new Integer(5));
	List<? super T> input=arrayListOfObject;  

You can see here List<? super T> input can contain any type of Objects in the java world, so it is not bounding T as upper bound.

  B. public static <T> List <T> backwards ( List <? extends T> input)  

Why B. option is valid?

  ArrayList<Object> arrayListOfObject=new ArrayList<Object>();
	arrayListOfObject.add(new Object());
	List<? extends T> input=arrayListOfObject;//compile time error we cannot do it.
	  

here List<? extends T> input reference can only take reference of those list that are declared with generic parameter T or subtypes of T.

for ex:

   ArrayList<T> arrayListOfT=new ArrayList<T>();
	List<? extends T> input=arrayListOfT;
	
	ArrayList<? extends T> arrayListOfT1=new ArrayList<T>();
	input=arrayListOfT1; 

Means here List<? extends T> input , limits the generic parameter of the assignable list means assignable list could be only List<? extends T>, List<T>, ArrayList<? extends T>, ArrayList<T>, LinkedList<? extends T>, LinkedList<T>, Vector<? extends T>, Vector<T>.
While it will not allow List<Object> references to be assigned to List<? extends T> reference.

Think in terms of what can be assigned to function argument List<? extends T> or List<? super T> or List<T> references. You will get the whole thing clear.

Option F is already well said by Ruben.

[Jesper de Jong]

Welcome to JavaRanch. Please use code tags when you post source code.

[Duran Harris]

@Punit

You said for the following:

List<Object> = new ArrayList<Object>();

Here T is typed as 'Object'
But Object has no superclasses....so how could the List accept anything other than something that has been casted to object?

[Punit Singh]

List can accept anything that is Object or its subtypes.

List<Object> list= new ArrayList<Object>(); 
list.add(new Object());
list.add(new String());
list.add(any object);

Object is just upper bound here, you can insert its subtypes also.

[Duran Harris]

Okay...

then what is the point of using something like:

<? super T> 

because then you can insert anything...?

and

<? extends T>

would be the same as just:

<T>

[Punit Singh]

<? super T>

Here you can add T objects and its subtypes objects.

<? extends T>

Here you can't add anything.

<T>

Here you can add T objects and its subtypes objects.

[Duran Harris]

<? super T>

So I can't add supertypes of T even though it says super?

[Punit Singh]

No you cannot add.

<? super T> is not designed for allowing objects that is supertype of T to be added in this.

The design purpose is actually for reference assignment.

Suppose you make a reference of List using <? super T>

List<? super T> listOfSuperT=null;

Then <? super T> decides what could be assignable to this reference.

You can assign any reference that is supertype of T.
for example lets make one reference of a type that is supertype of T.

List<Object> listOfObject=null;

Now we can do this:

listOfSuperT=listOfObject;

[Ruben Soto]

Also, note that, to clarify things, the compiler is not thinking about what we are adding to what list. The error is caught at // 1 below, when you attempt to assign something that is probably of a supertype of T to a T reference variable:

import java.util.*;
public class BackLister {

   public static <T> List <T> backwards ( List <? super T> input) {
      for (T t : input) { // 1
         System.out.println(t);
      }
   }
}

[Duran Harris]

@Punit

List<? super T> listOfSuperT=null; 

But now I thought that the wildcard can't be used when declaring collections?

[Punit Singh]

No nothing like that wild cards cannot be used when defining collections.

  new ArrayList<? super String>();
	new ArrayList<? extends String>();
	new ArrayList<? super T>();
	new ArrayList<? extends T>();  

[John Grabowsky]

Hi all,

you can use wildcards in variable declarations and return type declarations, but not when creating an instance (new) or declaring a type parameter (as in answer F in the original question).

Forget, for the moment, the type parameter T and make clear easier things (if there are easy things with generics at all):

  
List<Number> l = new ArrayList<Number>();
l.add(new Object()); // line 1
l.add(new Integer(2)); // line 2
Object o = l.get(0); // line 3
Number n = l.get(0); // line 4
Integer i = l.get(0); // line 5

here a List<Number> can hold any subtypes of Number, so you can add anything that is a subtype of Number (line 1 fails, line 2 ok) and you can be sure to get anything that is a subtype of number (line 5 fails, lines 3+4 ok).

Now, use a wildcard in the declaration of l:

  
List<? super Number> l = new ArrayList<Number>();
// List<? super Number> l = new ArrayList<Object>(); // line 0
l.add(new Object()); // line 1
l.add(new Integer(2)); // line 2
Object o = l.get(0); // line 3
Number n = l.get(0); // line 4
Integer i = l.get(0); // line 5

Now l can be any List with generic type ? super Number, i.e. a List<Number> or a List<Object> as line 0 shows. line 1-5 must work with ANY thing that l CAN be. When compiling line 1-5 the compiler knows only the declared type of l, not what is assigned to l. Thats why

line 1 fails, since l CAN be a List<Number> which cannot hold an Object

line 4 fails, since l CAN be a List<Object> and can deliver any Object

line 5 fails, since l CAN be a List<Object> or a List<Number> and can deliver in both cases things that are not Integers

lines 2+3 ok

[Duran Harris]

Okay,so then
On the LHS: the reference types<generic declaration>defines what types can be referenced.
On the RHS:the <generic declaration> defines what can be stored in the collection.

[John Grabowsky]

Yes. When using a reference variable declared with generics, as in line 1-5 above, you have to combine your 2 statements: What can be stored in types referenced by this reference variable. And your code must work with any possiby referenced type.

[Punit Singh]

Duran Harris wrote:Okay,so then
On the LHS: the reference types<generic declaration>defines what types can be referenced.
On the RHS:the <generic declaration> defines what can be stored in the collection.

Exactly Duran, you got a good point, your LHS RHS explains many things in just two lines, many rancher will get it very helpful. As generics are the most confusing topic and most asked questions.