6 Generic Classes and Methods

Java How to Program, 10/e
Late Objects Version
© Copyright 1992-2015 by Pearson Education, Inc. All Rights

Reserved.
 The content is mainly selected (sometimes modified)
from the original slides provided by the authors of the
textbook
 Readings
 Chapter 20: Generic Classes and Methods
©1992-2015 by Pearson Education, Inc.

All Rights Reserved.
20.2 Motivation for Generic Methods
20.3 Generic Methods: Implementation and Compile-Time Translation
20.4 Additional Compile-Time Translation Issues: Methods That Use a
Type Parameter as the Return Type
20.5 Overloading Generic Methods
20.6 Generic Classes
©1992-2015 by Pearson Education, Inc.

All Rights Reserved.
 Overloaded methods are often used to perform similar
operations on different types of data.
 Study each printArray method (Fig. 20.1).
◦ Note that the array element type appears in each method’s

header and for-statement header.
◦ If we were to replace the element types in each method with a
generic name—T by convention—then all three methods
would look like the one in Fig. 20.2.
© Copyright 1992-2015 by Pearson

Education, Inc. All Rights Reserved.
 If the operations performed by several overloaded
methods are identical for each argument type, the
overloaded methods can be more conveniently coded
using a generic method.
 You can write a single generic method declaration that
can be called with arguments of different types.

 Based on the types of the arguments passed to the
generic method, the compiler handles each method call

appropriately.

 All generic method declarations have a type-parameter section (< T >
in this example) delimited by angle brackets that precedes the method’s
return type.
 Each type-parameter section contains one or more type parameters,
separated by commas.
 A type parameter, also known as a type variable, is an identifier that
specifies a generic type name.
 Can be used to declare the return type, parameter types and local
variable types in a generic method, and act as placeholders for the
types of the arguments passed to the generic method (actual type
arguments).
 A generic method’s body is declared like that of any other method.
 Type parameters can represent only reference types—not primitive
types.

 When the compiler translates generic method
printArray into Java bytecodes, it removes the
type-parameter section and replaces the type
parameters with actual types.
 This process is known as erasure.
 By default all generic types are replaced with type
Object.
 So the compiled version of method printArray
appears as shown in Fig. 20.4—there is only one copy
of this code, which is used for all printArray calls
in the example.

 Generic method maximum (Fig. 20.5) determines and
returns the largest of its three arguments of the same
type.
 The relational operator > cannot be used with reference
types, but it’s possible to compare two objects of the
same class if that class implements the generic interface
Comparable<T> (package java.lang).
◦ All the type-wrapper classes (Integer, Character, Long, Double,
etc.) for primitive types implement this interface.
 Generic interfaces enable you to specify, with a single
interface declaration, a set of related types.

 Comparable<T> objects have a compareTo
method.
◦ The method must return 0 if the objects are equal,
◦ a negative integer if object1 is less than object2
◦ or a positive integer if object1 is greater than object2.
 A benefit of implementing interface
Comparable<T> is that Comparable<T> objects
can be used with the sorting and searching methods of
class Collections (package java.util).

 The type-parameter section specifies that T extends
Comparable<T>—only objects of classes that implement
interface Comparable<T> can be used with this method.
 Comparable is known as the type parameter’s upper
bound.
 By default, Object is the upper bound.
 Type-parameter declarations that bound the parameter
always use keyword extends regardless of whether the
type parameter extends a class or implements an interface.
 The Comparable<T> restriction is important, because not
all objects can be compared.

 When the compiler translates generic method
maximum into Java bytecodes, it uses erasure to
replace the type parameters with actual types.
 All type parameters are replaced with the upper bound
of the type parameter, which is specified in the type-
parameter section.
 When the compiler replaces the type-parameter
information with the upper-bound type in the method
declaration, it also inserts explicit cast operations in
front of each method call to ensure that the returned
value is of the type expected by the caller.

 A generic method may be overloaded like any other method.
 A class can provide two or more generic methods that
specify the same method name but different method
parameters.
 A generic method can also be overloaded by nongeneric
methods.
 When the compiler encounters a method call, it searches for
the method declaration that best matches the method name
and the argument types specified in the call—an error
occurs if two or more overloaded methods both could be
considered best matches.

 The concept of a data structure, such as a stack, can be
understood independently of the element type it
manipulates.
 Generic classes provide a means for describing the
concept of a stack (or any other class) in a type-

independent manner.
 These classes are known as parameterized classes or
parameterized types because they accept one or more

type parameters.

24
24

 The code in methods testPushDouble and
testPushInteger from the previous example is
almost identical for pushing values onto a
Stack<Double> or a Stack<Integer>,
 Respectively, and the code in methods
testPopDouble and testPopInteger is almost

identical for popping values from a Stack<Double>
or a Stack<Integer>, respectively.
 This presents another opportunity to use generic
methods.

24
24

 It’s also possible to instantiate generic class Stack
without specifying a type argument, as follows:
 // no type-argument specified
Stack objectStack = new Stack(new Double[5]);
◦ objectStack has a raw type
◦ The compiler implicitly uses type Object throughout the
generic class for each type argument.
◦ The preceding statement creates a Stack that can store
objects of any type.
◦ Important for backward compatibility with prior Java versions.
◦ Raw-type operations are unsafe and could lead to exceptions.

24
24
24

 Figure 20.12 shows the warning messages generated by
the compiler when the file RawTypeTest.java
(Fig. 20.11) is compiled with the
-Xlint:unchecked option, which provides more
information about potentially unsafe operations in code
that uses generics.

 “In generic code, the question mark (?), called the wildcard,
represents an unknown type.”, https://docs.oracle.com/javase/tutorial/java/generics/wildcards.html
 Suppose that you’d like to implement a generic method sum

that totals the numbers in an ArrayList . (Fig. 20.13)
◦ You’d begin by inserting the numbers in the ArrayList .
◦ The numbers would be autoboxed as objects of the type-wrapper classes
—any int value would be autoboxed as an Integer object, and any
double value would be autoboxed as a Double object.
◦ We’d like to be able to total all the numbers in the ArrayList
regardless of their type.
◦ For this reason, we’ll declare the ArrayList with the type argument
Number, which is the superclass of both Integer and Double.
◦ In addition, method sum will receive a parameter of type
ArrayList<Number> and total its elements.

 ArrayList:
◦ Resizable-array
◦ Create an ArrayList of Numbers:

ArrayList<Number> numberList = new ArrayList<>();
◦ Add an element to an ArrayList:

numberList.add(element);
◦ Iterate elements of an ArrayList:

for (Number element: numberList)

 In method sum:
◦ The for statement assigns each Number in the ArrayList
to variable element, then uses Number method
doubleValue to obtain the Number’s underlying primitive
value as a double value.
◦ The result is added to total.
◦ When the loop terminates, the method returns the total.

 Given that method sum can total the elements of an
ArrayList of Numbers, you might expect that the method
would also work for ArrayLists that contain elements of only
one numeric type, such as ArrayList<Integer>.
 Modified class TotalNumbers to create an ArrayList- of
Integers and pass it to method sum.
 When we compile the program, the compiler issues the following
error message:
 sum(java.util.ArrayList<java.lang.Number>) in
TotalNumbersErrors cannot be applied to
(java.util.ArrayList<java.lang.Integer>)
 Although Number is the superclass of Integer, the compiler
doesn’t consider the parameterized type
ArrayList<Number> to be a superclass of
ArrayList<Integer>.

 To create a more flexible version of the sum method that can
total the elements of any ArrayList containing elements of
any subclass of Number we use wildcard-type arguments.
 Wildcards enable you to specify method parameters, return
values, variables or fields, and so on, that act as supertypes or
subtypes of parameterized types.
 In Fig. 20.14, method sum’s parameter is declared in line 50
with the type:
 ArrayList<? extends Number>
 A wildcard-type argument is denoted by a question mark (?),
which by itself represents an “unknown type.”
◦ In this case, the wildcard extends class Number, which means that the
wildcard has an upper bound of Number.
◦ Thus, the unknown-type argument must be either Number or a subclass
of Number.

 Because the wildcard (?) in the method’s header does not specify a
type-parameter name, you cannot use it as a type name throughout the
method’s body (i.e., you cannot replace Number with ? in line 55).
 You could, however, declare method sum as follows:
◦ public static <T extends Number> double
sum( ArrayList< T > list )
◦ allows the method to receive an ArrayList that contains elements of any
Number subclass.
◦ You could then use the type parameter T throughout the method body.
 If the wildcard is specified without an upper bound, then only the
methods of type Object can be invoked on values of the wildcard
type.
 Also, methods that use wildcards in their parameter’s type arguments
cannot be used to add elements to a collection referenced by the
parameter.


6 Generic Classes and Methods

Uploaded by

Copyright:

Available Formats

6 Generic Classes and Methods

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

6 Generic Classes and Methods

Uploaded by

Copyright:

Available Formats

Java How to Program, 10/e

Late Objects Version

© Copyright 1992-2015 by Pearson Education, Inc. All Rights

©1992-2015 by Pearson Education, Inc.

©1992-2015 by Pearson Education, Inc.

◦ Note that the array element type appears in each method’s

© Copyright 1992-2015 by Pearson

can be called with arguments of different types.

generic method, the compiler handles each method call

© Copyright 1992-2015 by Pearson

© Copyright 1992-2015 by Pearson

© Copyright 1992-2015 by Pearson

© Copyright 1992-2015 by Pearson

© Copyright 1992-2015 by Pearson

© Copyright 1992-2015 by Pearson

© Copyright 1992-2015 by Pearson

© Copyright 1992-2015 by Pearson

concept of a stack (or any other class) in a type-

parameterized types because they accept one or more

© Copyright 1992-2015 by Pearson

© Copyright 1992-2015 by Pearson

testPopDouble and testPopInteger is almost

© Copyright 1992-2015 by Pearson

© Copyright 1992-2015 by Pearson

© Copyright 1992-2015 by Pearson

© Copyright 1992-2015 by Pearson

© Copyright 1992-2015 by Pearson

 Suppose that you’d like to implement a generic method sum

© Copyright 1992-2015 by Pearson

◦ Create an ArrayList of Numbers:

◦ Add an element to an ArrayList:

◦ Iterate elements of an ArrayList:

© Copyright 1992-2015 by Pearson

© Copyright 1992-2015 by Pearson

© Copyright 1992-2015 by Pearson

© Copyright 1992-2015 by Pearson

© Copyright 1992-2015 by Pearson

You might also like