Generic Question in JAVA Beat

[Maggie Zhou]

I do not understand the why the answer is call 1,3,4, please help me out, thanks

Q: which can complile without error:

   
public static <T> void addandDisp(Collection<T> cs, T t)
{
for (T o : cs)
{
s.add(o);
}
for (T o : cs)
{
System.out.println(o);
}
}
 
//call 1
List<? super Object> ls1 = new LinkedList<Object>();
addandDisp(ls1,new String());
//call 2
List<? extends Object> ls2 = new LinkedList<Object>();
addandDisp(ls2,new Object());
//call 3
List<Object> ls3 = new LinkedList<Object>();
addandDisp(ls3,new String());
//call 4
List<? super Object> ls4 = new LinkedList<Object>();
addandDisp(ls4,new Object());
 

[ramesh maredu]

List<? super Object>

means you can add either Object or subclass of Object to list

List<? extends Object>

you can not add anything to list

List<Object>

means you can add either Object or subclass of Object to list

Hope this explains why line 2 won't compile
[ September 09, 2008: Message edited by: ramesh maredu ]

[Maggie Zhou]

<? super Object> does not mean can add Object or Object's superClass?, I thought the call 1 must be wrong.

So, I just want to double confirm with you: the <? super Object> means you can add either Object or subclass of Object to list?

Then, How about <? super String>, does it have same meaning? or means you can add String(String has no subClass), am I right with this point?

[ramesh maredu]

  
 
public static void main(String[] args) {
testSuper(new ArrayList<Object>());
testSuper(new ArrayList<Throwable>());
                testSuper(new ArrayList<Exception>());
}
 
private static void testSuper(List<? super Exception> list) {
//list.add(new Object());
list.add(new Exception());
list.add(new IOException());
}
}
 

Above code explains ? super behaviour.

regarding String your understanding is correct, we can add only String object as it can not be extended
[ September 09, 2008: Message edited by: ramesh maredu ]

[VidyaVikas Yalamanchili]

Hi

<? super Object> means you can have Object type or its Super Class type at type where you are mentioning the type.It means whatever the Type you are mentioning in Generic it should be Object or its Super Object T should be Super of Object mens Super Classtype not SubClass type.But this method will allow you to add thngs to The collection that type.But The method with following Declaration gives compilation error when you try to add the Objects.<? extends Object>.It menas the type can be either Object or its SubClass.Just remeber its Declaration for type only.

When you gave decleration as <? super Object> you need to specify the type in method call.When you specify the the type then you can add only those type objects or the Objects which satisfy IS-A.

I think this will answer your Question.

Please correct me if i am wrong.

[Vierda Mila]

Then, How about <? super String>, does it have same meaning? or means you can add String(String has no subClass), am I right with this point?

for <? super String>; you can add only String. because String final class and cannot have subclass.
[ September 09, 2008: Message edited by: Vierda Mila ]

[ramesh maredu]

for <? super String> you can add String or Object.

this statement is not correct

List<? super String> list = new ArrayList<String>();
list.add("test");
//list.add(new Object());  

second line won't compile if you remove comment

[Vierda Mila]

ups..i want to make corection about my statement but you did it early. Thanks Ramesh..

I mean as per below :
List<? super String> a = new ArrayList <String> ();
List<? super String> a = new ArrayList <Object> ();

[ September 09, 2008: Message edited by: Vierda Mila ]
[ September 09, 2008: Message edited by: Vierda Mila ]

[Maggie Zhou]

Thanks you all,Now I get it:

When you gave decleration as <? super Object> you need to specify the type in method call.When you specify the the type then you can add only those type objects or the Objects which satisfy IS-A.

so for example:

class Parent {}
class Child extends Parent {}
class GrandChild extends Child {}
 
class test {
   public static void main(String[] args){
      List<? super Child> c = new ArrayList<Child> ();
      //The Rightside can assign type with <Child>, <Parent> and <Object>
 
      //Once you assigned a specific type, 
      //then you can add the specific type or its subtype
      c.add(new Child());       //no problem with itself
      c.add(new GrandChild());  //no problem with its subclass
      c.add(new Parent());      //--> problem with Parent and Object!
   }
}
 

So this is conclusion! Thanks for help
[ September 09, 2008: Message edited by: Doraemon Zhou ]

[Bob Ruth]

The way that I like to look at this ( <? super ClassName> ) is like this

if you declare a reference...

List<? super ClassName> list1;

Then that reference can hold a List of ClassName or a List of anything higher in ClassName's class hierarchy.

THAT guarantees that whatever List you assign to list1... it WILL be able to accept a ClassName element.

If list1 will accept a ClassName type, then it will accept a subclass of ClassName type element.


Thus, a List<? super Number> reference will hold a Number, an Integer, a Float, a Double, or any other of the wrapper classes.

---------

Now, if you have a reference typed

List<? extends Number> list2;

then list two will be able to accept a List of Number or anything that is a subclass of Number. That means it will accept List<Number>, List<Integer>, List<Float> or any List of any other wrapper class. With that being true at run-time, the JVM can not be sure what type is currently referenced. All of the "type" information will have been wiped (type erasure). So the compiler, in order to guarantee the type safety of the List, simply will not allow anything to be put on that list using that reference. At run-time, yes, list2 COULD be a reference to List<Number>... but it COULD be a List<Float>. This rule keeps us from adding a short to the List<Float>.