10.5 Writing Generic Classes and Methods

classes and methods from scratch. Generic programming produces highly general and reusable code—it’s very useful for people who write reusable software libraries to know how to do generic programming, since it enables them to write code that can be used in many di erent situations. Not every programmer needs to write reusable software libraries, but every programmer should know at least a little about how to do it. In fact, just to read the JavaDoc documentation for

Java’s standard generic classes, you need to know some of the syntax that is introduced in this section.

I will not cover every detail of generic programming in Java in this section, but the material presented here should be su cient to cover the most common cases.

10.5.1Simple Generic Classes

Let’s start with an example that illustrates the motivation for generic programming. In Subsection 10.2.1, I remarked that it would be easy to use a LinkedList to implement a queue. (Queues were introduced in Subsection 9.3.2.) To ensure that the only operations that are performed on the list are the queue operations enqueue, dequeue, and isEmpty, we can create a new class that contains the linked list as a private instance variable. To implement queues of strings, for example, we can define the class:

class QueueOfStrings {

private LinkedList<String> items = new LinkedList<String>(); public void enqueue(String item) {

items.addLast(item);

}

public String dequeue() { return items.removeFirst();

}

public boolean isEmpty() { return (items.size() == 0);

}

}

This is a fine and useful class. But, if this is how we write queue classes, and if we want queues of Integers or Doubles or JButtons or any other type, then we will have to write a di erent class for each type. The code for all of these classes will be almost identical, which seems like a lot of redundant programming. To avoid the redundancy, we can write a generic Queue class that can be used to define queues of any type of object.

The syntax for writing the generic class is straightforward: We replace the specific type String with a type parameter such as T, and we add the type parameter to the name of the class:

class Queue<T> {

private LinkedList<T> items = new LinkedList<T>(); public void enqueue(T item) {

items.addLast(item);

}

public T dequeue() {

return items.removeFirst();

}

public boolean isEmpty() { return (items.size() == 0);

}

}

Note that within the class, the type parameter T is used just like any regular type name. It’s used to declare the return type for dequeue, as the type of the formal parameter item in enqueue, and even as the actual type parameter in LinkedList<T>. Given this class definition, we can use parameterized types such as Queue<String> and Queue<Integer> and Queue<JButton>.

That is, the Queue class is used in exactly the same way as built-in generic classes like LinkedList and HashSet.

Note that you don’t have to use “T” as the name of the type parameter in the definition of the generic class. Type parameters are like formal parameters in subroutines. You can make up any name you like in the definition of the class. The name in the definition will be replaced by an actual type name when the class is used to declare variables or create objects. If you prefer to use a more meaningful name for the type parameter, you might define the Queue class as:

class Queue<ItemType> {

private LinkedList<ItemType> items = new LinkedList<ItemType>(); public void enqueue(ItemType item) {

items.addLast(item);

}

public ItemType dequeue() { return items.removeFirst();

}

public boolean isEmpty() { return (items.size() == 0);

}

}

Changing the name from “T” to “ItemType” has absolutely no e ect on the meaning of the class definition or on the way that Queue is used.

Generic interfaces can be defined in a similar way. It’s also easy to define generic classes and interfaces that have two or more type parameters, as is done with the standard interface Map<T,S>. A typical example is the definition of a “Pair” that contains two objects, possibly of di erent types. A simple version of such a class can be defined as:

class Pair<T,S> { public T first; public S second;

public Pair( T a, S b ) { // Constructor. first = a;

second = b;

}

}

This class can be used to declare variables and create objects such as:

Pair<String,Color> colorName = new Pair<String,Color>("Red", Color.RED); Pair<Double,Double> coordinates = new Pair<Double,Double>(17.3,42.8);

Note that in the definition of the constructor in this class, the name “Pair” does not have type parameters. You might have expected “Pair<T,S>. However, the name of the class is “Pair”, not “Pair<T,S>, and within the definition of the class, “T” and “S” are used as if they are the names of specific, actual types. Note in any case that type parameters are never added to the names of methods or constructors, only to the names of classes and interfaces.

10.5.2Simple Generic Methods

In addition to generic classes, Java also has generic methods. An example is the method Collections.sort(), which can sort collections of objects of any type. To see how to write generic methods, let’s start with a non-generic method for counting the number of times that a given string occurs in an array of strings: