Generics Lecture 16 COP 3252 Summer 2017 June 1, 2017
Summary ◮ New feature in Java 1.5.0, and similar to C++ templates ◮ Can use in methods and in classes Uses type parameters, in angle brackets <> , just like C++ templates – one or more type parameters, separated by commas ◮ Unlike C++ templates, only reference types can be used with generic methods and classes (i.e. no primitive types, like int, float, etc). ◮ Syntactially similar to C++ templates, but instantiated differently when compiled. ◮ A C++ template generates separate copies of the code for each instantiated type ◮ Java typically uses one compiled version, where the type parameter is replaced with a more general parent type (thus making legal calls via polymorphism) ◮ Helps eliminate many situations in which casting was previously necessary
Generic methods - Basic usage Set up by putting a type parameter before the method’s return type, and use the type parameter name in place of fixed types in the method signature (and definition, if necessary). Example: public static < T > void PrintArray( T[] arr ) ◮ Type parameters receive actual type arguments when the method is called ◮ Operations in the method body must be legal for the type arguments used in the call, or compiler errors will occur ◮ Type parameters can represent only reference types, not primitive types ◮ Type Erasure: When instantiated, the above translates to the method: public static void PrintArray(Object[] arr) This process of replacing the type parameters with actual types is called type erasure.
Upper Bounds of Type Parameters ◮ In the process of erasure, type parameters are replaced with their upper bound ◮ Unless specified otherwise, Object is the default upper bound for type parameters ◮ To declare an upper bound on a type parameter, use the keyword extends, followed by the class or interface that is to be the upper bound. ◮ Example: ◮ If a generic method will use the compareTo method, declare the Comparable < T > generic interface as the upper bound with: public static < T extends Comparable< T > > T minimum(T x, T y, T z)
Upper Bounds of Type Parameters ◮ Note that Comparable < T > objects will have a compareTo() method. The translated version of the method after erasure will be: public static Comparable minimum(Comparable x, Comparable y, Comparable z) ◮ Now, the following call is legal, since String implements Comparable < String > String min = minimum("one", "three", "eight"); ◮ Special case: Even though type parameters can only take reference types, the following calls are legal due to a special new feature of Java 1.5.0, called autoboxing, where primitive types (like int) can sometimes be auto-converted to objects of the corresponding ”type wrapper” class (like Intetger): int m1 = minimum(6, 9, 10); double m2 = minimum(3.3, 10.5, 1.1);
Creating a generic class ◮ A generic class is declared like a regular class, with a type parameter section after the class name: public class Table< T > ◮ The type parameter(s) can be used throughout the class, including in generic methods, to represent the element type(s) ◮ The type parameter cannot be used after new, to create objects or arrays. To create an array, for example, create an array of type Object (or whatever the type parameter’s upper bound is), and then downcast the reference variable to the generic type: private T[] list; // array variable in a class list = (T[]) new Object[size]; // creation of array of reference variables
Using a generic class ◮ When declaring instances of a generic class, fill in the type parameter with an actual type argument ◮ Example: Suppose the following is a generic class: public class List< T > { // ... } ◮ Then the following are valid declarations of variables and objects: //suppose these are instance variables of a class private List< Double > dlist; private List< String > slist; // creation of objects dlist = new List< Double > (10); // List of Doubles slist = new List< String > (20); // List of Strings
Using a generic class ◮ Generic class types can be used as parameters in generic methods: public < T > void doStuff(List< T > x, T[] arr) ◮ For backwards compatibility, it is often possible to instantiate a generic class without a type argument. In this instance, a raw type is being used for the type argument: // implicitly uses Object as type argument List x = new List(5); // allowed because Int is a subclass of Object List y = new List< Int > (5); /*permitted, but less safe, since the List object is not guaranteed to store type Double, although the variable is set that way. Compiler will probably issue a warning */ List< Double > dList = new List(10);
Wildcards in Methods that Accept Type Parameters ◮ Suppose we have this method: public static double average(List< Number > x) { // ... } ◮ Note that java.lang.Number is a base class for all the numeric type wrapper classes (like Integer, Float, etc). ◮ Numbers of various types could be stored in a List < Number > object ◮ BUT, a List < Double > object could not be passed into this method. Nor could a List < Integer > object. ◮ While Number is a superclass of Integer and Double, the class List < Number > would not be considered a superclass of List < Double > and List < Integer >
Wildcards in Methods that Accept Type Parameters ◮ To make the above method more versatile (and accept these types), we can use a wildcard, denoted by the question mark (?), and represents ”unknown type” public static double average(List< ? extends Number > x) { // ... } ◮ The unknown type may be filled with Number or any subclass of Number (like Double or Integer) ◮ Number is an upper bound ◮ Other varieties of wildcards ◮ If < ? > is used, it means any type could fill this slot: public static void func(List< ? > x) // ... //any List object (type filled in) could be sent ◮ If < ? super T > is used, this sets up T as a lower bound on the type that fills the slot public static void func(List< ? super Number > x) { // ... } // can send in a List object instatiated with //Number, or a super-type (a parent)
Recommend
More recommend
