What is the difference between an interface and abstract class

This is an extremely common interview question. It's surprising since an abstract class is rarely used in solutions compared to other things.

Many junior developers make the mistake of thinking of interfaces, abstract and concrete classes as slight variations of the same thing, and choose one of them purely on technical grounds: Do I need multiple inheritance? Do I need some place to put common methods? Do I need to bother with something other than just a concrete class?

So here is a clear difference and uses of Interface and Abstract class.

The key technical differences between an abstract class and an interface are:

• Abstract classes can have constants, members, method stubs (methods without a body) and defined methods, whereas interfaces can only have constants and methods stubs.


• Methods and members of an abstract class can be defined with any visibility, whereas all methods of an interface must be defined as public (they are defined public by default).


• When inheriting an abstract class, a concrete child class must define the abstract methods, whereas an abstract class can extend another abstract class and abstract methods from the parent class don't have to be defined.


• Similarly, an interface extending another interface is not responsible for implementing methods from the parent interface. This is because interfaces cannot define any implementation.


• A child class can only extend a single class (abstract or concrete), whereas an interface can extend or a class can implement multiple other interfaces.


• A child class can define abstract methods with the same or less restrictive visibility, whereas a class implementing an interface must define the methods with the exact same visibility (public).

Example:

Interface

 // I say all motor vehicles should look like this:  
 interface MotorVehicle  
 {  
      void run();  
      int getFuel();  
 }  
 // My team mate complies and writes vehicle looking that way  
 class Car implements MotorVehicle  
 {  
      int fuel;  
      void run()  
      {  
           print("Wrroooooooom");  
      }  
      int getFuel()  
      {  
           return this.fuel;  
      }  
 }  

Abstract Class

 // I say all motor vehicles should look like this:  
 abstract class MotorVehicle  
 {  
      int fuel;  
      // They ALL have fuel, so why not let others implement this?  
      // Let's make it for everybody.  
      int getFuel()  
      {  
           return this.fuel;  
      }  
      // That can be very different, force them to provide their  
      // implementation.  
      abstract void run();  
 }  
 // My teammate complies and writes vehicle looking that way  
 class Car extends MotorVehicle  
 {  
      void run()  
      {  
           print("Wrroooooooom");  
      }  
 }  

That's it. Hope this will help you to understand the difference and implement the Interfaces and Abstract classes in your next project.

Source : Stackoverflow