Java Generics -- an introduction. Based on

Transcription

1 Java Generics -- an introduction Based on

2 Generics vs. Templates Templates in C++ are compiled into unique code based on the types passed in as template parameters. Map<int,string> instantiates code that takes an int and a string this takes time, but it is ok because it is done at compile time, not run time Generics in Java create a class that takes many types. The type of the reference allows the compiler to often (but not always) checked at runtime. Generic classes can be created at javac time This does cause interesting issues, discussed later.

3 Why use generics Because Java has an Object class that all other classes derive from, one could just write containers of objects. However, doing this disables type checking at compile time increases the use of casts Does not allow the implementation of generic algorithms based on Interface or Base class functionality

4 Why use generics Cast needed with non-generic container of objects: List list = new ArrayList(); list.add("hello"); String s = (String) list.get(0); No cast needed when using generics: List<String> list = new ArrayList<String>(); list.add("hello"); String s = list.get(0); // no cast + type known inside of the generic code and can used methods based on the type

5 Consider the code: public class Box { private Object object; Generic types public void set(object object) { this.object = object; public Object get() { return object; Since an Object is taken, any class type can be put into the Box, and get( ) can return any class type. Thus, the code: Box box = new Box( ); box.set((object) new String( hello )); Integer i = (Integer) box.get( ); cannot be checked at compile time -- because the compiler only knows the class takes an Object. It will cause a runtime error instead of a compile time error.

6 Consider the code: public class Box<T> { // T stands for "Type" private T t; Generic types public void set(t t) { this.t = t; public T get() { return t; Now an object of type T is taken, and the code: Box<String> box = new Box<String>( ); box.set(new String( hello )); Integer i = (Integer) box.get( ); can be checked and because the reference type says a String will go into the box.

7 Conventions and notation Commonly used parameter names: E - Element (used extensively by the Java Collections Framework) K - Key N - Number T - Type V - Value S,U, etc. - 2nd, 3rd,... types Terminology: the T in Foo<T> is a type parameter and the String in Foo<String> f is a type argument. I.e., as with functions, the thing defining what will be passed in is a parameter, and the thing defining what is passed in is an argument.

8 Raw types A raw type is the name of a generic class or interface without any type arguments. To create a parameterized type of Box<T>, you supply an actual type argument for the formal type parameter T: Box<Integer> intbox = new Box<>(); If the actual type argument is omitted, you create a raw type of Box<T>: Box rawbox = new Box(); Assigning a raw type to a parameterized type gives a warning: Box<Integer> intbox = rawbox; // warning: // unchecked conversion // A runtime check is performed This is allowed to enable backwards compatibility with, e.g., code that uses pre-generics collections classes. The type T is treated as Object.

9 Generic methods Java allows methods to have parameterized types. public class Util { public static <K, V> boolean compare Pair<K, V> p1, Pair<K, V> p2) { return p1.getkey().equals(p2.getkey()) && p1.getvalue().equals(p2.getvalue()); It would be called as boolean same = Util.<Integer, String>compare(p1, p2);

10 Bounded type parameters Java allows you to restrict the types of arguments passed to a template public class Box<T> { private T t; public void set(t t) {this.t = t; public T get() {return t; public <U extends Number> void inspect(u u){ System.out.println("T: " + t.getclass().getname()); System.out.println("U: " + u.getclass().getname()); public static void main(string[] args) { Box<Integer> integerbox = new Box<Integer>(); integerbox.set(new Integer(10)); integerbox.inspect("some text"); // error: this is a String! Can also say: <T extends B1 & B2 & B3> to have multiple bounds on a parameter. Classes must be listed before interfaces in the list. Bounded types allow better compile time type checking by minimizing the types a method/class takes.

11 Does not compile because > only defined for primitives public static <T> int countgreaterthan(t[] anarray, T elem) { int count = 0; for (T e : anarray) if (e > elem) // compiler error ++count; return count; Bound T with the Comparable<T> interface and use compareto and it is ok. public static <T extends Comparable<T>> int countgreaterthan(t[] anarray, T elem) { int count = 0; for (T e : anarray) if (e.compareto(elem) > 0) ++count; return count; Where Comparable<T> is defined as: public interface Comparable<T> { public int compareto(t o); Using bounded type parameters

12 Generics, Inheritance and Subtypes This is legal because Integer ISA Object Object someobject = new Object(); Integer someinteger = new Integer(10); someobject = someinteger; // OK This is legal because Integer ISA Number and Double ISA Number Box<Number> box = new Box<Number>(); box.add(new Integer(10)); // OK box.add(new Double(10.1)); // OK What arguments does public void boxtest(box<number> n) accept? You cannot pass in a Box<Integer> or a Box<Double>. Although Integer ISA Number and Double ISA Number, Box<Integer> ISNOTA Box<Number>

13 How do you subtype generic classes? // PayloadList<E,P> ISA List<E> interface PayloadList<E,P> extends List<E> { void setpayload(int index, P val);... // PayloadList<String,String> ISA List<String> // PayloadList<String,Integer> ISA List<String> // PayloadList<String,Exception> ISA List<String> // PayloadList<Integer, Exception> ISA List<Integer>

14 Type inference is a Java compiler's ability to look at each method invocation and corresponding declaration to determine the type argument (or arguments) that make the invocation applicable. For example, in the following Java determines that the second argument passed to Pick is of type Serializable. static <T> T pick(t a1, T a2) { return a2; Serializable s = pick("d", new ArrayList<String>()); Now, consider the method public static <U> void addbox(u u, java.util.list<box<u>> boxes) It can be called as BoxDemo.<Integer>addBox(Integer.valueOf(10), listofintegerboxes); or as Type inference BoxDemo.addBox(Integer.valueOf(20), listofintegerboxes); In the second case, Java will infer from the Integer first argument that the witness is Integer because the first argument and the witness have the same type in the declaration.

15 Given the declaration Map<String, List<String>> mymap = new HashMap<String, List<String>>(); you could declare this using Map<String, List<String>> mymap = new HashMap<>(); because Java knows how the Map<...> parameters are related to the HashMap type parameters. You must use the < > (diamond) or risk getting an unchecked type error. Now consider the class class MyClass<X> { <T> MyClass(T t) { //... Given the declaration new MyClass<Integer>("") More type inference Java will infer the value for T as String because that is the type of the constructor call.

16 More type inference - target types Given the declaration static <T> List<T> emptylist(); and the assignment List<String> listone = Collections.emptyList(); This statement is expecting an instance of List<String>; this data type is the target type. Because the method emptylist returns a value of type List<T>, the compiler infers that the type argument T must be the value String. This works in both Java SE 7 and 8. Alternatively, you could use a type witness and specify the value of T as follows: List<String> listone = Collections.<String>emptyList(); This processstringlist(collections.emptylist()); however, will not compile and will give the error List<Object> cannot be converted to List<String> Because no return target type is specified and Java assumes Object. To allow it to compile we must use a witness, i.e., processstringlist(collections.<string>emptylist());

17 The? can be used to specify an unknown type Wildcards Upper Bound Wildcards: To declare an upper-bounded wildcard, use the wildcard character ('?'), followed by the extends keyword, followed by its upper bound. Note that, in this context, extends is used in a general sense to mean either "extends" (as in classes) or "implements" (as in interfaces). public static void process(list<? extends Foo> list) { /*... */ Matches any type that is Foo or extends Foo. Unbounded Wildcards: The method public static void printlist(list<object> list) { for (Object elem : list) System.out.println(elem + " "); System.out.println(); only prints a list of Objects. To print any list, we need to use unbounded wildcards, i.e., public static void printlist(list<?> list) { for (Object elem: list) System.out.print(elem + " "); System.out.println(); This will take a list of anything type of object, and since tostring( ) is defined for all objects (a class inherits Object s tostring( ) if the class doesn t define one.)

18 Wildcards Say you want to write a method that puts Integer objects into a list. To maximize flexibility, you would like the method to work on List<Integer>, List<Number>, and List<Object> anything that can hold Integer values. To write the method that works on lists of Integer and the supertypes of Integer, such as Integer, Number, and Object, you would specify List<? super Integer>. The term List<Integer> is more restrictive than List<? super Integer> because the former matches a list of type Integer only, whereas the latter matches a list of any type that is a supertype (base class) of Integer. The following code adds the numbers 1 through 10 to the end of a list: public static void addnumbers(list<? super Integer> list) { for (int i = 1; i <= 10; i++) { list.add(i);

19 Type Erasure Generics were introduced to the Java language to provide tighter type checks at compile time and to support generic programming. To implement generics, the javac compiler applies type erasure to: Replace all type parameters in generic types with their bounds or Object if the type parameters are unbounded. The produced bytecode, therefore, contains only ordinary classes, interfaces, and methods. Insert type casts if necessary to preserve type safety. Generate bridge methods to preserve polymorphism in extended generic types. Type erasure ensures that no new classes are created for parameterized types; consequently, generics incur no runtime overhead.

20 public class Node<T> { private T data; private Node<T> next; Type Erasure public Node(T data, Node<T> next) this.data = data; this.next = next; public T getdata() { return data; //... unbounded public class Node { private Object data; private Node next; parameter public Node(Object data, Node next) { this.data = data; this.next = next; public Object getdata() { return data; //...

21 public class Node<T extends Comparable<T>> { private T data; private Node<T> next; public Node(T data, Node<T> next) { this.data = data; this.next = next; public T getdata() { return data; //... public class Node { Type Erasure bounded parameter private Comparable data; private Node next; public Node(Comparable data, Node next) { this.data = data; this.next = next; public Comparable getdata() { return data; //...

22 public class Node<T> { public T data; public Node(T data) { this.data = data; Effects of type public void setdata(t data) { System.out.println("Node.setData"); this.data = data; Intent is for MyNode to extend Node, and MyNode s setdata to override Node s Node MyNode mn = new MyNode(5); Node n = mn; n.setdata( Hello"); Integer x = mn.data; public class MyNode extends Node<Integer> { public MyNode(Integer data) { super(data); erasure public void setdata(integer data) { System.out.println("MyNode.setData"); super.setdata(data); Consider the code: // Node is a raw type - compiler gives an // unchecked warning // Causes a ClassCastException // to be thrown.

23 public class Node<T> { public T data; public Node(T data) { this.data = data; Effects of type public void setdata(t data) { System.out.println("Node.setData"); this.data = data; Intent is for MyNode to extend Node, and MyNode s setdata to override Node s Node public class MyNode extends Node<Integer> { public MyNode(Integer data) { super(data); erasure public void setdata(integer data) { System.out.println("MyNode.setData"); super.setdata(data); Consider the code (after type erasure): MyNode mn = new MyNode(5); Node n = (MyNode)mn; // A raw type - unchecked warning n.setdata("hello"); Integer x = (String)mn.data; // ClassCastException to be thrown.

24 Why the class cast exception? public class Node<T> { public T data; public Node(T data) { this.data = data; public void setdata(t data) { System.out.println("Node.setData"); this.data = data; After type erasure public class Node { public Object data; public Node(Object data) { this.data = data; public void setdata(object data) { System.out.println("Node.setData"); this.data = data;

25 Why the class cast exception? public class MyNode extends Node<Integer> { public MyNode(Integer data) { super(data); public void setdata(integer data) { System.out.println("MyNode.setData"); super.setdata(data); Node s setdata setdata(object) public class MyNode extends Node { public MyNode(Integer data) { super(data); setdata(integer) public void setdata(integer data) { System.out.println("MyNode.setData"); super.setdata(data); Node s setdata is not overriden!

26 Why the class cast exception? MyNode mn = new MyNode(5); Node n = (MyNode)mn; // A raw type - unchecked warning n.setdata("hello"); Integer x = (String)mn.data; // ClassCastException to be thrown. Node s setdata MyNode s setdata setdata(object) setdata(integer) n.setdata("hello"); causes the method setdata(object) to be executed on the object of class MyNode. (The MyNode class inherited setdata(object) from Node.) In the body of setdata(object), the data field of the object referenced by n is assigned to a String. The data field of that same object, referenced via mn, can be accessed and is expected to be an Integer (since mn is a MyNode which is a Node<Integer>. Trying to assign a String to an Integer causes a ClassCastException from a cast inserted at the assignment by a Java compiler.

27 Restrictions on Generics 1. Cannot Instantiate Generic Types with Primitive Types 2. Cannot Create Instances of Type Parameters 3. Cannot Declare Static Fields Whose Types are Type Parameters 4. Cannot Use Casts or instanceof With Parameterized Types 5. Cannot Create Arrays of Parameterized Types 6. Cannot Create, Catch, or Throw Objects of Parameterized Types 7. Cannot Overload a Method Where the Formal Parameter Types of Each Overload Erase to the Same Raw Type Cannot Instantiate Generic Types with Primitive Types class Pair<K, V> {... Pair<int, char> p = new Pair<>(8, 'a'); // compile-time error Pair<Integer, Character> p = new Pair<>(8, 'a'); // autoboxes Pair<Integer, Character> p = new Pair<>(Integer.valueOf(8), new Character('a'));

28 Restrictions on Generics Cannot Create Instances of Type Parameters public static <E> void append(list<e> list) { E elem = new E(); // compile-time error list.add(elem); As a workaround, you can create an object of a type parameter through reflection: public static <E> void append(list<e> list, Class<E> cls) throws Exception { E elem = cls.newinstance(); // OK list.add(elem);

29 Restrictions on Generics Cannot Declare Static Fields Whose Types are Type Parameters A static field is shared across all objects of the class. Consider the following class: public class MobileDevice<T> { private static T os; //... If static fields of type parameters were allowed, then the following code would be ambiguous: MobileDevice<Smartphone> phone = new MobileDevice<>(); MobileDevice<Pager> pager = new MobileDevice<>(); MobileDevice<TabletPC> pc = new MobileDevice<>(); Because the static field os is shared by phone, pager, and pc, what is the actual type of os? It cannot be Smartphone, Pager, and TabletPC at the same time. You cannot, therefore, create static fields of type parameters.