[hardwired]

they placed obj1 in the if condition in ().what it indicates
Nothing really. Some people like to do it this way.

Code:

public class InterfaceRx {
    public static void main(String[] args) {
        Length length1 = new Length(100);
        Length length2 = new Length(50);
        Length larger = (Length)findLargest(length1, length2);
        System.out.println("larger = " + larger);
        Sequence seq1 = new Sequence(new int[]{5, 6, 7});
        Sequence seq2 = new Sequence(new int[]{3, 5, 7});
        Object o = findLargest(seq1, seq2);
        System.out.println("o = " + o);
        System.out.println("(Sequence)o  = " + (Sequence)o);
        System.out.println("(Relatable)o = " + (Relatable)o);
        Relatable r1 = new Length(12);
        Relatable r2 = new Length(32);
        Relatable r = (Relatable)findLargest(r1, r2);
        System.out.println("r = " + r);
        Relatable length = new Length(51);
        Relatable sequence = new Sequence(new int[]{1});
        //Object retVal = findLargest(length, sequence);
    }

    public static Object findLargest(Object object1, Object object2) {
        Relatable obj1 = (Relatable)object1;
        Relatable obj2 = (Relatable)object2;
        if (obj1.isLargerThan(obj2) > 0)
            return object1;
        else 
            return object2;
    }
}

class Sequence implements Relatable {
    int[] data;
    int length;

    Sequence(int[] data) {
        this.data = data;
        length = data.length;
    }

    public int isLargerThan(Object o) {
        Sequence aSequence = (Sequence)o;
        int len1 = length;
        int len2 = aSequence.length;
        int[] data2 = aSequence.data;
        if(len1 == len2) {
            for(int j = 0; j < length; j++) {
                if(data[j] != data2[j])
                    return data[j] - data2[j];
            }
        }
        return len1 - len2;
    }

    public String toString() {
        String s = "[";
        for(int j = 0; j < length; j++) {
            s += data[j];
            if(j < length-1)
                s += ", ";
        }
        s += "]";
        return "Sequence[data:" + s + ", length:" + length + "]";
    }
}

class Length implements Relatable {
    int value;

    Length(int value) {
        this.value = value;
    }

    public int isLargerThan(Object o) {
        int thisVal = this.value;
        int anotherVal = ((Length)o).value;
        return (thisVal < anotherVal ? -1 : (thisVal == anotherVal ? 0 : 1));
    }

    public String toString() {
        return "Length[value:" + value + "]";
    }
}

interface Relatable {
    public int isLargerThan(Object o);
}