Abstract classes & interfaces

In large-scale system design, architects frequently define common behaviors that multiple different classes must share, without committing to how those behaviors are carried out. Two complementary mechanisms achieve this in object-oriented design:abstract classes and interfaces.

An abstract class sits at the top of an inheritance hierarchy to provide a shared template:

• Cannot be instantiated: You can never write new Shape(). Doing so generates a compilation error.
• Can contain concrete code: An abstract class can contain regular instance variables, constructors, and fully implemented methods that subclasses inherit.
• Abstract methods: Methods declared with the abstract keyword have a signature but no body (e.g. public abstract double area();). Every non-abstract subclass is forced by the compiler to override and implement them.

An interface is a pure contract specifying what an object can do, with zero concern for how it does it:

// Interface declaration:
public interface Printable {
    void print(); // Implicitly public and abstract
}

// Class implementation:
public class Invoice implements Printable {
    public void print() {
        System.out.println("Printing customer invoice...");
    }
}

A single class can implement multiple interfaces (e.g. class Player implements Controllable, Serializable, Renderable). This provides the architectural benefits of multiple inheritance while avoiding the diamond problem of conflicting field implementations.