Type-safe generic code doubt

[Rahul Choudhary]

import java.util.*;
public class GenericDemo4 {
    public static void main(String r[]) {
        Set s1 = new HashSet();
        s1.add(0);
        s1.add("1");
        dostuff(s1);
    }

    static void dostuff(Set<Number> s) { 
        do2(s);
        Iterator i = s.iterator();
        while(i.hasNext()) System.out.println(i.next() + " ");

        Object [] oa = s.toArray();
        for(int x = 0; x<oa.length; x++)
            System.out.println(oa[x] + " ");
        System.out.println(s.contains(1));
    }

    static void do2(Set s2) { System.out.println(s2.size() + " "); }
}

On line 10 there is a type-safe set as a parameter for the method dostuff and it accepts non generic Set s1. How can it not flag an error for one of it's element being a string(s1.add("1"))? From what I understand, integer 0(s1.add(0)) is accepted since Integer IS-A Number but that's not the case for String so how come no error ? Sorry if it's a silly doubt.

[ayush raj]

@Rahul Choudhary : In main method , the set doesn't have any generic code , so whatever you add gets added (with warning that its not a type a safe operation, Remember compiler warnings are not the same as compiler error) without any error . However , when you are passing it to the method , you are specifying that the set now will contain only numbers in it . It does not check for the existing contents , but rather gets alert to whatever is added in future . Hence , if you now try to add a string in the set , you would surely be prompted with an error !!

[Rahul Choudhary]

Thanks @ayush raj, very well explained

[Rahul Choudhary]

However I have a similar doubt.

import java.util.*;
public class LinkedList3 {
	public static void main(String r[]) {
		LinkedList<Object> l = new LinkedList<Object>();
		l.add("1");
		l.add(2);
		l.add(3.44444f);
		l.add(new Object());
		l.add("string");
		System.out.println(l);
	}
}

The above program compiles and runs fine.
But the program below give compiler error for every add() statement. Why? Isn't <? extends Object> refer to anything and everything that can be added to it?

import java.util.*;
public class LinkedList4 {
	public static void main(String r[]) {
		LinkedList<? extends Object> l = new LinkedList<Object>();
		l.add("3");
		l.add(1);
		l.add(new Object());
		l.add(new Integer());
		System.out.println(l);
	}
}

[ayush raj]

You need to be very clear with this . By saying <? extends Object> , we are saying "I can be assigned a collection that is a subtype of LinkedList and typed for <Object>" and its like we swear that we wont be adding anything to the collection . <? extends> doesn't allow you to add either in the same method or in the different method . In the first case , its self explanatory that LinkedList<Object> will accept any of its sub-types also as Integer is-a Object , String is-a Object .... and so on . However , in the second case , even if you really want that the " LinkedList<? extends Object> l " should contain all that you have added , you need to change your code as the following :

 import java.util.*;  
    public class LinkedList4 {  
        public static void main(String r[]) {  
            LinkedList<? extends Object> l1 = new LinkedList();
            LinkedList<Object> l=new LinkedList<Object>();
            l.add("3");  
            l.add(1);  
            l.add(new Object());  
            l.add(new Integer(9));
            l1=l;
            System.out.println(l1);  
        }  
    }  

Check it and tell me if its clear or not . And nothing to thank me .. thanks to Kathy Sierra and Bert Bates for the magnificent book provided by them

[Dan Drillich]

Good Day,

The beloved book of Kathy Sierra and Bert Bates speaks about this issue in page #602 under the title - "Mixing Generic and Non-generic Collections". It says -

Remember, the older legacy code was allowed to put anything at all (except primitives) into a collection. And in order to support legacy code, Java 5 and Java 6 allows for newer type safe code to make use of older code (the last thing Sun wanted to do was ask several million Java developers to modify all their exiting code).

However, just because the Java 5 compiler allows this code to compile doesn't mean it has to be HAPPY about it. In fact the complier will warn you that you're taking a big, big risk....

In our case, s1 obviously represents the legacy code.

Regards,
Dan

[Himai Minh]

Hi Rahul Choudhary buddy,
In the code you give, the compiler does not know what the linked list l will hold even though it is assigned to new LinkedList<Object>(). That is why adding any type of object to this linked list will not compile.
For instance, LinkedList<? extends Object> l can be assigned to new LinkedList<String>() or new LinkedList<Integer>() or new LinkedList<Double>() and etc... The compiler prevents you from adding a wrong type.

import java.util.*;   
public class LinkedList4 {   
    public static void main(String r[]) {   
        LinkedList<? extends Object> l = new LinkedList<Object>();   
        l.add("3");   
        l.add(1);   
        l.add(new Object());   
        l.add(new Integer());   
        System.out.println(l);   
    }   
}  

Look at this example:

class Test{
 public static void main(String[] arg){

 // The compiler does not know what you will pass to methodA , can be a list of Ibject or a list of Integer or a list of String.....
 //The compiler is designed in the way that prevents you from adding any object type of a generic list. 
 LinkedList<? extends Object> l = new LinkedList<Object>();
       methodA(l) ;
 LinkedList<? extends Object> l1 = new LinkedList<Integer>();
      methodA(l1); 
 LinkedList<? extends Object> l2 = new LinkedList<String>();
    methodA(l2);

}
static void methodA (LinkedList<? extends Object> p){
       //The compiler prevents you from adding any object type to list p because it does not know what you will pass
      // as parameter p.
        p.add(new Object()) ; //won't compile 
        
        p.add(new Integer()); //wont' compile 
}

}

[Rahul Choudhary]

Hi ayush, dan and himai. From what all I have read in the posts from you guys is that if extends wild card is used it does not let you add anything. Not just <? extends Object> but something like <? extends Animal>. Also I have checked out other wild cards in K&B text.

<?>

<? extends XYZ>

<? super XYZ>

<Object>

Case1: <? extends XYZ> doesn't add anything from within method!

import java.util.*;
class Animal{Animal() {System.out.println("Animal constructor");}}
class Dog extends Animal{Dog() {System.out.println("Dog constructor");}}

public class GenericDemo8 extends Animal{
	public static void main(String r[]) {
		List<Animal> l1 = new ArrayList<Animal>(); 
		l1.add(new Dog());
		l1.add(new Animal());
		met(l1);
		System.out.println(l1);	}
	
	public static void met(List<? extends Animal> l2) {   //even for public static void met(List<? extends Object> l2), doesn't compile
		l2.add(new Dog());//COMPILE ERROR!
		l2.add(new Animal()); //COMPILE ERROR!
		System.out.println(l2);	}}

Case 2: <?> doesn't add anything from within method!

import java.util.*;
class Animal{Animal() {System.out.println("Animal constructor");}}
class Dog extends Animal{Dog() {System.out.println("Dog constructor");}}

public class GenericDemo8 extends Animal{
	public static void main(String r[]) {
		List<Animal> l1 = new ArrayList<Animal>();  
		l1.add(new Dog());
		l1.add(new Animal());
		met(l1);
		System.out.println(l1);	}
	
	public static void met(List<?> l2) {
		l2.add(new Dog());//COMPILE ERROR!
		l2.add(new Animal()); //COMPILE ERROR!
		System.out.println(l2);	}}

So can I safely understand it to be a rule that <? extends XYZ> and <?> as a method parameter won't allow anything to be added from within that method ass illustrated above?

However, for <? super XYX> and <Object> it's even more peculiar.

Case 3: <? super XYZ>

import java.util.*;
class Animal{Animal() {System.out.println("Animal constructor");}}
class Dog extends Animal{Dog() {System.out.println("Dog constructor");}}

public class GenericDemo8 extends Animal{
	public static void main(String r[]) {
		List l1<Animal> = new ArrayList<Animal>();  //With our without parameter type here, <Animal> or <Dog>
		l1.add(new Dog());
		l1.add(new Animal());
		met(l1);
		System.out.println(l1);	}
	
	public static void met(List<? super Dog> l2) {
		l2.add(new Dog());
		//l2.add(new Animal()); //COMPILE ERROR! Allowed if <? super Animal>
		System.out.println(l2);	}}
		

it adds Dog object but not Animal object. It should right? In the program Dog extends Animal! A partial result.
And if <? super Animal> is used, it adds both from within the method without any error! It shouldn't add Dog if <? super Animal> used right since Dog is subclass! What's the pattern or rule that I can understand here?

Case 4: <Object>

import java.util.*;
class Animal{Animal() {System.out.println("Animal constructor");}}
class Dog extends Animal{Dog() {System.out.println("Dog constructor");}}

public class GenericDemo8 extends Animal{
	public static void main(String r[]) {
		List<Animal> l1 = new ArrayList<Animal>(); //Even with <Dog> gives error
		l1.add(new Dog());
		l1.add(new Animal());
		met(l1);
		System.out.println(l1);	}
	
	public static void met(List<Object> l2) {
		l2.add(new Dog());
		l2.add(new Animal());
		System.out.println(l2);	}}
		

For the above program two things are happening. If I insert a type during instantiation (Dog or Animal) it gives compiler error saying "Object cannot be applied to Animal or Dog" and points to met(l1).
But if I remove the type during instantiation, all works fine!

Why this confusing thing is happening! I read up K&B but didn't find any such detailed explanation or if there I couldn't pinpoint Could I get help on each case please? Thanks again guys.

[Rahul Choudhary]

If explanation is given for such concept in K&B please could you provide me with page number.

[Himai Minh]

Rahul buddy,

 public static void met(List<? super Dog> l2) {   
        l2.add(new Dog());   
        //l2.add(new Animal()); //COMPILE ERROR! Allowed if <? super Animal>   
        System.out.println(l2); 
}

This is a similar compiler design issue. The compiler won't let you add an animal to l2. It won't let you add an object to it neither. Why ? What if the animal is a Cat ? What if the object is a String/Double/Integer...?
List<? super Dog> l2 tells the compiler that l2 can hold a list of Dogs. Or, it can hold a list of Animals or Objects. The followings are valid assignment:

 List<? super Dog> l2 = new ArrayList<Dog>(); 
 List<? super Dog> l3 = new ArrayList<Animal>();
 List<? super Dog> l4  = new ArrayList<Object>();

But you cannot add animal to l3 because l3 holds objects that is Dog or super type of Dog, which is animal and object.
Assume you have a Cat class extending Animal.

Animal cat = new Cat();
l3.add(cat) ; // won't compile

Adding a cat that is not in this hierachy Dog->Animal->Object won't make sense.
For this reason, the compiler prevents you from adding any object type that is not a Dog.

To add a Dog is fine because Dog is an Animal and is an Object.
So,

  
    l3.add(new Dog()) ; //compile

[ayush raj]

Rahul Choudhary wrote:If explanation is given for such concept in K&B please could you provide me with page number.

Its given in page 618 describing briefly with what operation can be performed on which of the generics code and what cannot be performed . Read it thoroughly . That would make sense .