Chapter 21 Template Method

1. Chapter 21Template Method Summary prepared by Kirk Scott

2. One half of a bronze mold for casting a socketed spear head dated to the period 1400-1000 BC. There are no known parallels for this mold.

3. Stone mold of the Bronze Age used to produce spear tips

4. Design Patterns in JavaChapter 21Template Method Summary prepared by Kirk Scott

5. The Introduction Before the Introduction • In this unit I will only cover the first example given by the book, sorting, taken from the Java API • The book ends that discussion with an example with rockets, which will be covered

6. Next, the book develops some examples using rockets which apply the template pattern to an operation other than sorting • Those examples will not be covered • You will only be responsible for the template design pattern as illustrated by sorting

7. The Template design pattern, at heart, is not very complicated • The idea can be summarized as follows: • You write the code for the outline of an algorithm, leaving certain steps of the algorithm as calls to other methods

8. If the overall algorithm is complex, this is a divide and conquer approach to code writing • Whether the algorithm is complex or not, the pattern has another potential benefit which is actually more important • The overall algorithm may be designed generally so that it can apply to multiple kinds of objects

9. The changes needed for specific kinds of objects can be implemented in the subparts • The subparts could also be altered so that they accomplish something different, or in a different way, without changing the overall outline of the algorithm

10. Book Definition of Pattern • Book definition: • The intent of the Template Method is to implement an algorithm in a method, deferring the definition of some steps of the algorithm so that other classes can redefine them.

11. A Classic Example: Sorting • Sorting provides a good example where the template method can be applied • There are many different sorting algorithms • These would be templates • Each algorithm depends on the ability to do pairwise comparisons • How the pairwise comparison is done is the subpart of the implementation of the algorithm overall

12. Multiple Templates • Here is one perspective on the design pattern • You might have multiple templates • You could implement a template for quick sort, for example • You could also implement a template for merge sort • Each template could rely on the same method that supported the pairwise comparison of the values or objects to be sorted

13. Multiple Subparts • Here is another perspective on the design pattern • Given one template, you might also be interested in varying implementations of the subpart • For example, assume for a moment that you are just interested in merge sort

14. You might be interested in applying the sorting template to different kinds of objects • Or you might be interested in applying it to the same kinds of objects, but sorting them on different attributes at different times • This means having various different implementations of the subpart, the pairwise comparison operation that the template depends on

15. Sorting in the Java API • The book doesn’t actually explain sorting in the Java API in great detail • It shows an example and moves on • I will try and explain it in detail • It is this information that you are responsible for

16. There are two parallel tracks to sorting in Java • The first of the two tracks is based on what the API refers to as “natural order” • In essence the second track is an extension that makes it possible to compare objects on some order other than the so-called natural order

17. For each of the two tracks, pairwise comparison of objects will be addressed first • Then using the comparison in a template method will be addressed

18. Natural Order • The phrase “natural order” sounds god-given • This is not the case • Natural order means the order that is defined by a class that implements the Comparable interface • The Comparable interface contains a compareTo() method • This is known as the natural comparison method

19. The compareTo() method has this signature • compareTo(obj:Object):int • Given an implicit and an explicit parameter that are objects, it will compare the two • It will return an integer value as the result of the comparison

20. In a class that implements the Comparable interface, the compareTo() method contains the logic for comparison • In general, the comparison is based on the value of the most important instance variable of the class

21. compareTo()’s Return Values • If the return value is -1, the implicit parameter is less than the explicit parameter • If the return value is 0, the implicit parameter is equal to the explicit parameter • If the return value is 1, the implicit parameter is greater than the explicit parameter

22. The Arrays and Collections Classes • The Java API contains classes named Arrays and Collections • These classes contain sorting methods that make use of calls to compareTo() • A little bit of background on the classes will be presented before getting to sorting

23. Do not to confuse the Arrays and Collections classes with the class Array or the interface Collection • It is a little inconvenient that there are classes Array, Arrays, and Collections, and an interface Collection

24. Recall that the Array class is a concrete class • Instances of that class are arrays • Collection is an interface • This interface is at the root of the a hierarchy of classes that implement it, like ArrayList, HashMap, etc.

25. The Arrays and Collections Classes Contain Static Methods • So what are the classes Arrays and Collections? • They are classes that contain many static methods that can be used to work on instances of arrays or collections • We will be interested in just those methods that sort the contents of an array or collection based on pairwise comparison of the elements

26. This is the first paragraph of the Java API for the Arrays class: • “This class contains various methods for manipulating arrays (such as sorting and searching). • This class also contains a static factory that allows arrays to be viewed as lists.” • (I only see static methods in the class.)

27. This is the first paragraph of the Java API for the Collections class: • “This class consists exclusively of static methods that operate on or return collections. • It contains polymorphic algorithms that operate on collections, "wrappers", which return a new collection backed by a specified collection, and a few other odds and ends.”

28. This is a simple analogy: • The Math class contains static methods for performing mathematical operations on simple types • The Arrays and Collections classes contain static methods for performing operations on instances of Array or Collection classes

29. The sort() Methods in the Arrays Class • The Arrays class has 18 different sort methods in it • The methods sort an array that is passed in as a parameter • Most of these methods differ according to the type of element in the array that is sorted • For simple types, the sort order is simply based on numeric comparison

30. Arrays with Numeric Elements • There is a version of sort() which takes an array of integers as the explicit parameter • The pairwise comparison that it’s based on is the numerical < operator • For what it’s worth, this version of sort() implements a version of quick sort

31. Sorting Arrays with Elements that are References • How will an array be sorted if it contains references to objects? • Remember that you typically declare the type of the object in the array • You can count on each of an array’s elements being an instance of the same class • The sort() method in Arrays will sort the elements in “natural” order

32. Natural Order Sorting is Based on Implementing the Comparable Interface • Here is part of the Java API documentation for the sort() method for objects in the Arrays class: • “public static void sort(Object[] a) • Sorts the specified array of objects into ascending order, according to the natural ordering of its elements. • All elements in the array must implement the Comparable interface.”

33. The sort() method will successfully work on an array if the elements of the array are of a class that implements the Comparable interface • The results of the sort will depend on the pairwise comparison of the array’s elements using the compareTo() method specified by Comparable and implemented in the class • For what it’s worth, this version of sort() implements a version of merge sort

34. Flexibility of the Template Pattern—Re-using the Comparison Operation • Notice how sorting in Java illustrates one aspect of the template pattern • You can have more than one sorting template, one for quick sort and the other for merge sort, for example • They both can make use of the same pairwise comparison operation

35. The sort() Methods in the Collections Class • Sorting with the Collections class is similar to the Arrays class, but simpler • Collections does not contain a large number of sort() methods because a collection can only contain object references, not simple types

36. The Collections class has two sort() methods • The first sort() method is analogous to the sort() method for the Arrays class • It will be discussed next • The second sort() method is based on something call a Comparator • That will be discussed after finishing with the first sort() method

37. Natural Order Sorting in the Collections Class • Here is part of the Java API documentation for the first sort() method in the Collections class: • “public static <T extends Comparable<? super T>> void sort(List<T> list)” • Sorts the specified list into ascending order, according to the natural ordering of its elements. • All elements in the list must implement the Comparable interface.”

38. Differences between Sorting in Arrays and Collections • The signature of the first sort() method in the Collections class differs from the signature of the sort() method in the Arrays class • An Array contains elements of one kind • It is possible for a collection to contain references to different kinds of objects

39. For a collection, angle bracket notation is used to specify a single object type that a collection contains • The angle bracket notation shown is more complex than any we’ve seen before • You don’t have to master this syntax in order to make use of the method • All it apparently means is that the elements of the collection either have to be comparable themselves or be subclasses of classes that are comparable

40. Similarities between Sorting in Arrays and Collections • Aside from those two differences, the sort() methods in Arrays and Collections discussed so far are similar • They both rely on the natural order defined on the objects by their implementation of the Comparable interface • The sort order results from the pairwise application of compareTo() to the elements of the collection

41. Kinds of Objects in Collections • The elements of a collection may literally be instances of different classes • Things will work if the objects are instances of subclasses of the type declared for the collection and that type implements Comparable • The collection will contain superclass references to subclass objects • Polymorphism and dynamic binding mean that comparison will be done on the basis of the comparability of the common superclass

42. Flexibility of the Template Pattern—Changing the Comparison Operation • The discussion of Java sorting so far has been based on natural order as defined by implementing the Comparable interface • The other aspect of the template pattern is the ability to change the pairwise comparison to sort different kinds of objects or in a different order • How that is accomplished in Java sorting will be addressed next

43. Sorting in a Different Order with a Different Comparison Operation • Suppose you want to sort objects which are of the same kind, but you want to define a new sort order • The Comparator interface in the Java API is the basis for this • There are sort() methods in the Arrays and Collections classes which are defined to work on parameters which implement this interface

44. The Comparator Interface for “Non-Natural Order” Sorting • Let a class implement the Comparator interface • This means that it implements a method named compare() with this signature • compare(o1:Object, o2:Object):int • Given two explicit parameters that are objects, it will compare the two • It will return an integer value as the result of the comparison

45. compare() isn’t declared static in the interface definition, but in a practical sense it is • It takes two instances of a class as explicit parameters and compares them with each other • Just like with compareTo(), we don’t call the method ourselves • A sorting method that uses Comparator will call the compare() method

46. compare()’s Return Values • The meaning of the integer return value of compare() is like that of compareTo(), • If the return value is -1, the first explicit parameter is less than the second explicit parameter • If the return value is 0, the first explicit parameter is equal to the second explicit parameter • If the return value is 1, the first explicit parameter is greater than the second explicit parameter

47. Using Comparator/compare() in Arrays and Collections • The Arrays and Collections classes both contain sort() methods based on Comparator • The methods take two parameters: • An array or collection of elements to be sorted • An instance of a class that implements the Comparator interface for the elements of the array or collection

48. Notice that this is one step deeper than plain Comparable • With Comparable, the element class itself implemented the interface and contained compareTo(), which defined its natural order • A Comparator is external to the element class • In theory, you could have many different comparators for the same element class

49. The sort() Method with a Comparator Parameter in the Arrays Class • Here is part of the Java API documentation for the sort() method with a Comparator parameter in the Arrays class: • public static <T> void sort(T[] a, Comparator<? super T> c) • Sorts the specified array of objects according to the order induced by the specified comparator.

50. The sort() Method with a Comparator Parameter in the Collections Class • Here is part of the Java API documentation for the sort() method with a Comparator parameter in the Collections class: • public static <T> void sort(List<T> list, Comparator<? super T> c) • Sorts the specified list according to the order induced by the specified comparator.