Abstract Class in Java - Shared Base Classes and Abstract Methods

⏱️ 23 min read • Beginner Level • Lesson 57

An abstract class in Java is an incomplete base class designed to be extended. It can define required behavior for child classes while also sharing fields, constructors, and implemented methods.

Abstract classes are useful when related classes have common state or implementation but must provide different versions of one or more operations. They support abstraction, inheritance, code reuse, and runtime polymorphism.

What Is an Abstract Class in Java?

A class declared with the abstract keyword is called an abstract class. It cannot be instantiated directly. Instead, another class extends it and completes any required abstract behavior.

Abstract Class Syntax

abstract class ClassName {
    abstract void abstractMethod();

    void concreteMethod() {
        // implemented behavior
    }
}

Why Use an Abstract Class?

Basic Abstract Class Example

abstract class Animal {
    private final String name;

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

    String getName() {
        return name;
    }

    abstract void makeSound();

    void sleep() {
        System.out.println(name + " is sleeping");
    }
}

class Dog extends Animal {
    Dog(String name) {
        super(name);
    }

    @Override
    void makeSound() {
        System.out.println(getName() + " says Woof");
    }

    public static void main(String[] args) {
        Animal animal = new Dog("Bruno");
        animal.makeSound();
        animal.sleep();
    }
}

Output:

Bruno says Woof
Bruno is sleeping

Abstract Methods

An abstract method defines a required operation but leaves its implementation to a child class. A concrete child must implement inherited abstract methods unless a suitable implementation is already inherited.

Concrete Methods in an Abstract Class

An abstract class may provide fully implemented methods. This is one of its main advantages when related child classes need common behavior.

abstract class Document {
    abstract void printBody();

    final void printHeader() {
        System.out.println("ProwessApps Document");
    }

    static void showFormat() {
        System.out.println("Format: Digital");
    }
}

Constructor in an Abstract Class

Although an abstract class cannot be instantiated directly, it can have constructors. A child constructor invokes the parent constructor to initialize the inherited part of the object.

abstract class Employee {
    private final String name;

    Employee(String name) {
        this.name = name;
        System.out.println("Employee constructor");
    }

    String getName() {
        return name;
    }

    abstract double calculateSalary();
}

class FullTimeEmployee extends Employee {
    private final double monthlySalary;

    FullTimeEmployee(String name, double monthlySalary) {
        super(name);
        this.monthlySalary = monthlySalary;
    }

    @Override
    double calculateSalary() {
        return monthlySalary;
    }

    public static void main(String[] args) {
        Employee employee =
                new FullTimeEmployee("Ayan", 50000);

        System.out.println(employee.getName());
        System.out.println(employee.calculateSalary());
    }
}

Output:

Employee constructor
Ayan
50000.0

Fields and Shared State

Abstract classes may contain instance fields and static fields. Use private fields with controlled methods when shared state must remain protected.

Abstract Class References

While an abstract class cannot produce an object directly, its reference type can point to a concrete child object. This supports runtime polymorphism.

abstract class Payment {
    abstract void pay(double amount);
}

class CardPayment extends Payment {
    @Override
    void pay(double amount) {
        System.out.println("Card payment: ₹" + amount);
    }
}

class ReferenceExample {
    public static void main(String[] args) {
        Payment payment = new CardPayment();
        payment.pay(1200);
    }
}

Output:

Card payment: ₹1200.0

Multilevel Abstract Classes

An abstract child class does not need to implement every inherited abstract method. It can refine the hierarchy and leave remaining work to a later concrete subclass.

abstract class Device {
    abstract void start();
}

abstract class MobileDevice extends Device {
    abstract void makeCall();
}

class Smartphone extends MobileDevice {
    @Override
    void start() {
        System.out.println("Smartphone starts");
    }

    @Override
    void makeCall() {
        System.out.println("Calling a contact");
    }
}

Abstract Class Implementing an Interface

An abstract class may implement an interface without implementing every abstract interface method. A concrete child must complete the remaining contract.

interface Exportable {
    void export();
    void validate();
}

abstract class Report implements Exportable {
    @Override
    public void validate() {
        System.out.println("Report validated");
    }
}

class PdfReport extends Report {
    @Override
    public void export() {
        System.out.println("PDF exported");
    }

    public static void main(String[] args) {
        Exportable report = new PdfReport();
        report.validate();
        report.export();
    }
}

Output:

Report validated
PDF exported

Important Abstract Class Rules

Abstract Class vs Concrete Class

Abstract Class vs Interface

When Should You Use an Abstract Class?

Tricky Cases

1. Can an abstract class have no abstract method?

2. Can an abstract class be final?

3. Can an abstract class have a private constructor?

4. Can an abstract class have a main() method?

5. Can an abstract class have final methods?

6. Can a constructor be abstract?

7. Can an abstract class extend a concrete class?

Common Mistakes

Interview Questions ⭐

Test your understanding with a quick quiz

abstract class Parent {
    Parent() {
        System.out.println("Parent");
    }
}

class Child extends Parent {
    Child() {
        System.out.println("Child");
    }

    public static void main(String[] args) {
        new Child();
    }
}

abstract class Animal {
    abstract void sound();
}

class Dog extends Animal {
    void sound() {
        System.out.println("Woof");
    }

    public static void main(String[] args) {
        Animal animal = new Dog();
        animal.sound();
    }
}

abstract class Animal {
    abstract void sound();
}

class Dog extends Animal {
}

Great job! Continue learning Java OOP step by step.