Abstraction and Abstract Classes

Declaring an Abstract Class

An abstract class can contain a mix of abstract methods (declared without a body, ending in a semicolon) and concrete methods (with a full implementation). It can also have constructors, fields, and static methods, even though it can never be instantiated directly with new.

• An abstract class is declared with the abstract keyword before class.
• It can have zero or more abstract methods — even zero is legal, though unusual.
• It can have fully implemented (concrete) methods that subclasses inherit as-is.
• You cannot write new AbstractClassName(); the compiler rejects it.

Extending an Abstract Class

A concrete (non-abstract) subclass must implement every abstract method it inherits, or the compiler forces it to also be declared abstract. This guarantees that by the time an object is actually created, every abstract method has a real implementation somewhere in the hierarchy.

Why Use Abstraction

Abstract classes let you share common code and fields across related classes while still forcing each subclass to supply its own specific behavior for the parts that must differ. This keeps a common contract in one place instead of duplicating it, and lets you write code against the abstract type so it works with any future subclass.

Example

abstract class Shape {
    String name;

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

    // Concrete method — shared by every subclass
    void describe() {
        System.out.println(name + " has area " + area());
    }

    // Abstract method — each subclass must define this
    abstract double area();
}

class Circle extends Shape {
    double radius;

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

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

public class AbstractionDemo {
    public static void main(String[] args) {
        Shape s = new Circle(2.0);
        s.describe();
    }
}

Circle has area 12.566370614359172

Exercise

Complete the two subclasses of the abstract Employee. A full-time employee is paid a fixed salary; a contractor is paid hours multiplied by an hourly rate.

Expected output: Pay: 50000 then Pay: 30000

abstract class Employee {
    abstract int pay();

    String describe() {
        return "Pay: " + pay();
    }
}

// TODO: class FullTime extends Employee, constructed with a salary
// TODO: class Contractor extends Employee, constructed with hours and a rate

public class PayrollDemo {
    public static void main(String[] args) {
        Employee[] staff = { new FullTime(50000), new Contractor(100, 300) };
        for (Employee employee : staff) {
            System.out.println(employee.describe());
        }
    }
}

abstract class Employee {
    abstract int pay();

    String describe() {
        return "Pay: " + pay();
    }
}

class FullTime extends Employee {
    private final int salary;

    FullTime(int salary) {
        this.salary = salary;
    }

    @Override
    int pay() {
        return salary;
    }
}

class Contractor extends Employee {
    private final int hours;
    private final int rate;

    Contractor(int hours, int rate) {
        this.hours = hours;
        this.rate = rate;
    }

    @Override
    int pay() {
        return hours * rate;
    }
}

public class PayrollDemo {
    public static void main(String[] args) {
        Employee[] staff = { new FullTime(50000), new Contractor(100, 300) };
        for (Employee employee : staff) {
            System.out.println(employee.describe());
        }
    }
}

Quick quiz

Interview questions