Abstract Classes

Intermediate ~30 min read

An abstract class is a class that cannot be instantiated directly. It's designed to be a base class that other classes extend. Abstract classes can contain both abstract methods (without implementation) and concrete methods (with implementation).

What is an Abstract Class?

An abstract class is declared with the abstract keyword. It represents an incomplete class that serves as a blueprint for subclasses.

abstract class Shape {
    String color;

    // Abstract method - no body, must be implemented by subclasses
    abstract double calculateArea();

    // Concrete method - has implementation
    void setColor(String color) {
        this.color = color;
    }
}

Key Characteristics:

Declared with abstract keyword
Cannot be instantiated (new Shape() is invalid)
Can have constructors (called by subclasses)
Can have both abstract and concrete methods
Can have instance variables

Abstract Methods

An abstract method has no body - just a declaration. Subclasses must provide an implementation.

abstract class Animal {
    // Abstract method - each animal sounds different
    abstract void makeSound();

    // Concrete method - all animals breathe the same way
    void breathe() {
        System.out.println("Breathing...");
    }
}

class Dog extends Animal {
    @Override
    void makeSound() {  // MUST implement abstract method
        System.out.println("Woof!");
    }
}

class Cat extends Animal {
    @Override
    void makeSound() {  // MUST implement abstract method
        System.out.println("Meow!");
    }
}

Rules for Abstract Methods:

No method body - ends with semicolon
Can only exist in abstract classes or interfaces
Cannot be final, static, or private
Subclasses must implement all abstract methods (or be abstract themselves)

Constructors in Abstract Classes

Abstract classes can have constructors. They are called when a subclass object is created.

abstract class Vehicle {
    String brand;
    int year;

    // Constructor in abstract class
    Vehicle(String brand, int year) {
        this.brand = brand;
        this.year = year;
        System.out.println("Vehicle constructor called");
    }

    abstract void start();
}

class Car extends Vehicle {
    int numDoors;

    Car(String brand, int year, int numDoors) {
        super(brand, year);  // Call abstract class constructor
        this.numDoors = numDoors;
        System.out.println("Car constructor called");
    }

    @Override
    void start() {
        System.out.println(brand + " car is starting");
    }
}

Concrete Methods in Abstract Classes

Abstract classes can provide default implementations that subclasses inherit or override:

abstract class Employee {
    String name;
    double baseSalary;

    Employee(String name, double baseSalary) {
        this.name = name;
        this.baseSalary = baseSalary;
    }

    // Abstract - different for each type
    abstract double calculateBonus();

    // Concrete - same for all employees
    double getTotalPay() {
        return baseSalary + calculateBonus();
    }

    // Concrete - can be overridden if needed
    void displayInfo() {
        System.out.println("Name: " + name);
        System.out.println("Total Pay: $" + getTotalPay());
    }
}

// Abstract class representing a shape
abstract class Shape {
    String color;
    String name;

// Constructor in abstract class
    Shape(String name, String color) {
        this.name = name;
        this.color = color;
        System.out.println("Shape constructor called for: " + name);
    }

// Abstract method - must be implemented by subclasses
    abstract double calculateArea();

// Abstract method
    abstract double calculatePerimeter();

// Concrete method - shared by all shapes
    void displayInfo() {
        System.out.println("Shape: " + name);
        System.out.println("Color: " + color);
        System.out.println("Area: " + calculateArea());
        System.out.println("Perimeter: " + calculatePerimeter());
    }

// Concrete method with default implementation
    void setColor(String color) {
        this.color = color;
    }
}

// Concrete class implementing all abstract methods
class Circle extends Shape {
    double radius;

Circle(String color, double radius) {
        super("Circle", color);  // Call abstract class constructor
        this.radius = radius;
    }

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

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

class Rectangle extends Shape {
    double width;
    double height;

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

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

@Override
    double calculatePerimeter() {
        return 2 * (width + height);
    }
}

class Triangle extends Shape {
    double base;
    double height;
    double side1, side2, side3;

Triangle(String color, double base, double height, double side1, double side2, double side3) {
        super("Triangle", color);
        this.base = base;
        this.height = height;
        this.side1 = side1;
        this.side2 = side2;
        this.side3 = side3;
    }

@Override
    double calculateArea() {
        return 0.5 * base * height;
    }

@Override
    double calculatePerimeter() {
        return side1 + side2 + side3;
    }
}

// Abstract class with template method pattern
abstract class Employee {
    String name;
    double baseSalary;

Employee(String name, double baseSalary) {
        this.name = name;
        this.baseSalary = baseSalary;
    }

// Abstract method - different for each employee type
    abstract double calculateBonus();

// Template method - uses abstract method
    double getTotalPay() {
        return baseSalary + calculateBonus();
    }

void displayPayInfo() {
        System.out.println("Employee: " + name);
        System.out.println("Base Salary: $" + baseSalary);
        System.out.println("Bonus: $" + calculateBonus());
        System.out.println("Total Pay: $" + getTotalPay());
    }
}

class Manager extends Employee {
    int teamSize;

Manager(String name, double baseSalary, int teamSize) {
        super(name, baseSalary);
        this.teamSize = teamSize;
    }

@Override
    double calculateBonus() {
        // Managers get 20% bonus plus $500 per team member
        return baseSalary * 0.20 + (teamSize * 500);
    }
}

class Developer extends Employee {
    int projectsCompleted;

Developer(String name, double baseSalary, int projectsCompleted) {
        super(name, baseSalary);
        this.projectsCompleted = projectsCompleted;
    }

@Override
    double calculateBonus() {
        // Developers get 15% bonus plus $1000 per project
        return baseSalary * 0.15 + (projectsCompleted * 1000);
    }
}

public class AbstractClasses {
    public static void main(String[] args) {
        System.out.println("=== Abstract Class: Shape Example ===\n");

// Cannot do: Shape shape = new Shape(); // Compile error!

// Create concrete subclass objects
        Shape circle = new Circle("Red", 5.0);
        Shape rectangle = new Rectangle("Blue", 4.0, 6.0);
        Shape triangle = new Triangle("Green", 3.0, 4.0, 3.0, 4.0, 5.0);

System.out.println("\n--- Shape Information ---\n");

circle.displayInfo();
        System.out.println();

rectangle.displayInfo();
        System.out.println();

triangle.displayInfo();

System.out.println("\n=== Polymorphism with Abstract Classes ===\n");

// Array of abstract type holding concrete objects
        Shape[] shapes = {circle, rectangle, triangle};

double totalArea = 0;
        for (Shape s : shapes) {
            totalArea += s.calculateArea();  // Calls appropriate implementation
        }
        System.out.println("Total area of all shapes: " + String.format("%.2f", totalArea));

System.out.println("\n=== Template Method Pattern: Employee Example ===\n");

Employee manager = new Manager("Alice", 80000, 5);
        Employee developer = new Developer("Bob", 70000, 3);

manager.displayPayInfo();
        System.out.println();
        developer.displayPayInfo();

System.out.println("\n=== Key Points ===");
        System.out.println("1. Abstract classes cannot be instantiated directly");
        System.out.println("2. Abstract methods have no body (just signature)");
        System.out.println("3. Concrete subclasses must implement all abstract methods");
        System.out.println("4. Abstract classes can have constructors");
        System.out.println("5. Abstract classes can have concrete methods too");
        System.out.println("6. Use abstract classes for IS-A with shared implementation");
    }
}

Output

Click Run to execute your code

When to Use Abstract Classes

Shared code among related classes: When subclasses share common code
Partial implementation: When you want to provide some default behavior but force subclasses to implement specific parts
Template method pattern: Define the skeleton of an algorithm, letting subclasses fill in the details
Access modifiers needed: When you need non-public methods (interfaces are implicitly public)
Instance variables: When you need to share state among subclasses

Abstract Class vs Interface

Abstract Class	Interface
Can have instance variables	Only constants (public static final)
Can have constructors	Cannot have constructors
Single inheritance only	Multiple implementation allowed
Any access modifier for methods	Methods are public by default
Use for IS-A relationship with shared code	Use for CAN-DO capability/behavior

Rule of Thumb: Use abstract classes when classes share code and state. Use interfaces when classes share behavior but not implementation.

Common Mistakes

Trying to instantiate an abstract class: new Animal() is a compile error
Forgetting to implement all abstract methods: Subclass must implement ALL abstract methods or be declared abstract itself
Making abstract methods private: Abstract methods must be accessible to subclasses
Overusing abstract classes: Consider interfaces for defining capabilities

Summary

Abstract classes cannot be instantiated directly
Abstract methods have no body and must be implemented by subclasses
Abstract classes can have constructors, instance variables, and concrete methods
Use abstract classes when you have shared code among related classes
A class that doesn't implement all abstract methods must itself be abstract

Previous Object Class

Next Interfaces