1. JAVA Objects & The Comparable Interface The MyComparable Interface. The MyComparable Interface. The AbstractObject class. The AbstractObject class. Wrapper classes. Wrapper classes. The Chr class.The Chr class. The Int class.The Int class. The Dbl class.The Dbl class. The Str class.The Str class. The class Hierarchy. The class Hierarchy. Review Questions. Review Questions.

2. The MyComparable Interface Being able to compare objects is very important in the study of data structures. Being able to compare objects is very important in the study of data structures. Java has a comparable interface but it is very limited - it only has the compareTo method. Java has a comparable interface but it is very limited - it only has the compareTo method. Thus, we introduce our comparable interface as follows; and most of the data structure classes we shall develope in this course will implement this interface. Thus, we introduce our comparable interface as follows; and most of the data structure classes we shall develope in this course will implement this interface. 1 public interface MyComparable { 2 boolean isLT (MyComparable object); 3 boolean isLE (MyComparable object); 4 boolean isGT (MyComparable object); 5 boolean isGE (MyComparable object); 6 boolean isEQ (MyComparable object); 7 boolean isNE (MyComparable object); 8 int compare (MyComparable object); 9 }

3. The AbstractObject class All Java classes are derived from the base class Object. All Java classes are derived from the base class Object. The Object class has the equals method that allows objects to be tested for equality, but we need to be able to do more than just test for equality. The Object class has the equals method that allows objects to be tested for equality, but we need to be able to do more than just test for equality. Thus, we define our own base class that implements our comparable interface. Thus, we define our own base class that implements our comparable interface. 1 public abstract class AbstractObject implements MyComparable 2 { 3 public final boolean isLT (MyComparable object) 4 { return compare (object) < 0; } 5 6 public final boolean isLE (MyComparable object) 7 { return compare (object) <= 0; } 8 9 public final boolean isGT (MyComparable object) 10 { return compare (object) > 0; } 11 public final boolean isEQ (MyComparable object) 12 { return compare (object) == 0; } 13 14 public final boolean isNE (MyComparable object) 15 { return compare (object) != 0; }

4. The AbstractObject class (contd.) 16 17 public final boolean equals (Object object) { 18 if (object instanceof MyComparable) 19 return isEQ ((MyComparable) object); 20 else 21 return false; 22 } 23 24 public final int compare (MyComparable arg) { 25 if (getClass () == arg.getClass ()) 26 return compareTo (arg); 27 else 28 return getClass ().getName ().compareTo ( 29 arg.getClass ().getName ()); 30 } 31 protected abstract int compareTo (MyComparable arg); 32 }

5. Wrapper classes Just as we could not rely on Java's Object class, we also Just as we could not rely on Java's Object class, we also cannot rely on Java's wrapper classes - not MyComparable. cannot rely on Java's wrapper classes - not MyComparable. Moreover, all the wrapper classes were defined as final, thus, we cannot extend them to make them MyComparable. Moreover, all the wrapper classes were defined as final, thus, we cannot extend them to make them MyComparable. Therefore, we have to define our own wrapper classes. Therefore, we have to define our own wrapper classes. 1 public class Chr extends AbstractObject { 2 protected char value; 3 4 public Chr (char value) { 5 this.value = value; 6 } 7 public char charValue () { 8 return value; 9 } 10 protected int compareTo (MyComparable object) { 11 Chr arg = (Chr) object; 12 return (int) value - (int) arg.value; 13 } 14 }

6. Wrapper classes (contd.) 1 public class Int extends AbstractObject { 2 protected int value; 3 4 public Int (int value) { 5 this.value = value; 6 } 7 public int intValue () { 8 return value; 9 } 10 protected int compareTo (MyComparable object) { 11 Int arg = (Int) object; 12 if (value < arg.value) 13 return -1; 14 else if (value > arg.value) 15 return +1; 16 else 17 return 0; 18 } 19 }

7. Wrapper classes (contd.) 1 public class Dbl extends AbstractObject { 2 protected double value; 3 4 public Dbl (double value) { 5 this.value = value; 6 } 7 public double doubleValue () { 8 return value; 9 } 10 protected int compareTo (MyComparable object) { 11 Dbl arg = (Dbl) object; 12 if (value < arg.value) 13 return -1; 14 else if (value > arg.value) 15 return +1; 16 else 17 return 0; 18 } 19 }

8. Wrapper classes (contd.) 1 public class Str extends AbstractObject { 2 protected String value; 3 4 public Str (String value) { 5 this.value = value; 6 } 7 public String stringValue () { 8 return value; 9 } 10 protected int compareTo (MyComparable object) { 11 Str arg = (Str) object; 12 return value.compareTo (arg.value); 13 } 14 } Implementation of the rest of the wrapper classes are left Implementation of the rest of the wrapper classes are left as exercises. as exercises.

9. Summary We have introduced MyComparable interface, the AbstractObject class and our wrapper classes. We have introduced MyComparable interface, the AbstractObject class and our wrapper classes. The class hierarchy so far is as shown in the figure below. The class hierarchy so far is as shown in the figure below. The conventions used in drawing the tree are: rounded rectangle is for interfaces; filled rectangle for abstract classes and unfilled rectangle is used for concrete classes. The conventions used in drawing the tree are: rounded rectangle is for interfaces; filled rectangle for abstract classes and unfilled rectangle is used for concrete classes. Dotted lines are for implements and solid lines for extends. Dotted lines are for implements and solid lines for extends. MyComparableAbstractObject Chr Int Dbl Str

10. Review Questions Suppose we define two concrete classes A and B, both of which are derived from the AbstractObject class. Furthermore, let a and b be instances of classes A and B respectively, declared as follows: 1 public class A extends AbstractObject {... }; 2 public class B extends AbstractObject {... }; 3 Comparable a = new A(); 4 Comparable b = new B();