Generic declarations "? super" Vs. "? extends"

[Santiago Bravo]

Hi All,


I have a doubt with the generic declarations "? super" and "? extends"


"? super Integer" means any class above the Integer class is permitted

"? extends Integer" means any subclass of Integer is permitted

I know that you cannot use "? extends" for access to a collection such as add or delete

But what about "? super"? I tried some code and it allows access to the collection.

   
Set<? super String> s1 = new TreeSet<String>();
          s1.add("1"); 
          s1.add("2"); 
 

If I change the generic declaration to Set<? extends String> s1

it will not compile

Please can anyone explain further?


Thanks

[Alexey Saenko]

Hi Santiago,
"? extends String" means that collection is applicable for all subclasses of String, but as String is a final class it cannot has any subclasses.

[Henry Wong]

"? super Integer" means any class above the Integer class is permitted

Not quite. It means that the collection works with an unknown type -- that happens to be super class of Integer (bounded by). It doesn't mean any type is allowed, but the type that is allowed is one either an Integer or one of it's super classes.

"? extends Integer" means any subclass of Integer is permitted

Not quite. It means that the collection works with an unknown type -- that happens to be subclass of Integer (bounded). It doesn't mean any type is allowed, but the type that is allowed is one either an Integer or one of it's derived classes.


Henry

[Henry Wong]

I know that you cannot use "? extends" for access to a collection such as add or delete

If I change the generic declaration to Set<? extends String> s1

it will not compile

I am not sure what you are asking... but don't one quote answers the other quote?

Henry

[Santiago Bravo]

Hi Henry,

Sorry for any confusion.

Basically I was under the impression that if your generic declaration has either "? super" or "? extends" then you cannot add or delete from the collection. Now, this holds true for "? extends" as it can only be used for access. However with "? super" you can add or delete from the collection.

So my real question is why CAN we add or delete from the collection if the generic delcaration is "? super"


Thanks

[Henry Wong]

So my real question is why CAN we add or delete from the collection if the generic delcaration is "? super"

example: ? super someclass

Basically, you don't know what type the collection takes, but it is one of the super classes of someclass.

Inheritance says that a subclass IS-A super class type, and of all class types up the inheritance tree. So, a someclass IS-A someclass, and IS-A all the classes which are super class of someclass.

So... if you add or delete someclass (or one of the subclass of someclass), you guarantee that the class is the type of the collection, even though you don't know what type it is.

Henry

[Henry Wong]

Basically I was under the impression that if your generic declaration has either "? super" or "? extends" then you cannot add or delete from the collection. Now, this holds true for "? extends" as it can only be used for access. However with "? super" you can add or delete from the collection.

BTW, IMO, it is better to understand why you can do something, and the limitations of what can be done, than to just memorized that .... add or delete is not allowed if you use some declaration.

Henry
[ November 19, 2008: Message edited by: Henry Wong ]

[Soumya Ranjan Mohanty]

add is not allowed for ? extends but can be applied to ? extends super . C&B page 619.

[Stephan van Hulst]

You realize this topic is more than two years old?

[Ryan Patrick]

the reason <? extends String> fails, while <? super String> is successful, is purely a matter of scope. A specific generic type method signature...

void bar(T t){}

...cannot be accessed when the initialization of the generic instance was created with wildcards...

Foo<? super   Widget> foo_sup

For Example:

public class Test {
	public static void main(String ... args){
		Foo<? super   Widget> foo_sup = null;
		Foo<? extends Widget> foo_ext = null;

		Widget   widget   = new Widget();
		Thing    thing    = new Thing();
		DoHickey doHickey = new DoHickey();

		// Allowed because the scope of <T> to its Highest Super class is fixed, and is traceable
		foo_sup.bar(thing);    // has widget as super class... so Ok!
		foo_sup.bar(doHickey); // has widget as super class... so Ok!
		//foo_sup.bar(widget); // has no super class... so BAD!

		// NOT Allowed because the scope of <T> to its Lowest Sub class is Infinite
		//foo_ext.bar(thing);
		//foo_ext.bar(doHickey);
		//foo_ext.bar(widget);   // Extends nothing (except Object)
	}
}


class Foo<T> {
	// notice this method signature DIRECTLY specifies the type,
	// and does not offer the flexibility of <? super T> or <? extends Thing>
	void bar(T t){}
}

class Widget{}

class Thing extends Widget{}

class DoHickey extends Thing{}