What is the difference between an abstract class and an interface?

Abstract class: a shared base

An abstract class is meant to be a common parent. It can provide some finished methods and leave others for children to complete. You cannot create an object of an abstract class directly.

class Shape {                       // abstract base class
public:
    virtual double area() = 0;         // no body, children must fill in
    void describe() {                  // shared, finished method
        cout << "I am a shape";
    }
    virtual ~Shape() = default;
};

abstract class Shape {
    abstract double area();          // no body, children must fill in
    void describe() {                // shared, finished method
        System.out.println("I am a shape");
    }
}

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self):          # no body, children must fill in
        ...
    def describe(self):      # shared, finished method
        print("I am a shape")

Interface: a pure contract

An interface says what a class must be able to do, without saying how. Many unrelated classes can implement the same interface to promise the same capability.

class Drawable {                   // interface via pure virtual
public:
    virtual void draw() = 0;   // any Drawable must provide draw()
    virtual ~Drawable() = default;
};
class Circle : public Drawable {
public:
    void draw() override { cout << "circle"; }
};

interface Drawable {
    void draw();   // any Drawable must provide draw()
}
class Circle implements Drawable {
    public void draw() { System.out.println("circle"); }
}

from abc import ABC, abstractmethod

class Drawable(ABC):
    @abstractmethod
    def draw(self):   # any Drawable must provide draw()
        ...
class Circle(Drawable):
    def draw(self):
        print("circle")

Quick comparison

• Methods: an abstract class can have finished and unfinished methods, an interface is traditionally only a contract.
• State: an abstract class can hold fields and state, an interface mainly holds constants.
• Inheritance: a class extends one abstract class but can implement many interfaces.
• Use: abstract class for a shared base type, interface for a capability shared across unrelated types.