Abstract Classes & Abstraction

A blueprint you cannot build directly

Abstraction means hiding the messy details and showing only the important idea. In Java, one tool for this is an abstract class — a class marked with the word abstract.

An abstract class is a blueprint that is deliberately unfinished. You cannot create an object from it directly. Instead, other classes extend it and complete the missing parts. It is useful when several classes share some code but each must also do one thing its own way.

Think of a form template at an office. The template has fixed parts already printed (your name goes here, the date goes here) plus blank boxes everyone must fill in themselves. You never hand in the blank template — you hand in your completed copy. An abstract class is that template: it provides the printed parts (real methods) and the blank boxes (abstract methods the child must complete).

An abstract method has no body

Inside an abstract class you can have two kinds of method. A normal method has a body (code in { }). An abstract method has no body at all — just a name ending in a semicolon. It is a promise that every child must write that method.

public abstract class Shape {
    String name;

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

    // abstract method: no body — each child MUST provide one
    abstract double area();

    // normal method: shared by every child, with real code
    void describe() {
        System.out.println(name + " has area " + area());
    }
}

Children fill in the blanks

Now two real shapes extend Shape. Each must write its own area(), because the parent left it abstract. They get describe() for free.

public class Circle extends Shape {
    double radius;

    Circle(double radius) {
        super("Circle");
        this.radius = radius;
    }

    @Override
    double area() {
        return 3.14159 * radius * radius;
    }
}

public class Rectangle extends Shape {
    double width, height;

    Rectangle(double width, double height) {
        super("Rectangle");
        this.width = width;
        this.height = height;
    }

    @Override
    double area() {
        return width * height;
    }
}

Using them

public class Main {
    public static void main(String[] args) {
        Shape[] shapes = { new Circle(2), new Rectangle(3, 4) };

        for (Shape s : shapes) {
            s.describe();   // shared method calls each child's own area()
        }
    }
}

Abstract class vs interface

Both let you promise methods, but they answer different questions. Use this table to choose: