what is the advantage of interface over abstract classes?

In Java, abstract classes give the ability to define both concrete and abstract methods whereas interfaces only give the ability to implement abstract methods. I believe overriding methods in subclasses/implementations is possible in both cases, there开发者_C百科fore, what is the real advantage of one over the other (interfaces vs abstract classes in Java)?

Interfaces are for when you want to say "I don't care how you do it, but here's what you need to get done."

Abstract classes are for when you want to say "I know what you should do, and I know how you should do it in some/many of the cases."

Abstract classes have some serious drawbacks. For example:

class House {

}

class Boat {

}

class HouseBoat extends /* Uh oh!! */ {
    // don't get me started on Farmer's Insurance "Autoboathome" which is also a helicopter
}

You can get through via an interface:

interface Liveable {

}

interface Floatable {

}

class HouseBoat implements Liveable, Floatable {

}

Now, abstract classes are also very useful. For example, consider the AbstractCollection class. It defines the default behavior for very common methods to all Collections, like isEmpty() and contains(Object). You can override these behaviors if you want to, but... is the behavior for determining if a collection is empty really likely to change? Typically it's going to be size == 0. (But it can make a big difference! Sometimes size is expensive to calculate, but determining whether something is empty or not is as easy as looking at the first element.)

And since it won't change often, is it really worth the developer's time to implement that method every... single... time... for every method in that "solved" category? Not to mention when you need to make a change to it, you're going to have code duplication and missed bugs if you had to re-implement it everywhere.

Interfaces are useful because Java doesn't have multiple inheritance (but you can implement as many interfaces as you like).

Abstract classes are useful when you need concrete behaviour from the base class.

The facts are-

1. Java doesn't support multiple inheritance
2. Multiple interfaces can be implemented
3. Few methods in an abstract class may be implemented

These facts can be used to tilt the advantage in favor of interfaces or abstract classes.

If there are more than one behavior that a class must share with other classes, interfaces win. If a method definition has to be shared/ overridden with other classes, abstract classes win.

An class may implement several interfaces, whereas it may only extend one class (abstract or concrete), because Java does not support multiple inheritance.

In OOP (mostly independent of a concrete language) abstract classes are a re-use mechanism for the class hierarchy for behaviour and structure which isn't complete on its own. Interfaces are mechanism for specification of requirements on a module (e.g. class) independently of the concrete implementation. All other differences are technical details, important is different usage.

You dont override an interface. You implement it.

Writing an interface gives implementors the ability to implement your interface and also other interfaces in addition to inheriting from a base class.

Abstract classes can be partially or fully implemented.Marking a class abstract just prevents you from instantiating an object of that type.

-Method without any implementation is abstract method,whenever a class contains one or more abstract method,then it must be declared as a abstract class

-Interface is fully abstract which cannot have constructor,instance and static blocks,and it contains only two types of members 1.public abstract method 2.public-static-final variable

*Both cannot be instantiated but reference can be created.

*Which one suits better depends on the application -Interfaces are useful because Java classes will not support multiple inheritance but interfaces do.

-Abstract classes are useful when you need concrete behavior from the base class.

The main advantages of interface over abstract class is to overcome the occurrence of diamond problem and achieve multiple inheritance. In java there is no solution provided for diamond problem using classes.For this reason multiple inheritance is block using classes in java. So to achieve multiple inheritance we use interface .

class Animal
{ void move(){} }

class Bird
{ void move(){fly} }

class Fish
{ void move(){swim} }

Now, if class Animal is abstract class like

Animal a; 

a= new Bird(); or a = new Fish()

Here, abstraction works well, but if there are 100 objects like Animal a[100];

You can not write new Bird().move or new Fish().move 100 times

Use interface and write a[i].move. It will differentiate as bird or fish and that move() will be invoked

Second it supports multiple inheritance as class A can implements as many interfaces.

Amazing answers!!

I too want to put my opinion on Interface.

As the name says it is interface which means it will provide interface between two classes.

It help a class or interface hold multiple behavior at the same time.

Who ever having the interface can access the behavior of the class agreed with the interface.

interface teacher
    {
    //methods related to teacher
    }

interface student
    {
     //methods related to student
    }
 interface employee
    {
    //methods related to employee
    }

 class Person:teacher,student,employee
    {
     //definition of all the methods in teacher,student, employee interface
     //and method for person
    }

Now here which ever class is having teacher interface will have access to only teacher behavior of Person. Similarly the class or module having student interface will have access to only student behavior of person.

Using abstract class, it is not at all possible.

Hope this will add some additional points. :)

Happy coding!!.