generics extends question?

[Minhaj Mehmood]

on page# 618 K&B
By saying <? extends Animal>, we're saying, I can be assigned a collection that is a subtype of List and typed for <Animal> or anything that extends Animal.

can anyone explain me the above and difference between <? extends Animal> and <? super Animal>


-Minhaj

[rohan yadav]

<? extends Animal> means any subclass of Animal can use <?extends Animal>.
<? super Animal> means any superclass of Animal can use<? super Animal>.

[Minhaj Mehmood]

thanks rohan

[rohan yadav]

e.g consider following code

 public void addAnimal(List<? extends Animal> animals) {
animals.add(new Animal()); 
}   

For above method addAnimal we can pass any argument that passes IS-A test for Animal class, i.e subtype of Animal class

 public void addDog(List<? super Dog> animals) {
animals.add(new Animal()); 
}   

Above code tells that we can pass any superclass of Dog class to method addAnimal.

[Ankur kothari]

dude i think in the first code...add will give a compile error

[W. Joe Smith]

Ankur kothari wrote:dude i think in the first code...add will give a compile error

Why do you think it will give a compiler error?

[Ankur kothari]

when ? extends Animal is used nothing can be added to the list.

[Edwin Dalorzo]

can anyone explain me the above and difference between <? extends Animal> and <? super Animal>

The best way to explain it is with an example. Basically you use extends when you intend to get things from the collection, but you do not intend to add items, and you use super when you intend to put things in the collection, but you do not intend to extract them.

Why so?

Consider the following scenario:

List<? extends Number> numbers = new ArrayList<Integer>();
numbers.put(10.5); //compile error, although 10.5 is a Number (in this case Double) you cannot guarantee that this list if of doubles.

But you can do this, knowing for sure that all items in the list are numbers, right?:

Number x = numbers.get(o);

Now consider this another one:

List<? super Integer> integers = new ArrayList<Object>();
integers.add(new Integer(10)); //you can be sure that all integer are objects, right?
Integer x = integers.get(); //compile time error, casting required. You cannot guarantee that the list is of Integers.

Do you get it now?

[Ankur kothari]

hey i didnt know that we cant get thing when we use super....

[Ankit Garg]

Ankur kothari wrote:hey i didnt know that we cant get thing when we use super....

You can get elements from a List<? extends Number> but only into references of type Object i.e. Object obj = list.get(0);

[Ankur kothari]

ankit did you mean List<? super Number> ???

[Ankit Garg]

Ankur kothari wrote:ankit did you mean List<? super Number> ???

I was just trying to show the syntax. The correct syntax would of course have an identifier for the name of the List...

[Minhaj Mehmood]

Edwin Dalorzo wrote:Do you get it now?

Sorry to say Edwin but I'm still not clear on this!! lets take this example:

import java.util.*;

class AnAnimal{
}
class SubTypeOfAnAnimal extends AnAnimal{

}
public class TestAnAnimal{
	public static void main(String... args){
		List<? extends AnAnimal> animal = new ArrayList<AnAnimal>();
		animal.add(new SubTypeOfAnAnimal()); //why its error here  where its stated into book: By saying this <? extends Animal>, we're saying, "I can be assigned a collection that is sub type of List and typed for <Animal> or anything that **extends** Animal.

	}
}

[Ankur kothari]

dude there is a difference between the two....? extends Animal mean anything can be accepted which extends Animal.....like Dog....so the compiler doesnt know which one at compile time...you can also add suppose a cat....whcih the compile is trying to avoid...so an error....becasue generics is all about compile time

understood?

[rohan yadav]

Because basically <? extend > is used to get things from List.

[Ankur kothari]

exaclty

[Edwin Dalorzo]

Ok, let's try again to clear this. Generics creates certain confusion when it comes to the rules of inheritance.

List<Number> numbers = new ArrayList<Number>();
numbers.add(new Integer(10));
numbers.add(new Float(10.5f));
numbers.add(new Double(11.1));
numbers.add(new BigInteger("100"));

As you can see in the code above, since the List is a List of Number, it can contain any kind of object that is a Number. Right?
Basically, Integer, Float, Double and BigInteger, all of them inherit from Number, and therefore they all are a Number. Correct?

However, you are not allowed to do this:

List<Number> numbers = new ArrayList<Integer>(); //compile time error?

You might think this weird, because ArrayList implements List and Integer is a Number.
Still, this is not valid. Why?

Well, for a moment imagine that the code above really compiled. See what you could do...

List<Integer> integers = new ArrayList<Integer>();
List<Number> numbers = integers;  //let's pretend this is Ok

numbers.add(new Float(10.5f));
numbers.add(new Double(11.1));
numbers.add(new BigInteger("100"));
numbers.add(new Integer(10));

Integer x = integers.get(0); //error, the list no longer contains only integers.

See the problem? The compiler must guarantee that the collection contains objects only of the declared type.

So fortunately, this is not possible thanks to the compiler.
Unfortunately, it makes very difficult to write generic code.

For instance, you are creating a method to print all items in a Lists containing Numbers.

Let's say you declare it like this:

public vod print(List<Number> printMe) { ... }

Based on the previous understanding, you could never invoke this method unless you were passing a List of Numbers and just that.
But what if you want to print an List<Integer> or a List<Float> or a List<BigDecimal>, you would need a method for every case.
That would be illogical, right?

Then you can do this:

public void print(List<? extends Number> printMe) {...}

Now you can pass any List whose parameterized type extends Number. Right?

You could do things like this:

List<Integer> integers = new ArrayList<Integer>();
List<Double> doubles = new ArrayList<Double>();
print(integers);
print(doubles);

But, there is no free lunch. You have to pay price.

For instance, take a look at this code:

List<Double> doubles = new ArrayList<Double>();
doubles.add(new Double(10.5);

List<? extends Number> numbers = doubles; //this is perfectly valid;
Number x = numbers.get(0); //you can be sure that item 0 is a double;

numbers.add(new Integer(19)); //compile-time error

Why, the last line produces a compile time error?

Simple, because you cannot guarantee that a List<? extends Number> is a List of Integers.
In fact, in this case it is a List of Doubles.

So, when you use extends in a generic type, it means you can read items, but you cannot write them.

How about this time, did you get it?

[Jack Bento]

great explanation. thanks

[Neha Daga]

that was great, it really helped.

thanks

[Minhaj Mehmood]

Edwin Dalorzo wrote:
How about this time, did you get it?

Great such a nice explanation, now i understand extends is all about read!!

Thanks alot!


Minhaj

[Edwin Dalorzo]

Excellent! Now the opposite case, with ? super T

List<Object> objects = new ArrayList<Object>();
objects.add(Integer.valueOf(10));
objects.add(Double.valueOf(Math.PI));

Evidently, we can add all kinds of objects to this list.

But now, we use generics:

List<? super CharSequence> text = objects; //this compile fine, all Charsequences are objects, right?

//this is valid since all Charsequences are objects too, right?
text.add("Obi-wan");
text.add(new StringBuilder("Qui-gon"));
text.add(CharBuffer.wrap("Joda"));

Now, this proves that we can write into the list, but if you try this:

CharSequence cs = text.get(0); //compile-time error

Why? Well, the compiler cannot ensure that the original list does not contain other types of objects different from CharSequence.
Actually, in this case, the original list contains an Integer in this position. So, at runtime this would have failed. Right?

That's why you can write things into this type of lists, but you cannot read from them (at least not without casting).

Lets say I want to right a method to copy items from one list to another. You could do somewhat like this:

public void copy(List<Object> src, List<Object> dest){  
	for(Object o : src){
		dest.add(o);
	}
}

Unfortunately, as we saw before, this would require that we strictly pass a List of Objects in every case, and what if we want to copy Strings, or StringBuilders or CharBuffers?

Then, according to what we learnt, you could suggest changing the method to this:

public void copy(List<? extends Object> src, List<? extends Object> dest){  
	for(Object o : src){
		dest.add(o); //compile time error
	}
}

But now, you get a compile time error, basically, because you cannot write items into this list, because the compiler cannot ensure its contents.

However, we could fix it like this:

public void copy(List<? extends Object> src, List<? super Object> dest){  
	for(Object o : src){
		dest.add(o);
	}
}

Now, you can read from List<? extends Object> src and write items to List<? super Object> dest.

[Neha Daga]

thats great....I was about to ask that question.

[Minhaj Mehmood]

Excellent