Why should I use interface in this situation in Java?

I'm trying to understand the basics of Java OOP concepts so I've a question about the interfaces as it confuses me a little. Below I was playing around with two classes. One which implements the SizeComparable interface and the other which doesn't but works too.

public interface SizeComparable {
    int isHigher(SizeComparable obj);
}

public class Interesting implements SizeComparable {

    private int height;

    public Interesting(int height) {
        this.height = height;
    }

    public int getHeight() {
        return height;
    }

    public int isHigher(SizeComparable obj) {
        Interesting otherInteresting = (Interesting)obj;
        if(this.getHeight() > otherInteresting.getHeight()) {
            return 1;
        } else {
            return 0;
 开发者_StackOverflow中文版       }
    }

    public static void main(String[] args) {
        Interesting i1 = new Interesting(182);
        Interesting i2 = new Interesting(69);

        int result = i1.isHigher(i2);

        System.out.println("Is i1 higher than i2? Result: " + result);
    }

}

How is the code above better than the code bellow? Personally I don't understand because the code bellow those it's job great too. Am I missing some concepts behind the interface idea?

public class Interesting {

    private int height;

    public Interesting(int height) {
        this.height = height;
    }

    public int getHeight() {
        return height;
    }

    public int isHigher(Interesting obj) {
        if(this.getHeight() > obj.getHeight()) {
            return 1;
        } else {
            return 0;
        }
    }

    public static void main(String[] args) {
        Interesting i1 = new Interesting(182);
        Interesting i2 = new Interesting(69);

        int result = i1.isHigher(i2);

        System.out.println("Is i1 higher than i2? Result: " + result);
    }

}

I was trying to understand it (here), but I'm still unsure about this. Sorry if the question is a little silly, i just want to understand it completely.

If you have Interesting, Boring, Indifferent and Crazy classes which all represent some objects comparable by height, then all of them can implement the SizeComparable interface and thus be comparable to each other.

Without the interface you would need n methods in each class to compare it with itself and all the others.

At the beginning it probably won't make much sense, however when you will start injecting dependencies, start testing or will write more than one implementation of interface, than it will really give you boost.

Also it allows for multiple inheritance. Sometimes you want thing like comparable - very generic interface that may be used by a lot of classes in your system. That will come with bigger systems and larger class hierarchies.

Right now just trust rest of java world, and use them interfaces :)

and good luck

An interface is a contract that any class wishing to implement the interface agrees to follow. The reason for using an interface is to allow some other class or method to access the interface functions without requiring that the your class inherit from a common class... I'll modify your example to make it clearer:

public interface HeightCapable {
    int getHeight();
}

public class Interesting implements HeightCapable {

    private int height;

    public Interesting(int height) {
        this.height = height;
    }

    public int getHeight() {
        return height;
    }

}

public class SomeOtherClass {
    public boolean isHigher(HeightCapable obj1, HeightCapable obj2) {
        // ... do something interesting
        if (obj1.getHeight() > obj2.getHeight()) {
            return true;
        }
}

In the example above, any class implementing the HeightCapable interface can call SomeOtherClass.isHigher(). Without the interface, any class wishing to call SomeOtherClass.isHigher() would need to inherit from a common class. Java lacks multiple inheritance.

If you want to have your SizeComparable objects comparable not to all other SizeComparable objects, but only to those of some type, you could use generic types.

interface SizeComparable<X> {

    /**
     * returns true if this object is higher than that object.
     */
    boolean isHigher(X that);

}

Then you could create your implementations like this:

public class Interesting implements SizeComparable<Interesting> {

    ...

    public boolean isHigher(Interesting obj) {
        return this.getHeight() > obj.getHeight();
    }

}

Or, you could even have another interface

public interface HeigthHaving extends SizeComparable<HeightHaving> {

    /**
     * returns the height of this object.
     */
    public int getHeigth(); 


    /**
     * compares this object's height with another objects height.
     * @return true if this.getHeight() > that.getHeight, else false.
     */
    public boolean isHigher(HeightHaving that);

}

Now every implementation of HeightHaving must implement the isHigher(HeightHaving) method (this would be the case even if we did not repeat it here), and should do that according to the specification here. Other SizeComparable implementations are not affected of this, though.

The good thing here is that now for example sort algorithms can sort lists/arrays of any type X implementing SizeComparable, so you don't have to write it again for every new type of object you may want to sort by height.

(In fact, there is already a similar interface Comparable<X> in the standard API. Maybe you want to use this instead of your SizeComparable.)

By the way, for a isXXX method usually a boolean return type is quite more sensible than an integer.