What is the advantage of using interfaces [duplicate]

Answer 1

An interface allows you to guarantee that certain methods exist and return the required types. When the compiler knows this, it can use that assumption to work with unknown classes as if they had certain known behavior. For example, the comparable interface guarantees that an implementing class will be able to compareTo() some similar object and will return an int.

This means that you can compare anything that implements this interface - so you can sort anything that is Comparable instead of writing one method to sort Strings and another to sort Integers and another to sort LabelledBoxesOfBooks

Answer 2

It makes it easier to define APIs using interfaces, so that all concrete implementations of the interfaces provide the expected methods in each class.

It also provides a way to implement multiple inheritance, which is not possible (in Java) with straight class inheritance.

Answer 3

My professor in college once gave a great anecdote to describe polymorphism and encapsulation. It went like this.

---

Does anyone here know how a soda machine works? (Cue confused glances about why we'd even talk about this.) No? Let me tell you.

You drop in your change, and inside the machine is a little monkey who counts all your change to make sure you put in enough money. When you press the button for your soda, a little light comes on telling the monkey which button you pressed, and if you entered the right amount of change, he grabs your choice and throws it into the little hole for you to grab your soda.

This is the concept of encapsulation. We hide the implementation of the soda machine. Unless it's got one of those fancy, clear windows to let you see the inside, you honestly have no idea how it really works. All you know is that you put in some cash, you press a button, and if you put in enough, you get your drink.

To add to that, you know how to use a soda machine's interface, so therefore as long as the machine's interface follows the usual soda machine interface, you can use it. This is called the interface contract. The machine can be bringing the drinks from Antarctica on a conveyor belt for all you care, as long as you get your drink, it's cold, and you get change back.

Polymorphism is the idea that when you use the soda machine interface, it could be doing different things. This is why encapsulation and polymorphism are closely related. In polymorphism, all you know is that you're using a SodaMachine implementation, which can be changed, and as a result, different things can be done behind the scenes. This leads to the driving concept of polymorphism, which is the ability of one object, the SodaMachine, to actually act as both a MonkeySodaMachine and a ConveyorSodaMachine depending on the machine actually behind the interface.

---

Probably not word-for-word, but close enough. Essentially it boils down to two concepts: polymorphism and encapsulation. Let me know if you want clarification.

Answer 4

It separates what the caller expects from the implementation. You have a pure set of methods you can call without any knowledge of the implementation. In fact some libraries like JMS and JDBC provide interfaces without any implementations.

This separation means you don't need to know the class of any actual implementation.

Answer 5

The interface essentially guarentees that all the methods that inherit it will have its methods, so that you can safely call a method in the interface for anything that inherits it.

Answer 6

Why is this better than just having individual methods in your classes, and not implementing an interface?

Because if a class C implements an interface I, you can use a C whenever an I is expected. If you do not implement the interface, you could not do this (even if you provided all of the appropriate methods as mandated by the interface):

interface I {
    void foo();
}

class C1 implements I {
    public void foo() {
        System.out.println("C1");
    }
}

class C2 {  // C2 has a 'foo' method, but does not implement I
    public void foo() {
        System.out.println("C2");
    }
}

...

class Test {
    public static void main(String[] args) {
        I eye1 = new C1();  // works
        I eye2 = new C2();  // error!
    }
}