CIS3023: Programming Fundamentals for CIS Majors II Summer 2010 Interfaces (Part II) “A picture is worth a thousand words. An interface is worth a thousand pictures.” -Ben Shneiderman Course Lecture Slides 28 June 2010 Ganesh Viswanathan The Principle of Intimate Engagement: You must commit to the problem “Roll up your sleeves” “Get your hands dirty.” 1

Interface Language construct that specifies functionality without any hint at implementation. An interface contains method specifications but no method implementations.

Comparable Interface // Interface defined in java.lang package public interface Comparable { public int compareTo(Object o); } compareTo( ) Compares this object with the specified object for order. Returns a negative integer, zero or a positive integer when this object is less than, equal to or greater than the specified object. Throws: ClassCastException if the specified object's type prevents it from being compared to this Object.

Declaring Classes to Implement Comparable

public class ComparableRectangle extends Rectangle implements Comparable { public ComparableRectangle(double width, double height){ super(width, height); } // Implement the compareTo method defined in Comparable public int compareTo(Object o) { ComparableRectangle cr = (ComparableRectangle)o; if (getArea() > cr.getArea()) return 1; else if(getArea() < cr.getArea()) return -1; else return 0;

Using Arrays.sort() Arrays.sort(Object[] a) If you have an array of objects of some class C and you want to use Arrays.sort(Object[] a) or Arrays.sort(Object[] a, int fromIndex, int toIndex) to sort this array, you must make class C implement Comparable interface The above sort() methods use the compareTo() method to compare two array elements of reference type

Arrays.Sort() What if you want to sort this array of objects in order of different attributes of class C at different times? Solution: Use Arrays.sort(Object[] a, Comparator c) Or Arrays.sort(Object[] a, int fromIndex, int toIndex, Comparator c)

Comparator Interface public interface Comparator { public int compare(Object o1, Object o2) } Returns: a negative integer, zero, or a positive integer when the first argument is less than, equal to, or greater than the second. Throws: ClassCastException - if the arguments' types prevent them from being compared by this Comparator.

Solution Create a class that implements the Comparator interface Code the compare() method to define the ordering between objects of this class Pass an instance of this class to the Arrays.Sort() method

Another scenario What if you are using a class C which does not implement the Comparable interface You do not have access to C.java file You only have access to the C.class file And you want to sort an arrays of objects of class C in order of some attribute of the class

Solution Create a class that implements the Comparator interface Code the compare() method to define the ordering between objects of this class

Another Advantage of using interfaces as data types public class Max { public static Comparable max(? o1, ? o2) { if (o1.compareTo(o2) > 0) return o1; else return o2; } ComparableRectangle rectangle1 = new ComparableRectangle(4, 5); ComparableRectangle rectangle2 = new ComparableRectangle(3, 6); System.out.println(Max.max(rectangle1, rectangle2));

Another Advantage of using interfaces as data types public class Max { public static Comparable max(Comparable o1, Comparable o2) { if (o1.compareTo(o2) > 0) return o1; else return o2; } ComparableRectangle rectangle1 = new ComparableRectangle(4, 5); ComparableRectangle rectangle2 = new ComparableRectangle(3, 6); System.out.println(Max.max(rectangle1, rectangle2));

Interfaces, cont Max method in (a) is more robust.

Get more info! Tutorial: Comparable vs. Comparator: http://lkamal.blogspot.com/2008/07/java-sorting-comparator-vs-comparable.html Comparable vs. Comparator: http://grdurand.com/static/presentation_four/comparable.html Using comparable: http://onjava.com/pub/a/onjava/2003/03/12/java_comp.html

Use Comparable (implement compareTo( ) method): if you want to compare based on the default natural ordering. if the object is in your control. Use Comparator (implement compare( ) method): if you want comparing behavior different from the expected default (which is specified by Comparable). if the object is outside your control and you cannot make them implement Comparable.

“Object Ordering” Reference: Java Docs http://java.sun.com/docs/books/tutorial/collections/interfaces/order.html See supporting code (TestComparator.java)

Shallow Copy and Deep Copy Using Java’s Cloneable interface Object Duplication Shallow Copy and Deep Copy Using Java’s Cloneable interface

Shallow Copy Bit-wise copy of an object. A new object created with an exact copy of the values in the original object. If any of the fields of the object are references to other objects, only the references are copied. Thus, if the object you are copying contains references to yet other objects, a shallow copy refers to the same sub-objects.

Deep Copy Complete duplicate copy of an object. If an object has references to other objects, complete new copies of those objects are also made. A deep copy generates a copy not only of the primitive values of the original object, but copies of all sub-objects as well, all the way to the bottom. To get a true, complete copy of the original object, you will need to override the default object.clone() to implement a full deep copy for the object.

The Cloneable Interface It is a Marker Interface i.e. it does not contain constants or methods. Defined in the java.lang package as follows: package java.lang; public interface Cloneable { }

Examples Many classes (e.g., Date and Calendar) in the Java library implement Cloneable. Thus, the instances of these classes can be cloned. For example, the following code outputs Calendar calendar = new GregorianCalendar(2003, 2, 1); Calendar calendarCopy = (Calendar)calendar.clone(); System.out.println("calendar == calendarCopy is " + (calendar == calendarCopy)); System.out.println("calendar.equals(calendarCopy) is " + calendar.equals(calendarCopy)); calendar == calendarCopy is false calendar.equals(calendarCopy) is true  

Implementing Cloneable Interface A class that implements the Cloneable interface must override the clone() method in the Object class.

public class House implements Cloneable{ private int id; private double area; public House(int id, double area) { this.id = id; this.area = area; } public double getId() { return id; } public double getArea() { return area; } public Object clone() throws CloneNotSupportedException { return super.clone();

public class House implements Cloneable{ private int id; private double area; private java.util.Date whenBuilt; public House(int id, double area) { this.id = id; this.area = area; whenBuilt = new java.util.Date(); } public double getId() { return id; } public double getArea() { return area; } public java.util.Date getWhenBuilt(){ return whenBuilt; } public Object clone() throws CloneNotSupportedException { return super.clone();

Shallow vs. Deep Copy House house1 = new House(1, 1750.50); House house2 = (House)house1.clone();

public class House implements Cloneable{ private int id; private double area; private java.util.Date whenBuilt; // other code public Object clone() throws CloneNotSupportedException { House house = (House)super.clone(); house.whenBuilt = (java.util.Date)(whenBuilt.clone()); return house; } All mutable fields should be cloned to get a deep copy. Strings are immutable, so there is no need to clone String type attributes separately.

Is the clone() method doing deep copy? public class House implements Cloneable{ private int id; private double area; private String name; public House(int id, double area) { this.id = id; this.area = area; whenBuilt = new java.util.Date(); } public double getId() { return id; } public double getArea() { return area; } public java.util.Date getWhenBuilt(){ return whenBuilt; } public Object clone() throws CloneNotSupportedException { return super.clone(); Is the clone() method doing deep copy?

Can the clone() method be written as follows? class House implements Cloneable { private int numberOfRooms; private int squareFeet; //... public Object clone() throws CloneNotSupportedException { return new House(numberOfRooms, squareFeet); }

What happens when the following code is executed? public class MultiStoryHouse extends House { private int numberOfStories; public MultiStoryHouse(int numRooms, int sqFootage, int numStories) { super(numRooms, sqFootage); numberofStories = numStories; } // no clone method defined public class Driver { public static void main(String[] args) { MultiStoryHouse msh = new MultiStoryHouse(6, 3000, 2); MultiStoryHouse other = (MultiStoryHouse)msh.clone(); //Exception

Get more info! Java docs: Cloneable Wikipedia: Clone http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Cloneable.html Wikipedia: Clone http://en.wikipedia.org/wiki/Clone_(28Java_method) Clone( ) method explained! http://geekexplains.blogspot.com/2008/06/what-is-cloning-how-clone-method-works.html