Different Between An Interface and An Abstract Class

What is the different between an interface and an abstract class in Java?

It is best to start answering this question with a brief definition of abstract classes and interfaces and then explore the two.

A class must be declared abstract when it has one or more abstract methods. A method is declared abstract when it has a  method heading, but no body

which means that an abstract method has no implementation code inside curly braces like normal methods do.

When to use abstract methods in Java?

Why you would want to declare a method as abstract is best illustrated by an example. Take a look at the code below:

public abstract class Figure{
        public abstract float getArea();
}
public class Circle extends Figure{
        private float radius;
        public float getArea(){
                  return (PI * (radius^2));
        }
}
public class Rectangle extends Figure{
        private float length, width;
        public float getArea(Figure other){
                  return length*width;
        }
}

In the Figure class above, we have an abstract method called getArea(), and  an becasue the Figure class contains an abstract method the entire Figure class itself 

must be declared abstract. The Figure base class has two classes which derive from it - called Circle and Rectangle classes provide definitions for the getArea method,

as you can see in the code above.

But the real question is why did we declare the getArea method to be abstract in the Figure class? Well, what does the getArea method do? It returns the area of a

 specific shape, But, because the Figure class  is not a specific shape(like a Circle or a Rectangle), there is really no definition we can give the getArea method inside the 

Figure class. That is why we declare the method and the Figure class to be abstract. Any classes that derive from the Figure class basically has 2 options:

1: The derived class must provide a definition for the getArea method OR

2: The derived class must be declared abstract itself.

A non abstract class is called a concrete class

You shoud also know that any non abstract class is called a concrete class. Knowing your terminology defintely pays off in an interview.

Now that we have expected the abstract method/class concepts, let us get into the concept of interfaces and how they differ from abstract classes.

Java interface versus abstract class
An interface differs from an abstract class because an interface is not a class. An interface is essentially a type that can be satisfied by any class that implements the

 interface.

Any class that implements an interface must satisfy 2 conditions:

1>It must have the phrase "implements Interface_Name" at the begining of the class definition.

2>It must implement all of the method headings listed in the interface defintion.

This is what an interface called "Dog" would look like:

public interface Dog{
        public boolean Barks();
        public boolean isGoldenRetriever();
}

Now if a class were to implement this interface, this is what it would look like:

public class Someclass implements Dog{
         public boolean Barks(){
                   //method definition here
          }
          public boolean isGoldenRetriever{
                   //method definition here
          }
}

Now that we know the basics of interfaces and abstract calsses, let us get to the heart of the question and explore the differences between the two. Here are the three

major differences:

Abstract classes and inheritance

1.Abstract classes are meant to be inherited from, and when one class inherits from another it means that there is a strong relationship between the 2 classes. For

 instance,if we have an abstract base class called "Canine", any deriving class should be an animal that belongs to the Canine family (like a Dog or a Wolf). The reason we

 use the word "should" is because it is up to the Java developer to ensure that relationship is maintained.

With an interface on the other hand, the relationship between the interface itself and the class implementing the interface is not necessarily strong. For example, if we

have a class called "House", that class could also implement an interface called "AirConditioning", Having air conditioning not really an essential part of a House(although

some may argue that point), and the relationship is not as strong as ,say, the relationship between a "TwonHouse" class and the "House" class or the relationship between

an "Apartment" class that derives from a "House" class.

Because a TownHouse is a type of House, that relationship is very strong, and would be more appropriately defined through inheritance instead of interfaces.

So, we can summarize this first point by saying that an abstract class would be more approproate when there is a strong relationship between the abstract class and 

the classes that will derive from it. Again, this is because an abstract class is very closely linked to inheritance, which implies a strong relationship. But, with interfaces there

need not  be a strong relationship between the interface and the classes that implement the interface.

Interfaces are a good substitute for multiple inheritance

Java does not allow multiple inheritance if you need a refresh on this. In Java, a class can only derive from one class, whether it is abstract or not. However, a class can

implement multiple interfaces which could be considered as an alternative to for multiple inheritance. So, one major difference is that a Java class can inherit from only one

abstract class but can implement multiple interfaces.

Abstract classes can have some implementation code

An abstract class may  provide some methods with definitions so an abstract calss can have non abstract methods with actual implementation details. An abstract class can

also have constructors an instance variables as well. An interface , however, can not provide any method definitions it can only provide method headings. Any class that 

implements the interface is responsible for providing the method definition/implementation.

When to  use abstract calss and interface in Java

Here are some guidelines on when to use an abstract class and when to use interface in Java:

1. An abstract class is good if you think you will plan on suing inheritance since it provides a common base class implementation to derived classes.

2. An abstract class is also good if you want to be able to declare non public members. In an interface, all methods must be public.

3. If you think you will need to add methods in the future, then an abstract class is a better choice. Because if you add new method headings to an interface, then all of the

classes  that already implement that interface will have to be changed to implement the new methods. That can be a quiet a hassle.

4. Interface are good choice when you think that the API will not change for a while.

5. Interface are also good when you want to have something similiar to multiple inheritance, since you can implement multiple interfaces.