chapter 15: generic methods, classes, and array-based lists java programming: program design...
TRANSCRIPT
Chapter 15: Generic Methods, Chapter 15: Generic Methods, Classes, and Array-Based ListsClasses, and Array-Based Lists
Java Programming: Java Programming: Program Design Including Data Program Design Including Data StructuresStructures
Java Programming: Program Design Including Data Structures 2
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 3
The interface cloneable
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
To make a deep copy of an object’s data, its class must override the clone method
Java Programming: Program Design Including Data Structures 4
The interface cloneable (continued)
The interface Cloneable has no method headings that need to be implemented 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
Java Programming: Program Design Including Data Structures 5
The interface cloneable (continued)
Writing the clone method First, invoke the clone method of the super class 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 6
The interface cloneable (continued)
Example of a clone methodpublic 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 7
The interface cloneable (continued)
clone method for variables of mutable typespublic 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 8
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 Values of two objects of that class can be properly
compared Example
public class Clock implements Comparable
Java Programming: Program Design Including Data Structures 9
The interface Comparable (continued)
Writing the compareTo method for Clockpublic 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 10
The interface Comparable (continued)
Writing the equals method for Clockpublic boolean equals(Object otherClock){ Clock temp = (Clock) otherClock; return (hr == temp.hr && min == temp.min && sec == temp.sec);}
Java Programming: Program Design Including Data Structures 11
The interface Comparable (continued)
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 12
The interface Comparable (continued)
Writing the compareTo method for Personpublic 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 13
The interface Comparable (continued)
Writing the compareTo method for Datepublic 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 14
The interface Comparable (continued)
Writing the compareTo method for PersonalInfopublic 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 15
Generic Methods Consider the following three methods:public static void print(int ... list)
{
for (int elem : list)
System.out.print(elem + " ");
System.out.println();
}
Java Programming: Program Design Including Data Structures 16
Generic Methods (continued)
public static void print(double ... list){ for (double elem : list) System.out.print(elem + " "); System.out.println();}
public static void print(String ... list){ for (String elem : list) System.out.print(elem + " "); System.out.println();}
Java Programming: Program Design Including Data Structures 17
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 18
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 19
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 20
Generic Methods (continued) Generic definition of the method printpublic static <T> void print(T ... list) //Line 1
{
for (T elem : list) //Line 2
System.out.print(elem + " "); //Line 3
System.out.println(); //Line 4
}
Java Programming: Program Design Including Data Structures 21
Generic Methods (continued) Usage exampleInteger[] 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 22
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 23
Generic Methods and Bounded Type Parameters (continued)
Definition of a generic method largerpublic static <T extends Comparable<T> >
T larger(T x, T y)
{
if (x.compareTo(y) >= 0)
return x;
else
return y;
}
Java Programming: Program Design Including Data Structures 24
Generic Methods and Bounded Type Parameters (continued)
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 25
Generic Classes
You can also define generic classes 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 26
Array-Based Lists
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 27
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 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 28
Array-Based Lists (continued)
Figure 15-1 UML class diagram of the interface ArrayListADT
Java Programming: Program Design Including Data Structures 29
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 30
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 31
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
We do not want to instantiate objects of this class The class is declared abstract
Java Programming: Program Design Including Data Structures 32
The class ArrayListClass (continued)
Figure 15-2 UML class diagram of the class ArrayListClass
Java Programming: Program Design Including Data Structures 33
The class ArrayListClass (continued)
Definition of this classpublic abstract class ArrayListClass<T> implements ArrayListADT<T>, Cloneable{ 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 34
The class ArrayListClass (continued)
Constructorpublic 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 35
The class ArrayListClass (continued)
Method removeAtpublic 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 36
The class ArrayListClass (continued)
Method retrieveAtpublic 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 37
Unordered Lists
Figure 15-4 UML class diagram of the class UnorderedArrayList and the inheritance hierarchy
Java Programming: Program Design Including Data Structures 38
Unordered Lists (continued)
Definition of this classpublic class UnorderedArrayList<T> extends
ArrayListClass<T>
{
//Place the definitions of the methods and the
//constructors here.
}
Java Programming: Program Design Including Data Structures 39
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 40
Unordered Lists (continued)
Method insertAtpublic 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 down
list[location] = insertItem;
length++; //increment the length
}
} //end insertAt
Java Programming: Program Design Including Data Structures 41
Unordered Lists (continued)
Method seqSearchpublic 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 42
Unordered Lists (continued)
Method removepublic 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 43
Ordered List
Figure 15-4 UML class diagram of the class OrderedArrayList and the inheritance hierarchy
Java Programming: Program Design Including Data Structures 44
Ordered List (continued)
Class definitionpublic class OrderedArrayList <T> extends
ArrayListClass<T>
{
// Place constructor and method definitions
// here.
}
Java Programming: Program Design Including Data Structures 45
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 46
Ordered List (continued)
Method seqSearchpublic 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;
}
}
Java Programming: Program Design Including Data Structures 47
Ordered List (continued)
Method seqSearch (continued) if (found)
{
if (list[loc].equals(searchItem))
return loc;
else
return -1;
}
else
return -1;
} //end seqSearch
Java Programming: Program Design Including Data Structures 48
Ordered List (continued)
Method insertpublic 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 49
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 50
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 51
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 52
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