A parameterized type (also called type instance) is an invocation or instantiation of a generic type, that is a specific usage of the generic type where the formal type parameters are replaced by actual type parameters Analogy with method declarations and method invocations can be helpful in understanding the relationship between generic types and parameterized types We pass actual parameters in a method invocation to execute a method In the case of a generic type invocation, we pass actual type parameters in order to instantiate a generic type We can declare references and create objects of parameterized types, and call methods on these objects, in much the same way as we use non-generic classes

Node<Integer> intNode = new Node<Integer>(2008, null);

The actual type parameter Integer, explicitly specified in the declaration statement above, binds to the formal type parameter E in Example 142 The compiler treats the parameterized type Node<Integer> as a new type The parameterized type Node<Integer> constrains the generic type Node<E> to Integer objects, thus implementing homogenous nodes with Integers The reference intNode can only refer to a Node of Integer In the object creation expression of the new operator, the actual type parameter is mandatory after the class name, and the node created can only be used to store an object of this concrete type Methods can be called on objects of parameterized types:

Integer iRef = intNodegetData(); // 2008

In the method call above, the actual type parameter is determined from the type of the reference used to make the call The type of the intNode reference is Node<Integer>, therefore, the actual type parameter is Integer The method header is Integer getData(), meaning that the method will return a value of type Integer The compiler checks that the return value can be assigned As the compiler guarantees that the return value will be an Integer and can be assigned, no explicit cast or runtime check is necessary Here are some more examples of calling methods of parameterized types:

intNodesetData(2010); intNodesetData("TwentyTen"); intNodesetNext(new Node<Integer>(2009, null)); intNodesetNext(new Node<String>("Hi", null)); // // // // Ok (1) Compile-time error! (2010, (2009, null)) (2) Compile-time error!

In the method calls shown above, the compiler determines that the actual type parameter is Integer The method signatures are setData(Integer) and setNext(Node<Integer>) As expected, we get a compile-time error when we try to pass an argument that is not compatible with the parameter types in the method signatures, eg, at (1) and (2) The parameterized types Node<Integer> and Node<String> are two unrelated types The compiler reports any inconsistent use of a parameterized type, so that errors can be caught earlier at compile-time and use of explicit casts in the source code is minimized, as evident from (3) and (4), respectively

Node<String> strNode = new Node<String>("hi", null); intNode = strNode; // (3) Compile-time error! String str = strNodegetData(); // (4) No explicit cast necessary

Generic types also include generic interfaces, which are declared analogous to generic classes The specification of formal type parameters in a generic interface is the same as in a generic class Example 143 declares a generic interface for objects that store a data value of type E and return a reference value of type IMonoLink<E>

Example 143 A Generic Interface and its Implementation interface IMonoLink<E> { void setData(E data); E getData(); void setNext(IMonoLink<E> next); IMonoLink<E> getNext(); } class MonoNode<E> implements IMonoLink<E> { private E data; // Data private IMonoLink<E> next; // Reference to next node MonoNode(E data, IMonoLink<E> next) { thisdata = data; thisnext = next; } public void setData(E data) { thisdata = data; } public E getData() { return thisdata; } public void setNext(IMonoLink<E> next) { thisnext = next; } public IMonoLink<E> getNext() { return thisnext; } public String toString() { return thisdatatoString() + (thisnext == null "" : ", " + thisnexttoString()); } }

// (1) // (2)

// (2) // (3)

A generic interface can be implemented by a generic (or a non-generic) class:

class MonoNode<E> implements IMonoLink<E> { // }

Note that the construct <E> is used in two different ways in the class header The first occurrence of <E> declares E to be a type parameter, and the second occurrence of <E> parameterizes the generic interface with this type parameter The declarebefore-use rule also applies to type parameters The version of the MonoNode class in Example 143 differs from the Node class in Example 142 at (1), (2), (3), and (4) These changes were necessary to make the MonoNode<E> class compliant with the IMonoLink<E> interface A generic interface can be parameterized in the same way as a generic class In the code below, the reference strNode has the parameterized type IMonoLink<String> It is assigned the reference value of a node of type MonoNode<String> The assignment is legal, since the parameterized type MonoNode<String> is a subtype of the parameterized type IMonoLink<String>:

IMonoLink<String> strNode2 = new MonoNode<String>("Bye", null); Systemoutprintln(strNode2getData()); // Prints: Bye

As with non-generic interfaces, generic interfaces cannot be instantiated either:

IMonoLink<String> strNode3 = new IMonoLink<String>("Bye", null); // Error!