Generics

[Rambabu Gonela]

Hi Friends..

i am really confusing with this generics,

see the below example

class C{}
class A extends C{}
class Impl {
void method(){
ArrayList<? extends C> arl = new ArrayList<A>();
arl.add(new A());//compile time error;
}
}

why its giving compile time error , already arl is type A arrayList means we can store the A class Objects, right?...

really i am confusing this senario.. pls help me the same.....
please give me detail explanation

ok
thank you

[rakesh sugirtharaj]

Hi

I think that is not allowed becoz it compromises type safety. If it is allowed, i can create a

 class B extends C{}   

and then

  arl.add(new B())  

and that would break type safety. Exercise caution while using wildcards.

[Dhaval Shah]

When you use extends to denote a type parameter bound, you are not requiring a
subclass-superclass relationship, but merely a subtype-supertype relationship. It is also important to remember that the bounded type does not need to be a strict subtype of the bound; it could be the bound as well.

In other words, for a Collection<? extends Number>, you could assign a Collection<Number> (although Number is not a strict subtype of Number) as well as a Collection<Integer>, Collection<Long>, Collection<Float>, and so on but you can not assign a Collection <Object> even though Object is a superclass of Number

[Pavel Cherkashin]

Consider piece of code with comments.

    
        List<C> arl = new ArrayList<C>();
        arl.add(new A()); //use base types without wildcards 
        // if needed values to be put into collection
 
        ArrayList<? extends C> arl2 = new ArrayList<A>();
        
        arl2.add(null); // null is a special case
        
        //arl2.add(new A); // we CANNOT put element of type which extends 
        // the wildcarded type to collection - it is UNSAFE
        
        C cobj = arl2.get(1); // we can retrieve element of collection of 
        // wildcarded type - it is SAFE 
        
        A aobj = (A) arl2.get(1); // same here 
 

Read the point 4 (about wildcards) of the generics tutorial - there is a good and quite detailed explanation of this situation.

[gaurav abbi]

this is because at runtime, there is no difference between a generics collection and a non-generics collection. (Type erasure)
ArrayList<? extends C> arl
is as good as
ArrayList arl
at runtime.
if there is no compile time error, then anything can be added to collection at runtime which will break the type safety. So normally you will no be able to assign a ArrayList<C> arl = new ArrayList<A>,
but the wildcards '?' allow you to do the assignment and with extends it can be read only, you can't do structural modifications.

consider the example

class C{}
class A extends C{}
Class B extends C{}
class D{
f(){
List<A> list = new ArraList<A>();
m(list);
}
void m(List<? extends C> list){
      //here if this is allowed
      //list.add(new A());
      //then you can also add
      //list.add(new B());
      //which will break your code
  }
}

Hope this will clear your doubt.