Generics - Revision history

Suhridk: /* Generics and Raw Types */

2011-09-10T05:48:53Z

Generics and Raw Types

Suhridk: /* Wildcards */

2011-09-09T15:59:45Z

Wildcards

Suhridk: /* Polymorphism and Generics */

2011-08-30T05:16:15Z

Polymorphism and Generics

Suhridk: /* Polymorphism and Generics */

2011-08-19T17:48:39Z

Polymorphism and Generics

Suhridk: /* Polymorphism and Generics */

2011-08-19T17:45:57Z

Polymorphism and Generics

Suhridk: /* Wildcards */

2011-08-19T16:57:27Z

Wildcards

Suhridk: /* Wildcards */

2011-08-19T16:53:37Z

Wildcards

Suhridk: /* Generics and Raw Types */

2011-08-19T16:38:58Z

Generics and Raw Types

Suhridk: /* Wildcards */

2011-08-19T16:32:00Z

Wildcards

Suhridk: /* Wildcards */

2011-07-31T12:03:21Z

Wildcards

@@ Line 40: / Line 40: @@
 * It is possible to use a generic class by its raw type only. e.g. instead of using List<String> using a plain List.
 * The compiler will issue an "unchecked" warning when it detects that there could be a problem at runtime when using the raw type.
-* Assignment of Generic type to raw type and vice versa is OK, but will generate an unchecked warning.
+* Assignment of Generic type to raw type is OK.
 <syntaxhighlight lang="java5">
-          	List ll = new ArrayList(); //No warning
+          	List ll = new ArrayList(); //OK
-		List<String> sL = ll; //Unchecked warning
+		List<String> sL = ll; //Unchecked warning - Raw to Generic
-		List ll2 = new ArrayList<Integer>(); //Unchecked warning
+		List ll2 = new ArrayList<Integer>(); //OK
-                 ll3.add(new Integer(42)); //Unchecked warning
+                 ll2.add(new Integer(42)); //Unchecked warning since ll2 is raw
 </syntaxhighlight>

@@ Line 171: / Line 171: @@
 * In the below example, it means that all Lists containing objects of superclasses of Dog can be passed to the foo method.
 * So foo is safe to add Dog objects to the passed list, since the passed list is guaranteed to be a list of some objects which are above Dog. So type-safety is maintained.
 <syntaxhighlight lang="java5">

@@ Line 122: / Line 122: @@
 * So, the compiler will prevent such polymorphic assignments when we are dealing with type-safe collections.
 * Because of the fact that Arrays retain type and Generics do not, we '''CANNOT mix Generics with Arrays'''. '''It is ILLEGAL to create an array of a Generic Type!'''
 * This is a CLASSIC OCPJP question:

@@ Line 121: / Line 121: @@
 * This will be exactly the same problem when type-safe collections are mixed with non-type safe ones.
 * So, the compiler will prevent such polymorphic assignments when we are dealing with type-safe collections.
-* Because of the fact that Arrays retain type and Generics do not, we CANNOT mix Generics with Arrays. It is ILLEGAL to create an array of a Generic Type!
+* Because of the fact that Arrays retain type and Generics do not, we '''CANNOT mix Generics with Arrays'''. '''It is ILLEGAL to create an array of a Generic Type!'''
 * This is a CLASSIC OCPJP question:

@@ Line 121: / Line 121: @@
 * This will be exactly the same problem when type-safe collections are mixed with non-type safe ones.
 * So, the compiler will prevent such polymorphic assignments when we are dealing with type-safe collections.
 * This is a CLASSIC OCPJP question:
@@ Line 138: / Line 139: @@
 </syntaxhighlight>
-−
 == Wildcards ==

@@ Line 186: / Line 186: @@
    e.g. List<? extends Dog> - get operations will return type Dog. set operations will not be allowed.
 * In general <? super Type> will allow us to perform set() operations by passing objects that are lowerbounded by Type (Objects of Type and its subtypes are allowed). Get operations will be return type Object.
-   e.g. List<? super Dog> - set will allow types of Dog and below, get will return type object.
+   e.g. List<? super Dog> - set will allow types of Dog and below, get will return type Object.
 * Common idiom is to use <? extends Type> to get objects from a data structure and <? super Type> be used to set objects in a data structure.

@@ Line 174: / Line 174: @@
 	private static void foo(List<? super Dog> dogList) {
                dogList.add(new Dog()); //OK
-               dogList.add(new Cat()); //OK
+              dogList.add(new Alsatian()); //OK
                dogList.add(new Animal()); //WONT WORK.
                dogList.add(new Object()); //WONT WORK.

@@ Line 197: / Line 197: @@
 * List<?> list is different from List<Object> objList ! The second will take only lists which contain Objects, whereas the former will take any List.
 * It follows that List<? extends Object> is the same as List<?>
 * The compiler allows the assignment of raw lists to List<?> //without any warning.
-* Also following the logic of wildcards, the compiler will not allow the addition of any object to a List<?>
+* Also following the logic of wildcards, the compiler will not allow the addition of any object to a List<?>.
 * Wildcards can also be used to declared bounded variables.

← Older revision		Revision as of 12:03, 31 July 2011
Line 180:		Line 180:

	* Why does the compiler not allow the addition of an animal object or a plain old object here ? Because List<? super Dog> says Lists containing objects of super-types of Dogs can be passed to this method. which means that we could pass a List<Animal> to this method as well. So, if the compiler allowed a plain Object to be added to a List<Animal> it wont make sense. So any objects of the super type are not allowed to be added to the list.		* Why does the compiler not allow the addition of an animal object or a plain old object here ? Because List<? super Dog> says Lists containing objects of super-types of Dogs can be passed to this method. which means that we could pass a List<Animal> to this method as well. So, if the compiler allowed a plain Object to be added to a List<Animal> it wont make sense. So any objects of the super type are not allowed to be added to the list.
		+
		+	* In general <? extends Type> will allow us to perform get() operations that will return objects upperbounded by Type. This will not allow the addition of any objects to the ADT.
		+	e.g. List<? extends Dog> - get operations will return type Dog. set operations will not be allowed.
		+	* In general <? super Type> will allow us to perform set() operations by passing objects that are lowerbounded by Type (Objects of Type and its subtypes are allowed). Get operations will be return type Object.
		+	e.g. List<? super Dog> - set will allow types of Dog and below, get will return type object.
		+	* Common idiom is to use <? extends Type> to get objects from a data structure and <? super Type> be used to set objects in a data structure.

	* '''NOTE VERY IMPORTANT: Wildcards specify what kind of collections the method can accept. NOT what can be added to the collection'''		* '''NOTE VERY IMPORTANT: Wildcards specify what kind of collections the method can accept. NOT what can be added to the collection'''