int/double, str (alphabetical)

Week 6: Methods of OO Programming/07A. Interface 'Comparable' [compareTo method]+++

@@ -0,0 +1,192 @@
+Interface Comparable
+When an object implements the INTERFACE 'Comparable', it can be compared to OTHER OBJECTS (USU instances of the SAME CLASS). 
+The METHOD defined in the interface is called 'compareTo', and is utilized for example by the sorting methods in Java. 
+
+This means that if your class implements the interface, 
+=> LATER WHEN U CREATE a 'LIST containing OBJECTS created FROM THAT CLASS' 
+=> THE LIST OF OBJECTS can be ordered by using the 'sort' method from class 'Collections'.
+
+
+
+Method 'compareTo' RETURNS an INTEGER by the following rules:
+- the method returns a 0, if the values are equal
+- the method returns a NEGATIVE value if the current (this) object is "SMALLER" than the other object
+- the method returns a POSITIVE value if the current (this) object is "LARGER" than the other object
+
+
+
+ 
+
+======================================================
+
+
+Note that the programmer must decide on how the actual comparison is made. 
+For example, the order of two Student objects could be determined based on the 
+- student id,
+- number of credits, or for example
+- name (in alphabetical order).
+Hence, it is important to think what is the correct method in the current situation.
+
+The interface uses GENERICS. 
+This is discussed in detail in the last week of the course. 
+Here, it means that the class defines the types of objects used in the comparison.
+In practice, it is almost always the same as the class itself: students are compared to other students, cars to other cars, and files to other files.
+
+Let's consider a class 'Student' which implements the 'Comparable' interface. 
+The property used for comparison is the 'number of credits'.
+
+// Generic type definition for implementing the interface
+class Student implements Comparable<Student> { 
+    private String studentId;
+    private String name;
+    private int credits;
+
+    // CONSTRUCTOR
+    public Student(String studentId, String name, int credits) {
+        this.studentId = studentId;
+        this.name = name;
+        this.credits = credits;
+    }
+
+    @Override
+    public String toString() {
+        return name + " (" + studentId + "), " + credits + " op.";
+    }
+
+    @Override
+    public int compareTo(Student o) {
+        if (this.credits == o.credits) {
+            return 0;
+        } 
+        else if (this.credits < o.credits) {
+            return -1;
+        } 
+        else {
+            return 1;
+        }
+    } 
+}
+
+
+
+
+For clarity, above, there was an entire conditional statement written in the method 'compareTo', 
+but naturally, we could get the same result with a single expression:
+
+return this.credits - o.credits
+
+
+
+ 
+
+======================================================
+
+
+
+
+Now, we can SORT a list of student objects into natural order based on their credits:
+
+import java.util.ArrayList;
+import java.util.Collections;
+
+public class SortTest {
+    public static void main(String[] args) {
+        // CREATE OBJECTS
+        Student o1 = new Student("1234", "Oscar", 15);
+        Student o2 = new Student("4321", "Olive", 25);
+        Student o3 = new Student("3333", "Paul", 7);
+        Student o4 = new Student("9999", "Pauline", 19);
+
+        // CREATE A LIST OF OBJECTS
+        ArrayList<Student> students = new ArrayList<>();
+        students.add(o1);
+        students.add(o2);
+        students.add(o3);
+        students.add(o4);
+
+        // SORT HERE
+        Collections.sort(students);
+        
+        for (Student o : students) {
+            System.out.println(o);
+        }
+    }
+}
+
+Program output:
+Paul (3333), 7 op.
+Oscar (1234), 15 op.
+Pauline (9999), 19 op.
+Olive (4321), 25 op.
+ 
+
+
+====================================================================
+
+
+
+
+
+As another example, let's consider the class Car. 
+
+In the example, the cars are sorted based on their 'make'. 
+Note that we can "use the String class implementation of the Comparable class's " compareTo in our own class.
+
+class Car implements Comparable<Car> {
+    private String make;
+    private String model;
+    
+    public Car(String make, String model) {
+        this.make = make;
+        this.model = model;
+    }
+
+    @Override
+    public String toString() {
+        return make + " " + model;
+    }
+
+    // DEFAULT 'compareTo' COMPARES STRINGS IN ALPHABETICAL ORDER
+    @Override
+    public int compareTo(Car o) {
+        return this.make.compareTo(o.make);
+    }  
+}
+ 
+
+
+
+
+
+
+Example of sorting an array of car objects:
+
+import java.util.Arrays;
+
+public class Example {
+    public static void main(String[] args) {
+        // CREATE OBJECTS
+        Car a1 = new Car("Volvo", "440");
+        Car a2 = new Car("Porsche", "911");
+        Car a3 = new Car("Datsun", "100a");
+        Car a4 = new Car("Citroen", "C5");
+
+        // CREATE ARRAY OF OBJECTS
+        Car[] cars = {a1, a2, a3, a4};
+        // SORT ARRAY
+        Arrays.sort(cars);
+        
+        for (Car car : cars) {
+            System.out.println(car);
+        }
+    }
+}
+
+Program output:
+Citroen C5
+Datsun 100a
+Porsche 911
+Volvo 440
+
+
+