Abstract Classes vs Interfaces

Feature	Interface	Abstract Class
Definition	A contract with abstract methods, default methods, static methods, and constants.	A class with abstract and/or concrete methods, fields, and constructors.
Keyword	`interface`	`abstract class`
Instantiation	Cannot be instantiated.	Cannot be instantiated.
Methods	Abstract methods (implicitly `public`), default methods, static methods.	Abstract and concrete methods (any access modifier).
Fields	Only `public`, `static`, `final` fields (constants).	Can have instance fields (state) with any access modifier.
Constructors	No constructors.	Can have constructors for initialization.
Inheritance	A class can implement multiple interfaces (`implements`).	A class can extend only one abstract class (`extends`).
Multiple Inheritance	Supported (via multiple interfaces).	Not supported (single inheritance for classes).
Access Modifiers	Methods are implicitly `public`.	Methods/fields can be `public`, `protected`, `private`, or `default`.
State	Stateless (no instance fields).	Can maintain state (instance fields).
Use Case	Define a contract or role (e.g., `Comparable`, `Runnable`).	Provide partial implementation and shared state (e.g., `Vehicle` with fields).
Polymorphism	Supports polymorphism (interface reference to implementing class).	Supports polymorphism (abstract class reference to subclass).
Example	`java<br>interface Flyable {<br> void fly();<br>}<br>`	`java<br>abstract class Animal {<br> abstract void sound();<br> void sleep() { ... }<br>}<br>`

interface Drawable {
    void draw();
    default void describe() {
        System.out.println("This is a drawable object.");
    }
}

abstract class Shape {
    String color;

    Shape(String color) {
        this.color = color;
    }

    abstract double getArea();

    String getColor() {
        return color;
    }
}

class Circle extends Shape implements Drawable {
    double radius;

    Circle(String color, double radius) {
        super(color);
        this.radius = radius;
    }

    @Override
    double getArea() {
        return Math.PI * radius * radius;
    }

    @Override
    public void draw() {
        System.out.println("Drawing a " + getColor() + " circle.");
    }
}

class Main {
    public static void main(String[] args) {
        Circle circle = new Circle("Red", 5);
        circle.draw();        // Output: Drawing a Red circle.
        circle.describe();    // Output: This is a drawable object.
        System.out.println("Area: " + circle.getArea()); // Output: Area: 78.53981633974483
    }
}

Keyboard shortcuts

Notes