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. |
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