CS2210: SW Development Methods

1. CS2210: SW Development Methods • Topics: • Comparable and Comparator interfaces in JCF • Function objects • Textbook readings: • More from MSD, Chapter 9 • Pages 641-647 • Pages 650-651 up to 9.4.1;Pages 666-671. Comparators

2. Back to Java: Comparable and Comparator • In computing, we often want to order a set of items • Find the max/best or min/worst • Sort them in order • Note how this is different than what is needed for search (where we just need equals) • Need a way to compare two items • Want to flexible way to “compare” using different criteria • In Java, let’s us use Collection(s) methods to meet our own special needs. (Powerful!)

3. Check out the Collections class • Class Collections • utility methods for doing operations on Collections, Lists (that almost always contain homogenous elements) • Note very similar Arraysclass • See MSD textbook, Section 9.5, pp. 666f • Methods (static, mostly for Lists) • search a list for an item: binarySearch() • sort(), max(), min() -- uses compareTo() or Comparator object • reverse(), fill(), shuffle(), copy(), replaceAll() • List list2 = Collections.unmodifiableList(list1); // p. 668

4. Comparable Interface • First solution: Can we ask an object how it compares to a second object? • Sure: string1.compareTo(string2) • Programming convention: Return value as follows: • zero if the same • negative value if first item strictly less than second • positive value if first item strictly greater than second • Java provides a Comparable interface int compareTo(YourClass o) • Note the parameter is an object of the same type as the class in which you’re defining compareTo()

5. Hang on: What’s an Interface? • When defining a class, state that it “implements” an interface. E.g. public class Watch implements TimeKeeper { • What does defines the interface TimeKeeper? • A set of methods that any implementing class must include • TimeKeeper interface doesn’t define how these methods are coded • Watch (the implementing class) is promising to include those in its definition

6. Interface gives an Object another Type • With this definition: public class Watch implements TimeKeeper { You can think of Watch in these ways: • You can treat a Watch object as a TimeKeeper • A Watch object can do “TimeKeeper things” • A Watch object can be used anywhere a TimeKeeper is legal to use • A Watch object has more than onetype • It’s a Watch (defined by the class Watch) • It’s a TimeKeeper (defined by the interface)

7. Writing compareTo for Your Classes • If you ever want to put your own objects in Collections, and use sort(), max(), min(),… • Make your class implement Comparable • Implement the compareTo() method in your class • How to write compareTo()? • Think about state-variables that determine natural order • Compare them and return proper-value • Note: For number values, you can subtract. For object values, call compareTo() on them.

8. See Example done in class

9. Example: Writing compareTo() • Imagine something like an entry in a phonebook • Order by last name, first name, then number int compareTo( Object o ) {PhoneBookEntry item2 = (PhoneBookEntry ) o;int retVal= last.compareTo(item2.last);if ( retVal != 0 ) return retVal;retVal = first.compareTo(item2.first);if ( retVal != 0 ) return retVal;retVal = phNum - item2.phNum;return retVal; }

10. Under the Hood for Sorting • How might a sort() or any other method use this? Imagine: • Perhaps items stored as a list of Objects: List theList …; • Inside a loop, code might look like this: Comparable item1 = (Comparable) theList.get(i); Comparable item2 = (Comparable) theList.get(j); int cmpResult = item1.compareTo(item2); • Such code will work when the list stores any class that implements Comparable! • But, what happens if list-elements are of different classes (still Comparable, but different)? compareTo() fails!

11. Flexible Design using Comparators • Solution #1: Make classes Comparable • Disadvantage: just one way to compare is possible, because there’s just one compareTo method per class • Possible solutions: • Separate functions: sortByName(), sortByNum(),… • We can’t predict in advance how you’ll want to sort! • Pass a parameter to indicate control: sort(theList, “byName”) or sort(theList, “byNum”); • Ugh. Same problem as before • And the internals of sort() will grow to become very ugly

12. Function Objects • We need to somehow pass “how to execute” information as a parameter to sort() • We pass objects as parameters • Can we pass a method/operation as an object? • Many languages support this, but in different ways: • C and C++ – pointers to functions • C# – delegates • Java – “function objects” that • implement a specified interface, and • the one method in that interface does the needed work

13. Function Objects in Java • Idea: encapsulate a function inside a class • Note: not our usual idea of a class • State? (None.) • Identity? (Just need one instance.) • Represents an entity? (Nope! Just a place to stash a function so it can be passed as a parameter.) • Warning / caveat! • This idea is contrary to many OO principles, but… • Useful if done in limited circumstances • Use it when the libraries make it available • Not often part of your own class-design • But use it in libraries when it’s part of the framework

14. Example: Comparator objects • We want to pass a function-object to a method: • Collections.sort(someList, function-object-goes-here); • But what type should this object be? • Use an Interface: • Interface name can be used as a type in the parameter list • Interface defines the method name itself! • Java’s Comparator interface: int compare( Object o1, Object o2); • Notes: not compareTo()! Takes two parameters! • Define a class for each kind of comparison you want. E.g. Classes: CmpStudentByGpa, CmpStudentByGpaDesc Classes: CmpDogByName, CmpDogByBreed

15. Writing a Comparator Class • Example on following slides like one from MSD text, p. 646-647 • We have a Dog class with name, breed and gender • But see simpler example in Java on website • list of Student objects • sort by name, gpa • Also sort in descending order too • Look at testSorting1() in TestDriver class • Look at compareTo() in Student • Look at use of comparator classes

16. Writing a Comparator Class • Example like one from MSD text, p. 647 • We have a Dog class with name, breed and gender • Compare two doggies by breed and then namepublic class CmpDogByBreedAndName implementsComparator<Dog> { public int compare(Object o1, Object o2) { Dog d1 = (Dog) o1; Dog d2 = (Dog) o2; int retVal = d1.getBreed().compareTo(d2.getBreed()); if ( retVal != 0 ) return retVal; return d1.getName().compareTo( d2.getName() );} }

17. Use of Comparator methods • How to use with Collections.sort() ArrayList dogList = …; Collections.sort( dogList, new CmpDogByName() );Collections.sort( dogList, new CmpDogByBreed() ); • (Do you understand what new does here?) • Inside sort(), code looks something like this: sort ( List theList, Comparator cmpObj ) { // in some loop Object item1 = list.get(i); Object item2 = list.get(j); cmpResult = cmpObj.compare(item1,item2);

18. End of Comparable/Comparator topics • Make sure you see slides on Abstraction • They relate to this material and what follows

19. Java Aside: Anonymous Classes • There’s a Java technique called anonymous classes • One of several types of nested class definition • You’ll very often see it in GUI programming (Swing) and with threads • Situation: • Sometimes Java’s design encourages us to create some thing that might be used just once • That thing needs to be wrapped up in a class, say because we need a function object • What couldn’t we just declare it at the same place we use it? Why create a separate file?

20. Creating and Using an Anonymous Class • Example: sort a list of Strings by their length Collections.sort ( stringList, new Comparator() {public int compare( Object o1, Object o2 ) { return ((String) o1).length() - ((String) o2).length(); } }) ; • We’ve created a new Comparator “on the fly” • new creates a new instance, but what kind? • Some object that implements Comparator • Object not named, and its “true” class not named! • What must a Comparator have? compare() • We defined it right here, where it’s used!

21. Anonymous Classes: Comments • Anonymous classes are unlike other classes • They have no name • Typically only implement methods in their interface or superclass. No new methods! • Since they have no name, can only define and use them at one point in your code! • Hard to understand at first? Sure! • Naming an abstraction is important for human understanding! • Sorting, a Collection, Comparing • Advice • Keep them very short (and simple)! • Be ready to understand them when you see them in Swing and with threads