#027 J2SE 5.0 Generics

In this exercise, you will learn the basic concept of Generics by adding lines of code to the Main.java.  You will try to reason why some code work while others result in compilation errors.  Technical explanations are then followed.

(1.1) Compile time type checking through Generics

Summary

ArrayList<Object> ao = new ArrayList<Integer>();

1. Create a new NetBeans project

• Select File->New Project (Ctrl+Shift+N). The New Project dialog box appears.
• Under Choose Project pane, select Java under Categories and Java Application under Projects.
• Click Next.

• Under Name and Location pane, for the Project Name field, type in GenericsSubtyping as project name.
• For Create Main Class field, type in GenericsSubtyping.
• Click Finish.

• Observe that GenericsSubtyping project appears and IDE generated GenericsSubtyping.java is displayed in the source editor window of NetBeans IDE.

2. Modify the IDE generated GenericsSubtyping.java as shown in Code-2.11 below.  Study the code by paying special attention to the bold fonted parts.

import java.util.ArrayList; import java.util.List; import java.util.Vector; public class GenericsSubtyping { public static void main(String[] args) { // These should work ArrayList<Integer> ai = new ArrayList<Integer>(); ArrayList<String> as = new ArrayList<String>(); ArrayList<Object> ao1 = new ArrayList<Object>(); // There is no inheritance relationship between type arguments ArrayList<Object> ao2 = new ArrayList<String>(); ArrayList<Object> ao3 = new ArrayList<Integer>(); // There is still inheritance relationship between classes List<String> ls = new ArrayList<String>(); List<Object> lo = new ArrayList<String>(); // There is still  inheritance relationship between elements in a collection object List<Number> ln1 = new Vector<Number>(); List<Number> ln2 = new Vector<Integer>(); List<Number> ln3 = new ArrayList<Long>(); } }

Code-2.11: GenericsSubtyping.java

3. Observe that some lines have compile errors as shown in Figure-2.12 below.

Figure-2.12

4. Understand why some lines have compile errors and while others don’t by reading the following explanations.

---

<Learning point>  As it clearly indicates, you cannot assign an instance of ArrayList<String> to a variable of ArrayList<Object> type.  Nor you can assign an instance of ArrayList<Integer> to a varaible of ArrayList<Object> type.  In other words, an ArrayList of String is not an ArrayList of Object and an ArrayList of Integer is not an ArrayList of Object.  This is very counter-intuitive to our understanding of OO concept but it is a very important aspect to remember in Generics.

Gilad Bracha (JSR-14 specification lead) explained why this assignment is not allowed in Generics in his Java Programming Language (Chapter 3: Generics and Subtyping) [2]. Basically if it had been allowed, then there would be a possibility of ClassCastException being thrown during runtime, which goes against the “type-safety” principle of Generics.  Let’s take a look an example code.

List<String> ls = new ArrayList<String>(); //1 List<Object> lo = ls; //2 lo.add(new Object()); // 3 String s = ls.get(0); // 4: attempts to assign an Object to a String! ClassCastException would have to be thrown!

Line 1 is certainly legal.  But Line 2 is not legal in Generics.  If it has been allowed, then during runtime, ClassCastException would have to be thrown in Line 4. [2]

---

5.  For your own exercise, do some experimentation by improvising your own code and see if they behave as you expect.  A sample code is provided in Code-1.14 below.

// // Assignment of collection with parameter types // List<Object> lo5 = new ArrayList<Integer>(); List<Object> lo6 = new Vector<Integer>(5); Collection<Object> co1 = new Vector<String>();           // Right-click this line and select Fix Imports first Collection<Object> co2 = new ArrayList<Integer> (10); Collection<Integer> ci1 = new ArrayList<Integer> (10);

Code-1.14:  Experimentation code

NetBeans project: This exercise up to this point is provided as a ready-to-open-and-run NetBeans project as part of hands-on lab zip file. You can find it as <LAB_UNZIPPED_DIRECTORY>/javase5generics/samples/GenericsSubtyping.  You can just open it and run it.

In this exercise, you will learn the concept of wildcard and  learn when to use them.  The wildcard type is equivalent to saying the type is unknown, so Collection<?> is the same as saying a Collection of unknown type.

1. Create a new NetBeans project

• Select File->New Project (Ctrl+Shift+N). The New Project dialog box appears.
• Under Choose Project pane, select Java under Categories and Java Application under Projects.
• Click Next.

• Under Name and Location pane, for the Project Name field, type in GenericsWildcard as project name.
• For Create Main Class field, type in GenericsWildcard.
• Click Finish.

• Observe that GenericsWildcard project appears and IDE generated GenericsWildcard.java is displayed in the source editor window of NetBeans IDE.

2. Modify the IDE generated GenericsWildcard.java as shown in Code-3.11 below.  Study the code by paying special attention to the bold fonted parts.

import java.util.ArrayList; import java.util.Collection; public class GenericsWildcard { static void printCollection(Collection<Object> c){ for (Object o: c) System.out.println(o); } public static void main(String[] args) { // TODO code application logic here ArrayList<Integer> a = new ArrayList<Integer>(10); printCollection(a); } }

Code-3.11: GenericsWildcard.java

3. Observe that some lines have compile errors as shown in Figure-3.12 below.

Figure-3.12: Compile error

4. Understand why some lines have compile errors and while others don’t by reading the following explanations.

5. One way to fix this is to change the printCollection(..) method as following.  Note that type, Integer, is matching between the caller and callee.

import java.util.ArrayList; import java.util.Collection; public class GenericsWildcard { static void printCollection(Collection<Integer> c){ for (Object o: c) System.out.println(o); } public static void main(String[] args) { ArrayList<Integer> a = new ArrayList<Integer>(10); printCollection(a); } }

Code-3.14: Use compatible type

6. Now supposed you want to pass not only a collection of Integer but also a collection of any type such as Long, Float, or String etc.  How would you change the printCollection()?  You know you can’t use Collection<Object> as you’ve seen in previous steps.  Here is where the unknown type <?> (or it is called wildcard) comes into the picture.  In order to accommodate a collection of any type, you can use unknown type <?> as shown in Code-3.15 below.

import java.util.ArrayList; import java.util.Collection; public class GenericsWildcard { static void printCollection(Collection<?> c){ for (Object o: c) System.out.println(o); } public static void main(String[] args) { // TODO code application logic here ArrayList<Integer> a = new ArrayList<Integer>(10); printCollection(a); ArrayList<Long> l = new ArrayList<Long>(10); printCollection(l); ArrayList<String> s = new ArrayList<String>(10); printCollection(s); } }

Code-3.15: Use wildcard

The code in Code-3.15 above has the same effect as the one shown in Code-3.16 below.

Collection<?> c = new ArrayList<Integer> (10);                           // This code works c = new ArrayList<Long> (10);                                                  // This code works c = new ArrayList<String> (10);                                                 // This code works

Code-3.16:  Usage of unknown type

NetBeans project: This exercise up to this point is provided as a ready-to-open-and-run NetBeans project as part of hands-on lab zip file. You can find it as <LAB_UNZIPPED_DIRECTORY>/javase5generics/samples/GenericsWildcard.  You can just open it and run it.

Now we are ready to learn Bounded Wildcards. There may well be situations where we want to be able to define a type argument so that it is restricted to a particular class or sub-type of that class.   Let’s say you want to constrain the printCollection() method to receive only the Number type and its sub-types instead of any type.  In other words, you want compiler to generate a compilation error when the printCollection() method receive a Collection of String type while it receives a Collection of Number, Integer, or Long without compilation errors.  This is where you can use a Collection of bounded Wildcards, <? extends Number>.

1. Create a new NetBeans project

• Select File->New Project (Ctrl+Shift+N). The New Project dialog box appears.
• Under Choose Project pane, select Java under Categories and Java Application under Projects.
• Click Next.

• Under Name and Location pane, for the Project Name field, type in GenericsBoundedWildcard as project name.
• For Create Main Class field, type in GenericsBoundedWildcard.
• Click Finish.

• Observe that GenericsBoundedWildcard project appears and IDE generated GenericsBoundedWildcard.java is displayed in the source editor window of NetBeans IDE.

2. Modify the IDE generated GenericsBoundedWildcard.java as shown in Code-3.21 below.  Study the code by paying special attention to the bold fonted parts.

import java.util.ArrayList; import java.util.Collection; public class GenericsBoundedWildcard { static void printCollection(Collection<? extends Number> c){      // Bounded wildcard for (Object o: c) System.out.println(o); } public static void main(String[] args) { ArrayList<Integer> a = new ArrayList<Integer>(10); printCollection(a); ArrayList<Long> l = new ArrayList<Long>(10); printCollection(l); ArrayList<String> s = new ArrayList<String>(10); printCollection(s);                                                    // Now compile error should occur } }

Code-3.21: GenericsBoundedWildcard.java

3. Observe that some lines have compile errors as shown in Figure-3.22 below.

Figure-3.22: Compile error

The code above has the same effect as the one shown in Code-3.23 below.

Collection<? extends Number> c = new ArrayList<Integer> (10); // This code works c = new ArrayList<Long> (10);                                                  // This code works c = new ArrayList<String> (10);                                                 // Compilation error

Code-3.23: Usage of bounded wildcard

4. Now is the time you are going to your own experimentation.  Improvise your own code and see if they behave as you expect.  Code-3.24 below contains sample code you can experiment with.

Collection<? extends Number> c3; c3 = new Vector<Integer>(); c3.add(new Integer(3)); c3.add(new Long(4L)); c3 = new Vector<String>(); c3 = new Vector<Long>(); c3 = new ArrayList<Date>(); Collection<? extends Object> c4; c4 = new Vector<Integer>(); c4 = new Vector<String>(); c4 = new Vector<Long>(); c4 = new ArrayList<Date>(); Collection<?> c5; c5 = new Vector<Integer>(); c5 = new Vector<String>(); c5 = new Vector<Long>(); c5 = new ArrayList<Date>();

Code-3.24: Experimental code using wildcard as type argument

NetBeans project: This exercise up to this point is provided as a ready-to-open-and-run NetBeans project as part of hands-on lab zip file. You can find it as <LAB_UNZIPPED_DIRECTORY>/javase5generics/samples/GenericsBoundedWildcard.  You can just open it and run it.

In this exercise, you have learned how to retrieve information on a ThreadGroup.

We are all familiar with defining a class in Java as something like “public class Foo extends Frame implements ActionListener”.  This still remains the same under Generics, except that an optional set of type parameters have been added.  Again the type parameters are placed between < and >. A generic class can have multiple type parameters and, as with type arguments, they are separated by commas.

So far, you have worked with generic classes that are already provided by J2SE 5.0 SDK. In this exercise, you are going to create your own Generic class and then use the class in your code.

(4.1) Create a generic class, Pair<F, S>

(4.2) Use wild card

(4.3) Create another Generic class, PairExtended<F, S, T>

(4.4) Use another generic type as a parameter

Summary

Generics are implemented by the Java compiler as a front-end conversion called type erasure. You can (almost) think of it as a source-to-source translation, whereby the generic version of your code is converted to the non-generic version.  Basically, type erasure gets rid of (or erases) all generic type information. All the type information between angle brackets is thrown out, so, for example, a parameterized type like List<String> is converted into a raw type List and similarly List<Date> is converted into List. All remaining uses of type variables are replaced by the upper bound of the type variable (usually Object). And, whenever the resulting code isn’t type-correct, a cast to the appropriate type is inserted.

The two important things about type erasure are 

• Assuming all code is compiled under 5.0 and uses parameterized types you can guarantee that you won’t get a ClassCastException at runtime
• There is full backwards compatibility with existing compiled code that was generated with pre-J2SE 5.0 compilers

1. Create a new NetBeans project

• Select File->New Project (Ctrl+Shift+N). The New Project dialog box appears.
• Under Choose Project pane, select Java under Categories and Java Application under Projects. Click Next.
• Under Name and Location pane, for the Project Name field, type in TypeErasure as project name.
• For Create Main Class field, type in TypeErasure.
• Click Finish.

• Observe that TypeErasure project appears and IDE generated TypeErasure.java is displayed in the source editor window of NetBeans IDE.

2. Modify the IDE generated TypeErasure.java as shown in Code-5.11 below.

import java.util.ArrayList; import java.util.Collection; import java.util.List; public class TypeErasure { static void printCollection(Collection<? extends Number> c){ for (Object o: c) System.out.println(o); } public static void main(String[] args) { // Display class information of the various ArrayList instances ArrayList<Integer> ai = new ArrayList<Integer>(); System.out.println(“Class of ArrayList<Integer> = ” + ai.getClass()); List<Integer> li = new ArrayList<Integer>(); System.out.println(“Class of List<Integer> = ” + li.getClass()); ArrayList<String> as = new ArrayList<String>(); System.out.println(“Class of ArrayList<String> = ” + as.getClass()); ArrayList ar = new ArrayList(); System.out.println(“Class of ArrayList  = ” + ar.getClass()); // Check if two ArrayList instances with different type parameters // (one with Integer and the other with String) share the same class (bytecode). // Boolean b1 = (ai.getClass() == as.getClass()); System.out.println(“Do ArrayList<Integer> and ArrayList<String> share same class? ” + b1); // Check if two ArrayList instances with different type parameters // (one with Integer and the other with raw type) share the same class (bytecode). // Boolean b2 = (ai.getClass() == ar.getClass()); System.out.println(“Do ArrayList<Integer> and ArrayList (raw type) share same class? ” + b2); } }

Code-5.11: TypeErasure.java

3. Build and run the project

• Right click TypeErasure project and select Run Project.
• Observe the result in the Output window. (Figure-5.15 below)

Class of ArrayList<Integer> = class java.util.ArrayList Class of List<Integer> = class java.util.ArrayList Class of ArrayList<String> = class java.util.ArrayList Class of ArrayList  = class java.util.ArrayList Do ArrayList<Integer> and ArrayList<String> share same class? true Do ArrayList<Integer> and ArrayList (raw type) share same class? true

Figure-5.15: Result of running TypeErasure application

NetBeans project: This exercise up to this point is provided as a ready-to-open-and-run NetBeans project as part of hands-on lab zip file. You can find it as <LAB_UNZIPPED_DIRECTORY>/javase5generics/samples/TypeErasure.  You can just open it and run it.

2. Modify the IDE generated TypeErasure2.java as shown in Code-5.21 below.

Code-5.21: TypeErasure2.java

3. Build and run the project

Figure-5.25: Result of running TypeErasure2 application

NetBeans project: This exercise up to this point is provided as a ready-to-open-and-run NetBeans project as part of hands-on lab zip file. You can find it as <LAB_UNZIPPED_DIRECTORY>/javase5generics/samples/TypeErasure2.  You can just open it and run it.

 In this exercise, you learned the concept of type erasure.

In this exercise, you will learn how generic and non-generic codes are used together. You will also learn about unchecked exception.

1. Create a new NetBeans project

• Select File->New Project (Ctrl+Shift+N). The New Project dialog box appears.
• Under Choose Project pane, select Java under Categories and Java Application under Projects. Click Next.
• Under Name and Location pane, for the Project Name field, type in GenericsInteroperability as project name.
• For Create Main Class field, type in GenericsInteroperability.
• Click Finish.

• Observe that GenericsInteroperability project appears and IDE generated GenericsInteroperability.java is displayed in the source editor window of NetBeans IDE.

2. Modify the IDE generated GenericsInteroperability.java as shown in Code-6.11 below.  Study the code by paying special attention to the bold fonted parts.

import java.util.LinkedList; import java.util.List; public class GenericsInteroperability { public static void main(String[] args) { List<String> ls = new LinkedList<String>(); List lraw = ls; lraw.add(new Integer(4)); String s = ls.iterator().next(); } }

Code-6.11: GenericsInteroperability.java

3. Compile the file.

• Right click GenericsInteroperability.java and select Compile file. (Or Right click GenericsInteroperability project and select Build Project.)
• Observe the waring message below.  Note that the compiler warns unchecked or unsafe operation.

Compiling 1 source file to C:\javase5generics\samples\GenericsInteroperability\build\classes Note: C:\javase5generics\samples\GenericsInteroperability\src\GenericsInteroperability.java uses unchecked or unsafe operations. Note: Recompile with -Xlint:unchecked for details.

Figure-6.12: Warning message

4. Run the project

• Right click GenericsInteroperability project and select Run Project.
• Observe the runtime ClassCastException. (Figure-6.13 below)  This is highly undesirable. (This is not type-safe.)  Because of this reason, it is highly recommended that you do not invoke non-Generic code whenever possible.

Figure-6.13: Result of running UnGenericsInteroperability application

NetBeans project: This exercise up to this point is provided as a ready-to-open-and-run NetBeans project as part of hands-on lab zip file. You can find it as <LAB_UNZIPPED_DIRECTORY>/javase5generics/samples/GenericsInteroperabilityWarning.  You can just open it and run it.

4. Modify the  GenericsInteroperability.java as shown in Code-6.14 below.  The code fragment that needs to be removed (or commented out) is highlighted in bold and red-colored font while the code fragment that needs to be added is highlighted in bold and blue-colored font.

import java.util.LinkedList; import java.util.List; public class GenericsInteroperability { public static void main(String[] args) { List<String> ls = new LinkedList<String>(); //List lraw = ls; //lraw.add(new Integer(4)); List<String> ls2 = ls; ls2.add(new Integer(4));        // Compile error String s = ls.iterator().next(); } }

Code-6.14: GenericsInteroperability.java

5. You should experience the compile error, which means you were able to detect type mismatch problem during the compile time rather than during runtime.  (Figure-6.15 below)

Figure-6.15: Compile time type mismatch detection

NetBeans project: This exercise up to this point is provided as a ready-to-open-and-run NetBeans project as part of hands-on lab zip file. You can find it as  <LAB_UNZIPPED_DIRECTORY>/javase5generics/samples/GenericsInteroperabilityCompileError.

In this exercise, you learned how generic and non-generic code are used together.  You alo learned when unchecked exception would occur.