why we need interface instead of class and what we are achieving from interface

Question

As we know that we can declare only the method signature and also can not create the instance of a Interface. then why we need interface. Unnecessary its loading into JVM. This is also one performance degradation. We are creating the interface and several classes implementing that interface and defining all the methods of the interface. Actually what we achieved from this interface. Could you please give me some example.

Answer 1

An analogy for an interface is to think of a class using an interface as being like an electric wall outlet, and think of the implementation as the plug. The outlet doesn't care what's behind the plug, as long as it fits in the outlet. In psuedocode terms it could be written like this:

public interface ElectricOutlet {
     public void powerUp(); 
}

And a class that implements ElectricOutlet might look like this:

public class Appliance implements ElectricOutlet {
    //member variables
    public void powerUp() {
        //Draw power from the wall
    }
    ...
}

So how do you use that interface? Like this:

//lots of other code
ElectricOutlet out = new Appliance(); //plug the appliance into the outlet
out.powerUp; //power it up!

Of course, it doesn't have to be an appliance that you plug into an outlet. It could be a TV, or a laptop, or a lawn mower, but they all behave the same way from the outlet's point of view. So how does this apply to programming? In exactly the same way:

List<String> list = new ArrayList<String>(); // create a new List of Strings

I just created a new (empty) List of Strings. If it turns out that ArrayList doesn't provide the right performance, and LinkedList works better, I can go back and change that line to this:

List<String> = new LinkedList<String>(); //should work better now

I can do this because both ArrayList and LinkedList implement the List interface, and thus they provide the same behavior (API), even though the internal implementations may be different. From the List's point of view, however, it doesn't matter what the internal workings are, just as long as the interface is there. This allows a lot of independence between classes, and allows more reuse.

Answer 2

Interface is nothing but its a guide line for the new implementation it provides some instructions for new implementation and categorize the functionality of the object .In details like if we create an interface then we create an instruction for the implementation .

Answer 3

The most important use of interfaces as i see it is passing code(anonymous inner class or lambda) to a method as parameter.

Example:

Suppose we want to make a method which can return the execution time required to run a piece of code. We want to pass our code as a parameter to this method.

interface Code{
     public void run();   
}


long getExectutionTime(Code code){

     long startTime = System.nanoTime();    
     code.run();    
     return System.nanoTime() - startTime;
}


getExecutionTime(new Code(){

     public void run(){
          //the code to be executed
     }
});

In java 8,

getExecutionTime(()->{ 
     //the code to be executed 
});

Answer 4

Simple. I think Interfaces and Abstract classes are for the same purpose. The difference is If you extend an Abstract Class, you could not extend no other class in Java. Reason: Java does not support Multiple Inheritance. At the same time, You can implement any number of Interface for a class.

Answer 5

Interface is you are forcing your client to implement some specified thing, implementation will be remain to the client.Also java doesn't support multiple inheritance by extending multiple classes you can have multiple interface implemented.

For example : List declares add(..) method all the implementation of List provides it implementations.

Simpler would be.

You define an Interface Animal and a method speak() it means all Animal must will have to speak with different different implementation. Man will speak,Dog will bark,Lion will roar.

Why should we go for create class Animal extra. We can declare the speak() in every class. What is befit we will get from Animal class and implementing speak() in all the sub classes. Still I did not get this concept

Main advantage is inheritance and polymorphism [core concepts of OOP]

You are specifying Animal's behavior here also.

You can have

Animal obj = new Man();

Animal obj = getAnimalForThisCriteria(something here);//this will return some animal at runtime so you can catch instance using Animal.

You might have Three different Class Ma,Dog,Lion with same method but there is no way to tell they all are animal unless they extends or implements common class or interface, here comes the concept of structure

Answer 6

I'll try to explain this in simple words.

Consider your favorite Computer Game, say Counter Strike. In this game, the players (terrorists or counter-terrorists) use weapons.

If we teach the player how to use weapon (analogous to Interface), it can use any weapon like AK47, Maverick, Shotgun, Sniper (analogous to classes which inherit Weapon interface).

The advantage of this is consider Bazooka (which implements Weapon) is developed in future versions. Then the current player will be able to use it without any modifications - as it knows how to use Weapon interface :-)

This is just a simple example. There are many other reasons for using interfaces.

Answer 7

Interfaces are for when you care only about an object's capabilities, not how it achieves them.

Suppose you are writing the high level control code for a robot. You don't care about how the robot actually works, you only want to be able to tell it to go forward, backward, turn left or right, etc. Without interfaces, you would implement a abstract class called AbstractRobot that has all methods as abstract methods. At this point you have basically created an interface,but in the form of an abstract class, but one that is 'heavier' than required.

Lastly, a class can conform to multiple interfaces, but can only inherit from one class. This allows some design patterns which rely on multiple inheritance.

Answer 8

Having interfaces separate from classes allows for clear separation between, well, the interface of an object and its implementation. Without them you would have no standard way to indicate that some class should not contain implementation details at all.

Second, since Java does not support multiple inheritance, interfaces are a partial workaround, by allowing inheritance on the outward features of the class.