程序代写代做 concurrency graph go Fortran AI Java game file system chain algorithm assembler ER clock information theory Hive flex interpreter assembly FTP c# compiler gui html Excel jvm c++ android database cache c/c++ data structure C Herbert Schildt | Dale Skrien Java

// }
}
Gen w3 = new Gen(c); Gen w4 = new Gen(d);
// These calls to test() are OK. test(w);
test(w2);
test(w3);
// Can’t call test() with w4 because // it is not an object of a class that // inherits A.
test(w4); // Error!
These are legal because w, w2, and w3 are subclasses of A.
This is illegal because w4 is not a subclass of A.
Java programming 521
In main( ), objects of type A, B, C, and D are created. These are then used to create four Gen objects, one for each type. Finally, four calls to test( ) are made, with the last call commented out. The first three calls are valid because w, w2, and w3 are Gen objects whose type is either A or a subclass of A. However, the last call to test( ) is illegal because w4 is an object of type D, which is not derived from A. Thus, the method will not accept w4 because of the wildcard’s bound.
In general, to establish an upper bound for a wildcard, use the following type of wildcard expression:

where superclass is the name of the class that serves as the upper bound. Remember, this is an inclusive clause because the class forming the upper bound (specified by superclass) is also within bounds.
You can also specify a lower bound for a wildcard by adding a super clause to a wildcard declaration. Here is its general form:

In this case, only classes that are superclasses of subclass are acceptable arguments.
This is an inclusive clause.
1. To specify a wildcard argument, use _______.
2. A wildcard argument matches any reference type. True or False? 3. Can a wildcard be bounded?
4. In this expression, what types can be matched by the wildcard?
void myMeth(XYZ trdOb) { // …
Answers:
1. ?
2. True.
3. Yes.
4. The wildcard can match type Thread or a subclass of Thread.
progress Check

522 chapter 14 Generics
ask the expert
Q Can I cast one instance of a generic class into another?
AYes, but its use is somewhat limited. You can cast one instance of a generic class into another only if the two are otherwise compatible and their type arguments are the same. For example, assume a generic class called Gen that is declared like this:
class Gen { // …
Next, assume that x is declared as shown here: Gen x = new Gen();
Then, this cast is legal:
(Gen) x // legal
because x is an instance of Gen. But, this cast (Gen) x // illegal
is not legal because x is not an instance of Gen.
GeneriC methOds
As the preceding examples have shown, methods inside a generic class can make use of a class’s type parameter and are, therefore, automatically generic relative to the type parameter. However, it is possible to declare a generic method that uses one or more type parameters of its own. Furthermore, it is possible to create a generic method that is enclosed within a non-generic class.
The following program declares a non-generic class called GenericMethodDemo and a static generic method within that class called arraysEqual( ). This method determines if two arrays contain the same elements, in the same order. It can be used to compare any two arrays as long as the arrays are of the same or compatible types.
// Demonstrate a simple generic method. class GenericMethodDemo {
// Determine if the contents of two arrays are the same. static boolean arraysEqual(T[] x, V[] y) {
// If array lengths differ, then the arrays differ. if(x.length != y.length) return false;
for(int i=0; i < x.length; i++) if(!x[i].equals(y[i])) return false; // arrays differ return true; // contents of arrays are equivalent } A generic method. public static void main(String[] args) { Java programming 523 Integer[] nums = { 1, 2, 3, 4, 5 }; Integer[] nums2 = { 1, 2, 3, 4, 5 }; Integer[] nums3 = { 1, 2, 7, 4, 5 }; Integer[] nums4 = { 1, 2, 7, 4, 5, 6 }; if(arraysEqual(nums, nums)) System.out.println("nums equals nums"); if(arraysEqual(nums, nums2)) System.out.println("nums equals nums2"); if(arraysEqual(nums, nums3)) System.out.println("nums equals nums3"); if(arraysEqual(nums, nums4)) System.out.println("nums equals nums4"); // Create an array of Doubles Double[] dvals = { 1.1, 2.2, 3.3, 4.4, 5.5 }; // This won’t compile because nums and dvals // are not of the same type. if(arraysEqual(nums, dvals)) System.out.println("nums equals dvals"); The output from the program is shown here: nums equals nums nums equals nums2 The type arguments for T and V are implicitly determined when the method is called. // // } } Let’s examine arraysEqual( ) closely. First, notice how it is declared by this line: static boolean arraysEqual(T[] x, V[] y) {
The type parameters are declared before the return type of the method. Second, notice that the type V is upper-bounded by T. Thus, V must be either the same as type T or a subclass of T. This relationship enforces that arraysEqual( ) can be called only with arguments that are compatible with each other. Also notice that arraysEqual( ) is static, enabling it to be called independently of any object. Understand, though, that generic methods can be either static or nonstatic. There is no restriction in this regard.
Now, notice how arraysEqual( ) is called within main( ) by use of the normal call syntax, without the need to specify type arguments. This is because the types of the arguments are automatically discerned, and the types of T and V are adjusted accord- ingly. For example, in the first call:
if(arraysEqual(nums, nums))
the base type of the first argument is Integer, which causes Integer to be substituted for T. The base type of the second argument is also Integer, which makes Integer a

524 chapter 14 Generics
substitute for V, too. Thus, the call to arraysEqual( ) is legal, and the two arrays can be compared.
Now, notice the commented-out code, shown here:
// if(arraysEqual(nums, dvals))
// System.out.println(“nums equals dvals”);
If you remove the comments and then try to compile the program, you will receive an error. The reason is that the type parameter V is bounded by T in the extends clause in V’s declaration. This means that V must be either type T or a subclass of T. In this case, the first argument is of type Integer, making T into Integer, but the second argument is of type Double, which is not a subclass of Integer. This makes the call to arraysEqual( ) illegal and results in a compile-time type- mismatch error.
The syntax used to create arraysEqual( ) can be generalized. Here is the syntax for a generic method:
ret-type meth-name(param-list) { // …
In all cases, type-param-list is a comma-separated list of type parameters. Notice that
for a generic method, the type parameter list precedes the return type.
GeneriC COnstruCtOrs
A constructor can be generic, even if its class is not. For example, in the following program, the class Summation is not generic, but its constructor is.
// Use a generic constructor. class Summation {
private int sum;
Summation(T arg) { A generic constructor sum = 0;
for(int i=0; i <= arg.intValue(); i++) sum += i; } int getSum() { return sum; } } class GenConsDemo { public static void main(String[] args) { Summation ob = new Summation(4.0); System.out.println("Summation of 4.0 is " + ob.getSum()); } } Java programming 525 The Summation class computes and encapsulates the summation of the numeric value passed to its constructor. In this case, we are using a summation of N that is the sum of all the whole numbers between 0 and N. Because Summation( ) specifies a type parameter that is bounded by Number, a Summation object can be constructed using any numeric type, including Integer, Float, or Double. No matter what numeric type is used, its value is converted to Integer by calling intValue( ), and the summation is computed. Therefore, it is not necessary for the class Summation to be generic; only a generic constructor is needed. GeneriC Class hierarChies A generic class can be part of a class hierarchy in just the same way as a non-generic class. Thus, a generic class can act as a superclass or be a subclass. The key differ- ence between generic and non-generic hierarchies is that in a generic hierarchy, any type arguments needed by a generic superclass must be passed up the hierarchy by all subclasses. This is similar to the way that constructor arguments must be passed up a hierarchy. Here is a simple example of a hierarchy that uses a generic superclass: // A simple generic class hierarchy. class Gen {
T ob;
Gen(T o) { ob = o;
}
// Return ob. T getob() {
return ob; }
}
// A subclass of Gen.
class Gen2 extends Gen {
Gen2(T o) { super(o);
} }
In this hierarchy, Gen2 extends the generic class Gen. Notice how Gen2 is declared by the following line:
class Gen2 extends Gen {
The type parameter T is specified by Gen2 and is also passed to Gen in the extends clause. This means that whatever type is passed to Gen2 will also be passed to Gen. For example, this declaration,
Gen2 num = new Gen2(100);

526 chapter 14 Generics
passes Integer as the type parameter to Gen. Thus, the ob inside the Gen portion of Gen2 will be of type Integer.
Notice also that Gen2 does not use the type parameter T except to pass it to the Gen superclass. Thus, even if a subclass of a generic superclass would otherwise not need to be generic, it still must specify the type parameter(s) required by its generic superclass. Of course, a subclass is free to add its own type parameters, if needed.
It is also perfectly acceptable for a non-generic class to be the superclass of a generic subclass. For example:
// A non-generic class can be the superclass // of a generic subclass.
// A non-generic class. class NonGen {
int num;
NonGen(int i) { num = i;
}
int getnum() { return num;
} }
// A generic subclass.
class Gen extends NonGen {
T ob; // declare an object of type T
// Pass the constructor a reference to // an object of type T.
Gen(T o, int i) {
super(i);
ob = o; }
// Return ob. T getob() {
return ob; }
}
Notice how Gen inherits NonGen in the following declaration: class Gen extends NonGen {
Because NonGen is not generic, no type argument is specified. Thus, even though Gen declares the type parameter T, it is not needed by (nor can it be used by) NonGen. Thus, NonGen is inherited by Gen in the normal way. No special con- ditions apply.

Java programming 527
ask the expert
Q In a generic class hierarchy, can a method with a type parameter be over- ridden?
A Yes. A generic method in a generic class hierarchy can be overridden just like any other method. For example, consider this example in which the method
getob( ) is overridden:
// Overriding a generic method in a generic class. class Gen {
T ob; // declare an object of type T
// Pass the constructor a reference to // an object of type T.
Gen(T o) {
ob = o; }
// Return ob. T getob() {
System.out.print(“Gen’s getob(): ” );
return ob; }
}
// A subclass of Gen that overrides getob(). class Gen2 extends Gen {
Gen2(T o) { super(o);
}
// Override getob(). T getob() {
System.out.print(“Gen2’s getob(): “);
return ob; }
}
// Demonstrate generic method override. class OverrideDemo {
public static void main(String[] args) {
// A Gen reference that can refer to any type of Gen object. Gen gRef;
// Create a Gen object for Integers. Gen iOb = new Gen(88);

528 chapter 14 Generics
ask the expert (Continued)
// Create a Gen2 object for Integers. Gen2 iOb2 = new Gen2(99);
// Create a Gen2 object for Strings.
Gen2 strOb2 = new Gen2 (“Generics Test”);
gRef = iOb; System.out.println(gRef.getob());
gRef = iOb2; System.out.println(gRef.getob());
gRef = strOb2;
System.out.println(gRef.getob()); }
}
The output is shown here:
Gen’s getob(): 88
Gen2’s getob(): 99
Gen2’s getob(): Generics Test
In the program, notice that the generic reference gRef is used to call getob( ) on objects of both Gen and Gen2. As the output confirms, the overridden version of getob( ) is called for objects of type Gen2, but the superclass version is called for objects of type Gen.
progress Check
1. Can a method or constructor be generic even if its class is not?
2. Show how to declare a generic method called myMeth( ) that takes one generic
type argument. Have it return an argument of that generic type. 3. A generic class cannot be inherited. True or False?
GeneriC interFaCes
In addition to generic classes and methods, you can also have generic interfaces. Generic interfaces are specified just like generic classes. Here is an example. It cre- ates an interface called Containment, which can be implemented by classes that
Answers:
1. Yes.
2. T myMeth(T o) 3. False.

Java programming 529 store one or more values. It declares a method called contains( ) that determines if a
specified value is contained by the invoking object.
// A generic interface example.
// A generic containment interface.
// This interface implies that an implementing // class contains one or more values. interface Containment {
A generic interface.
// The contains() method tests if a
// specific item is contained within
// an object that implements Containment. boolean contains(T o);
}
// Implement Containment using an array to // hold the values.
class MyClass implements Containment {
Any class that implements a generic interface must itself be generic.
T[] arrayRef;
MyClass(T[] o) { arrayRef = o;
}
// Implement Contains(). public boolean contains(T o) {
for(T x : arrayRef) if(x.equals(o)) return true;
return false; }
}
class GenIFDemo {
public static void main(String[] args) {
Integer[] x = { 1, 2, 3 };
MyClass ob = new MyClass(x);
if(ob.contains(2)) System.out.println(“2 is in ob”);
else
System.out.println(“2 is NOT in ob”);
if(ob.contains(5)) System.out.println(“5 is in ob”);
else
System.out.println(“5 is NOT in ob”);
// The following is illegal because ob // is an Integer Containment and 9.25 is // a Double value.

530 chapter 14 Generics
// //
} }
The output is shown here:
2 is in ob
5 is NOT in ob
Although most aspects of this program should be easy to understand, a couple of key points need to be made. First, notice that Containment is declared like this:
interface Containment {
In general, a generic interface is declared in the same way as a generic class. In this case, the type parameter T specifies the type of objects that are contained.
Next, Containment is implemented by MyClass. Notice the declaration of MyClass, shown here:
class MyClass implements Containment {
In general, if a class implements a generic interface, then that class must also be generic, at least to the extent that it takes a type parameter that is passed to the inter- face. For example, the following attempt to declare MyClass is in error:
class MyClass implements Containment { // Wrong!
This declaration is wrong because MyClass does not declare a type parameter, which means that there is no way to pass one to Containment. In this case, the identifier T is simply unknown and the compiler reports an error. Of course, if a class implements a specific type of generic interface, such as shown here:
class MyClass implements Containment { // OK
then the implementing class does not need to be generic.
As you might expect, the type parameter(s) specified by a generic interface can
be bounded. This lets you limit the type of data for which the interface can be imple- mented. For example, if you wanted to limit Containment to numeric types, then you could declare it like this:
interface Containment {
Now, any implementing class must pass to Containment a type argument also having the same bound. For example, now MyClass must be declared as shown here:
class MyClass implements Containment {
Pay special attention to the way the type parameter T is declared by MyClass and then passed to Containment. Because Containment now requires a type that extends
if(ob.contains(9.25)) // Illegal! System.out.println(“9.25 is in ob”);

Java programming 531
Number, the implementing class (MyClass in this case) must specify the same bound. Furthermore, once this bound has been established, there is no need to specify it again in the implements clause. In fact it would be wrong to do so. For example, this dec- laration is incorrect and won’t compile:
// This is wrong!
class MyClass
implements Containment { // Wrong!
Once the type parameter has been established, it is simply passed to the interface without further modification.
Here is the generalized syntax for a generic interface: interface interface-name { // …
Here, type-param-list is a comma-separated list of type parameters. When a generic interface is implemented, you must specify the type arguments, as shown here:
class class-name
implements interface-name {
Try This 14-1 Create a Simple Generic Stack
IGenSimpleStack.java
SimpleStackExc.java
GenSimpleStack.java
GenSimpleStackDemo.java
One of the most powerful advantages that generics bring to programming is the abil- ity to construct reliable, reusable code. As mentioned at the start of this chapter, many algorithms are the same no matter what type of data they are used on. For example, the basic functionality of a stack is the same no matter what type of objects are being stored. Instead of creating a separate stack class for each specific type of object, you can craft a single, generic solution that can be used with any type of object. Thus, the development cycle of design, code, test, and debug occurs only once when you create a generic solution—not repeatedly, each time a stack is needed for a new data type.
In this project you will adapt the simple stack example that has been evolving since Try This 5-2, making it generic. This project represents the final evolution of the stack. It includes a generic interface that defines the stack operations, a generic fixed-length stack implementation, and the stack exception classes. This version of the stack will be called GenSimpleStack.
STEP-By-STEP
1. The first step in creating a generic stack is to create a generic interface that describes the stack’s operations. The generic version of the stack

532 chapter 14 Generics
interface is called IGenSimpleStack and it is shown here. Put this inter- face into a file called IGenSimpleStack.java.
// A generic interface for a simple stack. public interface IGenSimpleStack {
// Push an item onto the stack.
void push(T item) throws StackFullException;
// Pop an item from the stack.
T pop() throws StackEmptyException;
// Return true if the stack is empty. boolean isEmpty();
// Return true if the stack is full.
boolean isFull(); }
Notice that this interface is similar to the non-generic version developed in
Try This 10-1 except that the data type is specified by T rather than char.
2. The generic stack can use the same, non-generic exception classes developed in Try This 10-1. Recall that they encapsulate the two stack errors: full or
empty. They are not generic classes because they are the same no
matter what type of data is stored in the stack. For your convenience, they are shown again here. They should be in the file SimpleStackExc.java.
// An exception for stack-full errors.
class StackFullException extends Exception {
int size;
StackFullException(int s) { super(“Stack Full”);
size = s;
}
public String toString() {
return “\nStack is full. Maximum size is ” + size;
} }
// An exception for stack-empty errors.
class StackEmptyException extends Exception {
StackEmptyException() { super(“Stack Empty”);
}
public String toString() { return “\nStack is empty.”;
} }

Java programming 533
3. Now, create a file called GenSimpleStack.java. Into that file, put the fol- lowing code, which implements a simple fixed-size, generic stack.
// A simple generic fixed-length stack.
class GenSimpleStack implements IGenSimpleStack {
private T[] data; // this array holds the stack private int tos; // index of top of stack
// Construct an empty stack with the given array as storage. GenSimpleStack(T[] arrayRef) {
data = arrayRef;
tos = 0; }
// Push an item onto the stack.
public void push(T obj) throws StackFullException {
if(isFull())
throw new StackFullException(data.length);
data[tos] = obj;
tos++; }
// Pop an item from the stack.
public T pop() throws StackEmptyException {
if(isEmpty())
throw new StackEmptyException();
tos–;
return data[tos]; }
// Return true if the stack is empty. public boolean isEmpty() {
return tos==0; }
// Return true if the stack is full. public boolean isFull() {
return tos==data.length; }
}
GenSimpleStack is a generic class with type parameter T, which specifies the type of data stored in the stack. Notice that T is also passed to the IGenSimpleStack interface.
Pay special attention to the GenSimpleStack constructor. It is passed a reference to an array that will be used to hold the stack. Thus, to construct a GenSimpleStack, you will first create an array whose type is compatible with

534 chapter 14 Generics
the objects that you will be storing in the stack and whose size is long enough to store the number of objects that will be placed in the stack. For example, the following sequence shows how to create a 10-element stack that holds strings:
String[] strArray = new String[10];
GenSimpleStack strStack = new GenSimpleStack(strArray);
4. To demonstrate GenSimpleStack, create a file called GenSimpleStackDemo.java and put the following code into it.
/*
Try This 14-1
Demonstrate a simple generic stack class. */
class GenSimpleStackDemo {
public static void main(String[] args) {
int i;
Integer[] nums = new Integer[5]; String[] strs = new String[3];
// first create a stack for integers
GenSimpleStack intStack = newGenSimpleStack(nums);
System.out.println(“Demonstrating Integer stack.”);
// use intStack try {
System.out.print(“Pushing: “);
// push integers onto intStack
for(i = 0; !intStack.isFull(); i++) {
System.out.print(i);
intStack.push(i); }
System.out.println();
// pop integers off intStack System.out.print(“Popping: “); while(!intStack.isEmpty())
System.out.print(intStack.pop());
System.out.println();
} catch (StackFullException exc) {
System.out.println(exc);
} catch (StackEmptyException exc) {
System.out.println(exc); }

Java programming 535
// next, create a stack for strings
GenSimpleStack strStack = new GenSimpleStack(strs);
System.out.println(“\nDemonstrating String stack.”);
// now, use strStack try {
System.out.println(“Pushing: alpha beta gamma”);
// push strings onto strStack strStack.push(“alpha”); strStack.push(“beta”); strStack.push(“gamma”);
// pop Strings off strStack System.out.print(“Popping: “); while(!strStack.isEmpty())
System.out.print(strStack.pop() + ” “);
System.out.println();
} catch (StackFullException exc) {
System.out.println(exc);
} catch (StackEmptyException exc) {
System.out.println(exc); } System.out.println();
} }
5. Compile all the files and then run GenSimpleStackDemo. You will see the output shown here:
Demonstrating Integer stack. Pushing: 01234
Popping: 43210
Demonstrating String stack. Pushing: alpha beta gamma Popping: gamma beta alpha
raW types and leGaCy COde
Because support for generics did not exist prior to JDK 5, it was necessary for Java to provide some transition path from existing, pre-generics code. Simply put: all pre- generics code needed to remain both functional and compatible with new code that used generics. This meant that pre-generics code must be able to work with generics, and generic code must be able to work with pre-generics code.
To handle the transition to generics, Java allows a generic class to be used without any type arguments. This creates a raw type for the class. This raw type is compatible

536 chapter 14 Generics
with legacy code, which has no knowledge of generics. The main drawback to using the raw type is that the type safety of generics is lost.
Here is an example that shows a raw type in action.
// Demonstrate a raw type. class Gen {
T ob; // declare a reference to an object of type T
// Pass the constructor a reference to // an object of type T.
Gen(T o) {
ob = o; }
// Return ob. T getob() {
return ob; }
}
// Demonstrate raw type. class RawDemo {
public static void main(String[] args) {
// Create a Gen object for Integers. Gen iOb = new Gen(88);
// Create a Gen object for Strings.
Gen strOb = new Gen(“Generics Test”);
// Create a raw-type Gen object and give it // a Double value.
Gen raw = new Gen(new Double(98.6));
// Cast here is necessary because type is unknown. double d = (Double) raw.getob(); System.out.println(“value: ” + d);
// The use of a raw type can lead to run-time. // exceptions. Here are some examples.
// The following cast causes a run-time error!
int i = (Integer) raw.getob(); // run-time error
// This assignment overrides type safety. strOb = raw; // OK, but potentially wrong
String str = strOb.getob(); // run-time error
// This assignment also overrides type safety. raw = iOb; // OK, but potentially wrong
d = (Double) raw.getob(); // run-time error
When no type argument is supplied, a raw type is created.
//
//
// }
Raw types override type safety.
}

Java programming 537 This program contains several interesting things. First, a raw type of the generic
Gen class is created by the following declaration: Gen raw = new Gen(new Double(98.6));
Notice that no type arguments are specified. In essence, this creates a Gen object whose type T is replaced by Object.
A raw type is not type safe. Thus, a variable of a raw type can be assigned a refer- ence to any type of Gen object. The reverse is also allowed, in which a variable of a specific Gen type can be assigned a reference to a raw Gen object. However, both operations are potentially unsafe because the type checking mechanism of generics is circumvented.
This lack of type safety is illustrated by the commented-out lines at the end of the program. Let’s examine each case. First, consider the following situation:
// int i = (Integer) raw.getob(); // run-time error
In this statement, the value of ob inside raw is obtained, and this value is cast to Integer. The trouble is that raw contains a Double value, not an integer value. However, this cannot be detected at compile time because the type of raw is unknown. Thus, this statement fails at run time.
The next sequence assigns to a strOb (a reference of type Gen) a reference to a raw Gen object:
strOb = raw; // OK, but potentially wrong
// String str = strOb.getob(); // run-time error
The assignment itself is syntactically correct, but questionable. Because strOb is of type Gen, it is assumed to contain a String. However, after the assignment, the object referred to by strOb contains a Double. Thus, at run time, when an attempt is made to assign the contents of strOb to str, a run-time error results because strOb now contains a Double. Thus, the assignment of a raw reference to a generic reference bypasses the type-safety mechanism.
The following sequence inverts the preceding case:
raw = iOb; // OK, but potentially wrong
// d = (Double) raw.getob(); // run-time error
Here, a generic reference is assigned to a raw reference variable. Although this is syntactically correct, it can lead to problems, as illustrated by the second line. In this case, raw now refers to an object that contains an Integer object, but the cast assumes that it contains a Double. This error cannot be prevented at compile time. Rather, it causes a run-time error.
Because of the potential for danger inherent in raw types, javac displays unchecked warnings when a raw type is used in a way that might jeopardize type safety. In the preceding program, these lines generate unchecked warnings:
Gen raw = new Gen(new Double(98.6)); strOb = raw; // OK, but potentially wrong

538 chapter 14 Generics
In the first line, it is the call to the Gen constructor without a type argument that causes the warning. In the second line, it is the assignment of a raw reference to a generic variable that generates the warning.
At first, you might think that this line should also generate an unchecked warning, but it does not:
raw = iOb; // OK, but potentially wrong
No compiler warning is issued because the assignment does not cause any further loss of type safety than had already occurred when raw was created.
One final point: you should limit the use of raw types to those cases in which you must mix legacy code with newer, generic code. Raw types are simply a transitional feature and not something that should be used for new code.
type inFerenCe With the diamOnd OperatOr
Beginning with JDK 7, it is possible to shorten the syntax used to create an instance of a generic type. To begin, think back to the TwoGen class shown earlier in this chapter. A portion is shown here for convenience. Notice that it uses two generic types.
class TwoGen { T ob1;
V ob2;
// Pass the constructor a reference to // an object of type T.
TwoGen(T o1, V o2) {
ob1 = o1;
ob2 = o2; }
// … }
For versions of Java prior to JDK 7, to create an instance of TwoGen, you must use a statement similar to the following:
TwoGen tgOb =
new TwoGen(42, “testing”);
Here, the type arguments (which are Integer and String) are specified twice: first, when tgOb is declared, and second, when a TwoGen instance is created when its constructor is called via new. Since generics were introduced by JDK 5, this is the form required by all versions of Java prior to JDK 7. While there is nothing wrong, per se, with this form, it is a bit more verbose than it needs to be. Since, in the new clause, the type of the type arguments can be readily inferred, there is really no reason that they need to be specified a second time. To address this situation, JDK 7 adds a syntactic element that lets you avoid the second specification.
In JDK 7, the preceding declaration can be rewritten as shown here:
TwoGen tgOb = new TwoGen<>(42, “testing”);

Java programming 539
Notice that the instance creation portion simply uses < >, which is an empty type argument list. This is referred to as the diamond operator. It tells the compiler to infer the type arguments needed by the constructor. The principal advantage of this type- inference syntax is that it shortens what are sometimes quite long declaration state- ments. This is especially helpful for generic types that specify bounds.
The preceding example can be generalized. When type inference is used, the declaration syntax for a generic reference and instance creation has this general form:
class-name var-name = new class-name< >(cons-arg-list);
Here, the type argument list of the new clause is empty.
Although mostly for use in declaration statements, type inference can also be
applied to parameter passing. For example, if the following method is added to TwoGen:
boolean isSame(TwoGen o) {
if(ob1 == o.ob1 && ob2 == o.ob2) return true; else return false;
}
Then, the following call is legal in JDK 7:
if(tgOb.isSame(new TwoGen<>(42, “testing”))) System.out.println(“Same”);
In this case, the type arguments for the argument passed to isSame( ) can be inferred. They don’t need to be specified again.
Because the diamond operator is new to JDK 7 and it won’t work with older compil- ers, the remaining examples of generics in this book will continue to use the full syntax when declaring instances of generic classes. This way, the examples will work with any Java compiler that supports generics. Using the full-length syntax also makes it very clear precisely what is being created, which is helpful when example code is shown. Of course, in your own code, use of the type inference syntax will streamline your declarations.
1. If a generic interface is implemented by a class, that class must also be generic. True or False?
2. A type parameter in a generic interface cannot be bounded. True or False?
3. Given
class XYZ { // …
show how to declare an object called ob that is XyZ’s raw type.
4. Type inference uses the _____________ operator.
Answers:
1. True.
2. False.
3. XYZ ob = new XYZ(); 4. diamond
progress Check

540 chapter 14 Generics erasure
Usually, it is not necessary for the programmer to know the details about how the Java compiler transforms source code into object code. However, in the case of generics, some general understanding of the process is important because it explains why the generic features work as they do—and why their behavior is sometimes a bit surpris- ing. For this reason, a brief discussion of how generics are implemented in Java is in order.
An important constraint that governed the way generics were added to Java was the need for compatibility with previous versions of Java. Simply put: generic code had to be compatible with preexisting, non-generic code. Thus, any changes to the syntax of the Java language, or to the JVM, had to avoid breaking older code. The way Java implements generics while satisfying this constraint is through the use of erasure.
In general, here is how erasure works. When your Java code is compiled, all generic type information is removed (erased). This means replacing type parameters with their bound type, which is Object if no explicit bound is specified, and then applying the appropriate casts (as determined by the type arguments) to maintain type compatibility with the types specified by the type arguments. The compiler also enforces this type compatibility. This approach to generics means that no type parameters exist at run time. They are simply a source-code mechanism.
amBiGuity errOrs
The inclusion of generics gives rise to a new type of error that you must guard against: ambiguity. Ambiguity errors occur when erasure causes two seemingly distinct generic declarations to resolve to the same erased type, causing a conflict. Here is an example that involves method overloading:
// Ambiguity caused by erasure on // overloaded methods.
class MyGenClass {
T ob1; V ob2;
// …
// These two overloaded methods are ambiguous // and will not compile.
void set(T o) {
ob1 = o;
} These two methods are
void set(V o) { ob2 = o;
} }
inherently ambiguous.
Notice that MyGenClass declares two generic types: T and V. Inside MyGenClass, an attempt is made to overload set( ) based on parameters of type T and V. This looks

Java programming 541
reasonable because T and V appear to be different types. However, there are two ambiguity problems here.
First, as MyGenClass is written, there is no requirement that T and V actually be different types. For example, it is perfectly correct (in principle) to construct a MyGenClass object as shown here:
MyGenClass obj = new MyGenClass()
In this case, both T and V will be replaced by String. This makes both versions of set( ) identical, which is, of course, an error.
Second, and more fundamental, is that the type erasure of set( ) effectively reduces both versions to the following:
void set(Object o) { // …
Thus, the overloading of set( ) as attempted in MyGenClass is inherently ambiguous. The solution in this case is to use two separate method names rather than trying to overload set( ).
1. Erasure _________ all type parameters, substituting their bound types and applying appropriate casts.
2. By default, the bound type of a type parameter is ________.
3. Ambiguity can occur when type erasure causes two seemingly different decla-
rations to resolve to the same erased type. True or False?
sOme GeneriC restriCtiOns
There are a few restrictions that you need to keep in mind when using generics. They involve creating objects of a type parameter, static members, exceptions, and arrays. Each is examined here.
type parameters Can’t Be instantiated
It is not possible to create an instance of a type parameter. For example, consider this class:
// Can’t create an instance of T. class Gen {
T ob; Gen() {
ob = new T(); // Illegal!!! }
}
Answers:
1. removes 2. Object 3. True.
progress Check

542 chapter 14 Generics
Here, it is illegal to attempt to create an instance of T. The reason should be easy to understand: the compiler has no way to know what type of object to create. T is simply a placeholder.
restrictions on static members
No static member can use a type parameter declared by the enclosing class. For example, both of the static members of this class are illegal:
class Wrong {
// Wrong, no static variables of type T. static T ob;
// Wrong, no static method can use T. static T getob() {
return ob; }
}
Although you can’t declare static members that use a type parameter declared by the enclosing class, you can declare static generic methods, which define their own type parameters, as was done earlier in this chapter.
Generic array restrictions
There are two important generics restrictions that apply to arrays. First, you cannot instantiate an array whose element type is a type parameter. Second, you cannot cre- ate an array of type-specific generic references. The following short program shows both situations.
// Generics and arrays.
class Gen {
T ob;
T[] vals; // OK
Gen(T o, T[] nums) { ob = o;
// This statement is illegal.
// vals = new T[10]; // can’t create an array of T
// But, this statement is OK.
vals = nums; // OK to assign reference to existent array }
}
class GenArrays {
public static void main(String[] args) {
Integer[] n = { 1, 2, 3, 4, 5 };

Gen iOb = new Gen(50, n);
Java programming 543
// Can’t create an array of type-specific generic references. // Gen[] gens = new Gen[10]; // Wrong!
// This is OK.
Gen[] gens = new Gen[10]; // OK }
}
As the program shows, it’s valid to declare a reference to an array of type T, as this line does:
T[] vals; // OK
But you cannot instantiate an array of T, as this commented-out line attempts: // vals = new T[10]; // can’t create an array of T
The reason you can’t create an array of T is that there is no way for the compiler to know what type of array to actually create. However, you can pass a reference to a type-compatible array to Gen( ) when an object is created and assign that reference to vals, as the program does in this line:
vals = nums; // OK to assign reference to existent array
This works because the array passed to Gen( ) has a known type, which will be the same type as T at the time of object creation. Inside main( ), notice that you can’t declare an array of references to a specific generic type. That is, this line
// Gen[] gens = new Gen[10]; // Wrong!
won’t compile.
Generic exception restriction
A generic class cannot extend Throwable. This means that you cannot create generic exception classes.
exerCises
1. Generics are important to Java because they enable the creation of code that is A. Type-safe
B. Reusable
C. Reliable
D. All of the above
2. Can a primitive type be used as a type argument?
3. Show how to declare a class called FlightSched that takes two generic parameters.

544 chapter 14 Generics
4. Beginning with your answer to question 3, change FlightSched’s second type parameter so that it must extend Thread.
5. Now, change FlightSched so that its second type parameter must be a subclass of its first type parameter.
6. As it relates to generics, what is the ? and what does it do?
7. Can the wildcard argument be bounded?
8. A generic method called MyGen( ) has one type parameter. Furthermore,
MyGen( ) has one parameter whose type is that of the type parameter. It also
returns an object of that type parameter. Show how to declare MyGen( ).
9. Given this generic interface
interface IGenIF { // …
show the declaration of a class called MyClass that implements IGenIF.
10. Given a generic class called Counter, show how to create an object of
its raw type.
11. Do type parameters exist at run time?
12. When a generic class is inherited, its type parameters must also be specified
by the subclass. True or False?
13. What is < >?
14. When using JDK 7, how can the following be simplified?
MyClass obj = new MyClass(1.1,”Hi”);
15. Which of the following lines of code are legal declarations of generic methods? If any are not legal, explain why not.
A. void print(T x) { System.out.println(x); }
B. static void print(T x) { System.out.println(x); }
C. T getT(T t) { return null; }
D. void print(Object x) { System.out.println(x); }
E. void print(V x) { System.out.println(x); }
F. void print(T x) { System.out.println(x); }
16. In the body of a generic method with parameter type T, you cannot use the assignment statement
T[] x = new T[10];
because you cannot create arrays of the parameter type T. Would it work to initialize x as follows?
T[] x = (T[]) new Object[10];
17. In this chapter, it was mentioned that a non-generic class can have a generic subclass. Is the opposite also true? That is, can a generic class have a non-generic subclass?

Java programming 545
18. In this chapter, it was mentioned that a non-generic class can have a
generic method. Is the opposite also true? That is, can a generic class have a non-generic method?
19. Is it legal to create a generic class with type parameter T and then never use T in the class implementation? For example, is the following class definition legal?
class MyClass {
MyClass() { }
void printName() { System.out.println(“MyClass”); }
}
20. In Try This 14-1, you saw how to create a simple generic stack class. You may be interested to know that the Java library already includes a full-featured stack class called Stack, which is in the java.util package. In the pre-generics versions of Java, that Stack class stored any kind of object. Its push( ) method used Object as the type of its parameter and its pop( ) method’s return type was Object. To use such a stack to store strings, you had to do typecasting. For example, after pushing a string, you could retrieve it as a string only with statements of the form
String value = (String) stack.pop();
What are the disadvantages of doing it this way? That is, why is the generic
Stack better?
21. If Obj is a generic class that has a no-argument constructor, what are the
differences, if any, between the following four statements?
A. Obj x = new Obj