This is very common question in core java interview for entry level programmer so let’s discuss some important point of difference as below:
Difference between interfaces and abstract classes
| abstract class | interface |
|---|---|
| Abstract class may not be contain abstarct method or may be contain. we can say it can have abstract and non-abstract methods. | By default all methods of interface are abstract. |
| An abstract class may contain non-final variables. | Variables declared in a Java interface is by default final. |
| A Java abstract class can have the any flavors of class members like private, abstract. | Members of a Java interface are public by default. |
| An abstract class required when we want some default behavior in our project as like in DAO layer there are some common behavior save object, delete object etc. | Java interface is required when we want implement contract between service and client. |
| The abstract keyword is used to declare abstract class. Example: public abstract class Shape{ public abstract void draw(); } |
The interface keyword is used to declare interface. Example: public interface Drawable{ void draw(); } |
| A Java abstract class should be extended using keyword “extends”. Example: public class Circle extends Shape{ public void draw(){ //draw circle; } } |
Java interface should be implemented using keyword “implements”; Example: public class Circle implements Drawable{ public void draw(){ //draw circle; } } |
| Abstract class can have static methods, main method and constructor. | Interface can’t have static methods, main method or constructor. |
| Abstract class doesn’t support multiple inheritance. | Interface supports multiple inheritance. |
Popular Tutorials
Abstract Class Examples in Java –
abstract class Shape{
abstract void draw();
}
class Rectangle extends Shape{
void draw(){
System.out.println("Drawing Rectangle");
}
}
class Traingle extends Shape{
void draw(){
System.out.println("Drawing Traingle");
}
}
class AbstractDemo{
public static void main(String args[]){
Shape s1 = new Rectangle();
s1.draw();
s1 = new Traingle();
s1.draw();
}
}
Output:
Drawing Rectangle
Drawing Traingle.
Interface Examples in Java –
interface Drawable{
abstract void draw();
abstract void fillColor();
}
class abstract BlueShape implement Drawable{
void fillColor(){
System.out.println("Fill Blue color in Shape");
}
}
class Traingle extends BlueShape {
void draw(){
System.out.println("Drawing Blue Traingle");
}
}
class InterfaceDemo{
public static void main(String args[]){
Drawable s1 = new Traingle();
s1.draw();
}
}
Output:
Drawing Blue Traingle.
Abstract classes can have a constructor because the constructor does not define a method signature that must be matched inherited by child classes. It’s the only method that doesn’t require that same signature on child implementations