Generics

Writing typed checked generic code There are many instances where the type of the object is irrelevant : –The construction of data structures. –The specification and implementation of methods.

Generic data structures Containers are and ought to be independent of the type of their entries. –A list specification and implementation is the same regardless of the type of its entries.

Generic operations There are many methods whose algorithm is and ought to be independent of the type of its parameters: –Swapping –Reversing a list –Length –Spliting a list –Concatenating two lists –Sorting

Java’s old solution For containers: –Use Object as the generic type. This solution has only negative consequences: –Elements added to a container cannot be typed checked for its true type: i.e. we loose type checking. –Client of containers must coerce at run-time to the expected type: instanceof is an expensive operation. Client may coerce to the incorrect type. Without use of instanceof client may run into run-time errors. –For production of safe code programmers must define abstract containers based on Object and subclass it for the expected type of container’s entries: It breaks Liskov’s substitutability principle. Client is forced to write and maintain repeated code It leads to class explosion when container is subclassed.

Java’s new solution: Generics. What are generics? Generics allows you to abstract over types. Specifically you can specify parameters whose values are types. Example: The only difference between the different XXXList is the type of the entries. –Specify the list using type as a parameter. –Implement the list using the parameter wherever you need a specific type. –When you need a specific list (a list of students): Instantiate the List matching the parameter type with Student.

Java’s generic syntax public class List { … public void add(Entry element) {…} public Entry get(int index){.. } … private Entry[] elements; } Entry in angular brackets represents a type variable, to be matched by an existing class when the generic class is instantiated.

Generic List instantation List studentList = new List (1,20); Matches the type parameter throughout the class implementation Matches the List constructor’s parameters

import java.util.Vector; class DynamicList { public DynamicList() { elements = new Vector (); } public boolean isEmpty(){ return elements.size() == 0; } public Entry get(int i){ return elements.get(i); } public int indexOf( Entry entry){ return elements.indexOf(entry); } public void append (Entry entry){ elements.add(entry); }

public void add(int i, Entry entry){ elements.add(i, entry); } public void remove(int i){ elements.removeElementAt(i); } public int size() { return elements.size(); } public void set ( int i, Entry entry){ elements.set(i,entry); } private Vector elements; } DynamicList studentList = new DynamicList ( ); //constructors arguments if any,

Generic methods Using the Java’s generic extension we can also write methods whose algorithm does not depend on explicit types: –To swap two entries in an array. void swap(Element[] a, int i1, int i2){ Element temp = a[i1]; a[i1] = a[i2]; a[i2] = temp; } An invocation: swap(integersTable, 3, 7);

More examples of generic functions Interface Function { B value(A arg); } Interface Ntuple { Ntuple map( Function f); } Ntuple nti = ….; nti.map( new Function { Integer value(Integer i){ return new Integer(i.intValue()*2); } );

Java’s generic Classes Abstract classes Interfaces methods

Java’s generic trade-offs Positive: –The way to catch type errors up front. –Code is more readable. –Client does not have to coerce. –Totally compatible with current Java Negative: –The choice of implementation of generic code may produce unexpected warning errors. Cannot overload based on different instantiations of same generic type.

How can I start using generics? For home use follow the link to: download jdk1.5 extensions (zip file) README file instructs you for setup and compilation of generic code Need to set two environment variables use the javac version provided to compile generic code. The usual javac will not compile it. The command to run the interpreter ( java ) will also need to be changed to use new generic libraries.

Java generics in the dept To run the compiler from the department network, set the environment variables J2SE14 and JSR14DISTR. export J2SE14=/usr/java export JSR14DISTR=/home/c /Utilities/adding_generics-2_2-ea and run the scripts javac and java from / home/c /Utilities/adding_generics-2_2-ea/scripts to compile and execute. To simplify all the above, two scripts to run the compiler and interpreter, javac1.5 and java1.5, are available in /home/c /scripts. You can simply copy these scripts to your home directory and use them to compile and run. For example, $ ~/javac1.5 foo.java $ ~/java1.5 foo