on 16-Nov-2014 (Sun)

Suppose we have a class that tries to cooperate with String. What is wrong with it?

public final class CaseInsensitiveString {

    private final String s;

    @Override public boolean equals(Object o) {
        if (o instanceof CaseInsensitiveString)
            return s.equalsIgnoreCase(((CaseInsensitiveString) o).s);
        if (o instanceof String)
            return s.equalsIgnoreCase((String) o);
       return false;
    }

    // rest of the code
}

Suppose we have a class

public class Point {
    private final int x;
    private final int y;

    @Override public boolean equals(Object o) {
	if (!(o instanceof Point))
	    return false;
	Point p = (Point)o;
	return p.x == x && p.y == y;
    }
    // Remainder omitted
}

and a subclass

public class ColorPoint extends Point {
    private final Color color;
    // Remainder omitted
}

what are the consequences of NOT implementing equals() method on ColorPoint?

Suppose we have a class

public class Point {
    private final int x;
    private final int y;

    @Override public boolean equals(Object o) {
	if (!(o instanceof Point))
	    return false;
	Point p = (Point)o;
	return p.x == x && p.y == y;
    }
    // Remainder omitted
}

and a subclass

public class ColorPoint extends Point {
    private final Color color;

    @Override public boolean equals(Object o) {
      if (!(o instanceof ColorPoint))
         return false;
      return super.equals(o) && ((ColorPoint) o).color == color;
     }

    // Remainder omitted
}

what are the consequences of implementing equals() method on ColorPoint like above?

Suppose we have a class

public class Point {
    private final int x;
    private final int y;

    @Override public boolean equals(Object o) {
	if (!(o instanceof Point))
	    return false;
	Point p = (Point)o;
	return p.x == x && p.y == y;
    }
    // Remainder omitted
}

and a subclass

public class ColorPoint extends Point {
    private final Color color;

    @Override public boolean equals(Object o) {
	if (!(o instanceof Point))
	    return false;
	// If o is a normal Point, do a color-blind comparison
	if (!(o instanceof ColorPoint))
	    return o.equals(this);
	// o is a ColorPoint; do a full comparison
	return super.equals(o) && ((ColorPoint)o).color == color;
    }
    // Remainder omitted
}

what are the consequences of implementing equals() method on ColorPoint like above?

It violates transitivity, for example:

ColorPoint p1 = new ColorPoint(1, 2, Color.RED);
Point p2 = new Point(1, 2);
ColorPoint p3 = new ColorPoint(1, 2, Color.BLUE);

Now p1.equals(p2) and p2.equals(p3) return true, while p1.equals(p3) returns false, a clear violation of transitivity. The first two comparisons are “color-blind,” while the third takes color into account.

What are the consequences of implementing equals() method like this (using getClass() instead of using instanceof)?

public class Point {
     @Override public boolean equals(Object o) {
     if (o == null || o.getClass() != getClass())
         return false;
     Point p = (Point) o;
     return p.x == x && p.y == y;
 }
}

What is a better way of implementing ColorPoint to avoid problems with equals() method?

public class Point {
    private final int x;
    private final int y;

    @Override public boolean equals(Object o) {
	if (!(o instanceof Point))
	    return false;
	Point p = (Point)o;
	return p.x == x && p.y == y;
    }
    // Remainder omitted
}

public class ColorPoint extends Point {
    private final Color color;

    // Remainder omitted
}

Use composition, not inheritance:

public class ColorPoint {
    private final Point point;
    private final Color color;

    // Remainder omitted
}

public int compareTo(PhoneNumber pn) {
    return lineNumber - pn.lineNumber;
}

if (o instanceof Set) { // Raw type
  // here
}

if (o instanceof Set) { // Raw type
  Set<?> m = (Set<?>) o; // Wildcard type
  // rest of the code
}

// Fails at runtime!
Object[] objectArray = new Long[1];
objectArray[0] = "I don't fit in"; // Throws ArrayStoreException

// Won't compile!
List<Object> ol = new ArrayList<Long>(); // Incompatible types
ol.add("I don't fit in");

1. You could create an array of lists of strings:
   List<String>[] stringLists = new List<String>[1]; // this part is not legal and wouldn't compile
2. Because arrays are covariant, you can store the array into a variable of Object[] type and then store an element of type List<Integer> (or really List<anything>) as an element of the original array without causing ArrayStoreException because at runtime List<String> and List<Integer> are simply lists
3. So, we are in trouble - List<Integer> is stored where the compiler thought it was List<String>

public interface Comparable<T> {
   int compareTo(T o);
}

// Wildcard type for parameter that serves as an E producer - produces Es onto a Stack from external Iterable
public void pushAll(Iterable<...> src) {
  for (E e : src)
    push(e);
}

// Wildcard type for parameter that serves as an E consumer - it consumes from the Stack to external collection
public void popAll(Collection<...> dst) {
  while (!isEmpty())
    dst.add(pop());
}

public static <E> Set<E> union(Set<? extends E> input1, Set<? extends E> input2)  { /* .. */ }

public static <E> Set<? super E> union(Set<? extends E> input1, Set<? extends E> input2) { /* .. */ }

public static <E> Set<E> union(Set<? extends E> input1, Set<? extends E> input2)  { /* .. */ }

public static <E> Set<E> union(Set<? extends E> s1, Set<? extends E> s2) { /* ... */ }

Set<Integer> integers = ... ;
Set<Double> doubles = ... ;
Set<Number> numbers = Union.union(integers, doubles); // does not compile

Set<Number> numbers = Union.<Number>union(integers, doubles);