Download Generic Methods, Classes, and Array

Chapter 15: Generic Methods, Classes,
and Array-Based Lists
Java Programming:
Program Design Including Data Structures
Chapter Objectives
 Learn about the interfaces Cloneable and
Comparable and how to implement them
 Learn about generic methods and classes
 Learn how to implement generic array-based lists
 Explore how various operations, such as search,
insert, and remove, are implemented on lists
Java Programming: Program Design Including Data Structures
2
The method, clone()
 Method clone of the class Object
 Protected method inherited by every class in Java
 Cannot be invoked by an object outside the definition
of its class
 Provides a bit-by-bit copy of the object’s data in
storage
 Provides a shallow copy of object’s data
 Appropriate definition of the method clone with
deep copy  redefine, override!!!
 To make a deep copy of an object’s data, its class
must override the clone method
Java Programming: Program Design Including Data Structures
3
The interface cloneable
 The interface Cloneable has no method
headings that need to be implemented
 But, classes that implement this interface must only
redefine the clone method
 Shallow copies work only when the cloned objects
contain only primitive type data or data of
immutable objects such as Integer or String
Java Programming: Program Design Including Data Structures
4
The interface cloneable
(continued)
 Writing the clone method
 First, invoke the clone method of the super class
 Note that the clone method returns a reference of
the Object type
 Then, change the values of instance variables of
mutable types
 The method clone of the class Object throws
CloneNotSupportedException
Java Programming: Program Design Including Data Structures
5
clone for the class Clock,
Person, and Date
 Example of a clone method
public Object clone()
{
try
{
return super.clone(); //Invoke the method clone of
//the super class
}
catch (CloneNotSupportedException e)
{
return null;
}
}
Java Programming: Program Design Including Data Structures
6
clone for the class
PersonInfo
 clone method for variables of mutable types in the
class PersonInfo
public Object clone()
{
try
{
PersonalInfo copy = (PersonalInfo) super.clone();
copy.bDay = (Date) bDay.clone();
//explicitly clone
//the object bDay
copy.name = (Person) name.clone(); //explicitly clone
//the object name
return copy;
}
catch (CloneNotSupportedException e)
{
return null;
}
Java
Programming: Program Design Including Data Structures
}
7
The interface Comparable
 The interface Comparable has only one
method heading, which is compareTo
 Used to force a class to provide an appropriate
definition of the method compareTo
 To properly compare values of two objects of that
class
 Example
public class Clock implements Comparable
Java Programming: Program Design Including Data Structures
8
compareTo for Clock class
 Writing the compareTo method for Clock
public int compareTo(Object otherClock)
{
Clock temp = (Clock) otherClock;
int hrDiff = hr - temp.hr;
if (hrDiff != 0)
return hrDiff;
int minDiff = min - temp.min;
if (minDiff != 0)
return minDiff;
return sec - temp.sec;
}
Java Programming: Program Design Including Data Structures
9
equals for Clock class
 Writing the equals method for Clock
 to make it compatible with the method equals of
the class Object
public boolean
{
Clock temp
return (hr
&&
&&
}
equals(Object otherClock)
= (Clock) otherClock;
== temp.hr
min == temp.min
sec == temp.sec);
Java Programming: Program Design Including Data Structures
// type cast
10
Implementing multiple interfaces
 If a class implements multiple interfaces
 Separate all interfaces names using commas
 Example
public class Clock implements Cloneable, Comparable
Java Programming: Program Design Including Data Structures
11
compareTo for Person class
 Writing the compareTo method for Person
public int compareTo(Object otherPerson)
{
Person temp = (Person) otherPerson;
if (firstName.equals(temp.firstName)
&& lastName.equals(temp.lastName))
return 0;
else if ((lastName.compareTo(temp.lastName) < 0) ||
((lastName.equals(temp.lastName) &&
(firstName.compareTo(temp.firstName) < 0))))
return -1;
else
return 1;
}
Java Programming: Program Design Including Data Structures
12
compareTo for Date class
 Writing the compareTo method for Date
public int compareTo(Object otherDate)
{
Date temp = (Date) otherDate;
int yrDiff = dYear - temp.dYear;
if (yrDiff != 0)
return yrDiff;
int monthDiff = dMonth - temp.dMonth;
if (monthDiff != 0)
return monthDiff;
return dDay - temp.dDay;
}
Java Programming: Program Design Including Data Structures
13
compareTo for PersonInfo
class
 Writing the compareTo method for
PersonalInfo
public int compareTo(Object other)
{
PersonalInfo temp = (PersonalInfo) other;
int retValue;
retValue = personID - temp.personID;
if (retValue == 0)
retValue = name.compareTo(temp.name);
if (retValue == 0)
retValue = bDay.compareTo(temp.bDay);
return retValue;
}
Java Programming: Program Design Including Data Structures
14
Generic Methods
Consider the following three print() methods for three lists of int, double, and String
public static void print(int ... list){
for (int elem : list)
System.out.print(elem + " ");
System.out.println();
}
public static void print(double
for (double elem : list)
System.out.print(elem +
System.out.println();
}
public static void print(String
for (String elem : list)
System.out.print(elem +
System.out.println();
}
... list){
" ");
... list){
" ");
Note: foreach loop,
for (datatype identifier : arrayName) {
System.out.println(identifier)
}
Java Programming: Program Design Including Data Structures
15
Generic Methods (continued)
 Definition of the method print is identical in each
case
 We can use Java’s mechanism of generic methods
 Write only one definition rather than three different
definitions
 Generic methods are defined using type parameters
Java Programming: Program Design Including Data Structures
16
Generic Methods (continued)
 Type parameters
 Identifiers that specify generic type names
 Separated by commas and enclosed in angular
brackets, < and >
 Also known as type variables
 Used to
 Declare the return type of the method
 Declare formal parameters
 Declare local variables
 Cannot represent primitive types
Java Programming: Program Design Including Data Structures
17
Generic Methods (continued)
 A skeleton form of a generic method is
 T is referred to as the type parameter
 You can declare a reference variable using the type
parameter T
 You cannot instantiate objects using the type
parameter
Java Programming: Program Design Including Data Structures
18
Generic Methods (continued)
 Generic definition of the method print
public static <T> void print(T ... list)
{
for (T elem : list)
System.out.print(elem + " ");
System.out.println();
}
Java Programming: Program Design Including Data Structures
//Line 1
//Line 2
//Line 3
//Line 4
19
Generic Methods (continued)
 Usage example
Integer[] intList = {2, 3, 32, 56};
Double[] numList = {14.56, 32.78, 11.98};
String[] strList = {"Java", "C++", "Basic", "Perl"};
print(intList);
print(numList);
print(strList);
Java Programming: Program Design Including Data Structures
20
Generic Methods and Bounded
Type Parameters
 There are situations when the type parameter T must
be restricted
 An example: generic method larger
 Finds the larger value of two objects
 Method works with built-in as well as user-defined
classes
 Objects are compared using compareTo
 Method should work only with classes that provide a
definition of this method
Java Programming: Program Design Including Data Structures
21
Generic Methods and Bounded
Type Parameters (continued)
 Definition of a generic method larger
Upper bound of the
type parameter T
public static <T extends Comparable<T> >
T larger(T x, T y)
{
if (x.compareTo(y) >= 0)
return x;
else
return y;
}
Note: T represents a generic type. x and y and return types of the method
larger are the type T.
Java Programming: Program Design Including Data Structures
22
Generic Methods and Bounded
Type Parameters (continued)
 Previously, we want the method larger to use the
method compareTo.
 When a type parameter declaration bounds a
parameter
 Always use the keyword extends regardless of
whether the type parameter extends a class or an
interface
 If a type parameter is bounded by more than one
class (or interface), Class names are separated using
the symbol &
Java Programming: Program Design Including Data Structures
23
Generic Classes
 You can also define generic classes
 The type parameter(s) are enclosed in angular brackets
(< and >) and may be bounded or unbounded.
 A typical form of a generic class is
 Generic classes are used to write a single definition for
a set of related classes
 Also known as parametric classes
Java Programming: Program Design Including Data Structures
24
Array-Based Lists
 Definition of a list:
 A list is a collection of elements of the same type
 The length of a list is the number of elements in the
list
 Example
 Hardware store list of items
 Available items
 Number of pieces in stock
 Price
Java Programming: Program Design Including Data Structures
25
Array-Based Lists (continued)
 Common operations performed on a list










Create the list
Determine whether the list is empty or full
Find the size of the list
Destroy, or clear, the list
Determine whether an item is the same as a given list
element
Insert an item at the specified location
Remove an item at the specified location
Replace an item at the specified location
Retrieve an item at the specified location
Search the list for a given item
Java Programming: Program Design Including Data Structures
26
Array-Based Lists (continued)
Figure 15-1 UML class diagram of the interface ArrayListADT
Java Programming: Program Design Including Data Structures
27
Array-Based Lists (continued)
 The list can be sorted or unsorted
 However, the algorithms to implement certain
operations are the same
 An effective, convenient, and common way to
process a list is to store it in an array
 Initially the size of the array is larger than the size of
the list
 At a larger stage, the list can grow to a larger size
 We must know how full the array is
Java Programming: Program Design Including Data Structures
28
Array-Based Lists (continued)
 Variables needed to maintain and process the list in
an array
 The array, list, holding the list elements
 A variable, length, to store the length of the list
 A variable, maxSize, to store the size of the array
Java Programming: Program Design Including Data Structures
29
The class ArrayListClass
 Implements the operations that are common for
sorted and unsorted lists
 It does not implement all the operations of the
interface ArrayListADT. Why?
 Consider a search method for sorted and unsorted lists
 Still, the class is declared abstract
 We do not want to instantiate objects of this class
Java Programming: Program Design Including Data Structures
30
The class ArrayListClass
(continued)
abstract
class
protected
instance
variables
abstract
methods
Note:
abstract
class and
abstract
methods are
shown in
italics.
Figure 15-2 UML class diagram of the class ArrayListClass
Java Programming: Program Design Including Data Structures
31
The class ArrayListClass
(continued)
protected
instance
variables
 Definition of this class
public abstract class ArrayListClass<T> implements
protected
ArrayListADT<T>, Cloneable
instance
{
variables
protected int length; //to store the length of the list
protected int maxSize; //to store the maximum size of the
//list
protected T[] list;
//array to hold the list elements
//Place the definitions of the instance methods and
//abstract methods here
}
Java Programming: Program Design Including Data Structures
32
The class ArrayListClass
(continued)
 Constructor
public ArrayListClass(int size)
{
if (size <= 0)
{
System.err.println("The array size must be positive. "
+ "Creating an array of size 100. ");
maxSize = 100;
}
else
maxSize = size;
length = 0;
list = (T[]) new Object[maxSize];
}
Java Programming: Program Design Including Data Structures
33
The class ArrayListClass
(continued)
 Method removeAt
public void removeAt(int location)
{
if (location < 0 || location >= length)
System.err.println("The location of the item to "
+ "be removed is out of range.");
else
{
for (int i = location; i < length - 1; i++)
list[i] = list[i + 1];
list[length - 1] = null;
length--;
}
} //end removeAt
Java Programming: Program Design Including Data Structures
34
The class ArrayListClass
(continued)
 Method retrieveAt
public T retrieveAt(int location)
{
if (location < 0 || location >= length)
{
System.err.println("The location of the item to be "
+ "retrieved is out of range.");
return null;
}
else
return list[location];
} //end retrieveAt
Java Programming: Program Design Including Data Structures
35
Unordered Lists
Figure 15-4 UML class diagram of the class UnorderedArrayList and the
inheritance hierarchy
Java Programming: Program Design Including Data Structures
36
Unordered Lists (continued)
 Definition of this class
public class UnorderedArrayList<T> extends
ArrayListClass<T>
{
//Place the definitions of the methods and the
//constructors here.
}
Java Programming: Program Design Including Data Structures
37
Unordered Lists (continued)
 Constructors
//Default constructor
public UnorderedArrayList()
{
super();
}
//Constructor with a parameter
public UnorderedArrayList(int size)
{
super(size);
}
Java Programming: Program Design Including Data Structures
38
Unordered Lists (continued)
 Method insertAt
public void insertAt(int location, T insertItem)
{
if (location < 0 || location >= maxSize)
System.err.println("The position of the item to "
+ "be inserted is out of range.");
else if (length >= maxSize) //list is full
System.err.println("Cannot insert in a full list.");
else
{
for (int i = length; i > location; i--)
list[i] = list[i - 1]; //move the elements
list[location] = insertItem;
length++;
//increment the length
}
} //end insertAt
Java Programming: Program Design Including Data Structures
39
Unordered Lists (continued)
 Method seqSearch
public int seqSearch(T searchItem)
{
int loc;
boolean found = false;
for (loc = 0; loc < length; loc++)
if (list[loc].equals(searchItem))
{
found = true;
break;
}
if (found)
return loc;
else
return -1;
} //end seqSearch
Java Programming: Program Design Including Data Structures
40
Unordered Lists (continued)
 Method remove
public void remove(T removeItem)
{
int loc;
if (length == 0)
System.err.println("Cannot delete from an " + "empty list.");
else
{
loc = seqSearch(removeItem);
if (loc != -1)
removeAt(loc);
else
System.out.println("The item to be deleted "
+ "is not in the list.");
}
} //end remove
Java Programming: Program Design Including Data Structures
41
Ordered List
Figure 15-4 UML class diagram of the class OrderedArrayList and the
inheritance hierarchy
Java Programming: Program Design Including Data Structures
42
Ordered List (continued)
 Class definition
public class OrderedArrayList <T> extends
ArrayListClass<T>
{
// Place constructor and method definitions
// here.
}
Java Programming: Program Design Including Data Structures
43
Ordered List (continued)
 Constructors
//Default constructor
public OrderedArrayList()
{
super();
}
//Constructor with a parameter
public OrderedArrayList(int size)
{
super(size);
}
Java Programming: Program Design Including Data Structures
44
Ordered List (continued)
 Method seqSearch
public int seqSearch(T searchItem) {
int loc;
boolean found = false;
for (loc = 0; loc < length; loc++) {
Comparable<T> temp = (Comparable<T>) list[loc];
if (temp.compareTo(searchItem) >= 0) {
found = true;
break;
}
}
if (found) {
if (list[loc].equals(searchItem))
return loc;
else
return -1;
}
else
return -1;
} //end seqSearch
Note: Since class Object
does not contain the method
compareTo() 
create a reference of the type
Comparable<T> and use
the compareTo() method.
Java Programming: Program Design Including Data Structures
45
Ordered List (continued)
 Method insert
public void insert(T insertItem)
{
int loc;
boolean found = false;
if (length == 0)
//list is empty
list[length++] = insertItem; //insert insertItem
//and increment length
else if (length == maxSize)
System.err.println("Cannot insert in a full list.");
Java Programming: Program Design Including Data Structures
46
Ordered List (continued)
 Method insert (continued)
else
{
for (loc = 0; loc < length; loc++)
{
Comparable<T> temp = (Comparable<T>) list[loc];
if (temp.compareTo(insertItem) >= 0)
{
found = true;
break;
}
}
for (int i = length; i > loc; i--)
list[i] = list[i - 1]; //move the elements down
list[loc] = insertItem; //insert insertItem
length++;
//increment the length
}
} //end insert
Java Programming: Program Design Including Data Structures
47
Programming Example:
Polynomial Operations
 Write a class that implements the following basic
operations performed on polynomials





Evaluating a polynomial
Adding polynomials
Subtracting polynomials
Multiplying polynomials
Dividing polynomials
Java Programming: Program Design Including Data Structures
48
Chapter Summary
 Cloneable interface
 clone method makes a bit-by-bit copy of the object
 Classes can override this method to provide a deep
copy
 Comparable interface
 Used to force classes to implement the compareTo
method
 Objects can be properly compared using the
compareTo method
Java Programming: Program Design Including Data Structures
49
Chapter Summary (continued)
 Generic methods
 Created using type parameters
 Allow use of restricted type parameters
 Generic classes
 Array-based lists
 Lists are collection of elements of the same type
 Arrays provide a convenient way to implement lists
 Lists can be either unsorted or sorted
Java Programming: Program Design Including Data Structures
50