Abstract Class in Java

An abstract class in Java is a parent class that's deliberately left unfinished. It shares common code with its subclasses but leaves some methods for each subclass to fill in. You can't create an object of an abstract class directly. This guide shows how abstract classes work, the rules, and when to choose one over an interface.

What is an abstract class in Java?

Think of a form with some fields pre-filled and others left blank. Every copy shares the pre-filled parts, but each person must complete the blanks before it's valid. An abstract class is that form: the shared code is written once, and the blanks are abstract methods.

public abstract class Notification {
    private final String recipient;

    protected Notification(String recipient) {
        this.recipient = recipient;
    }

    // Shared, finished behaviour
    public void send(String message) {
        System.out.println("Sending to " + recipient + " via " + channel());
        deliver(message);
    }

    // The "blanks" each subclass must fill in
    protected abstract String channel();
    protected abstract void deliver(String message);
}

• abstract class — marks the class as unfinished; new Notification(...) is not allowed.
• protected abstract void deliver(...) — an abstract method: a signature with no body, ending in a semicolon.
• send(...) — a normal method. Every subclass inherits it as-is.

Let's see it in action: extending an abstract class

Each subclass fills in the blanks in its own way:

public class EmailNotification extends Notification {
    public EmailNotification(String address) {
        super(address);
    }

    @Override
    protected String channel() { return "email"; }

    @Override
    protected void deliver(String message) {
        System.out.println("  [SMTP] " + message);
    }
}

public class SmsNotification extends Notification {
    public SmsNotification(String phone) {
        super(phone);
    }

    @Override
    protected String channel() { return "SMS"; }

    @Override
    protected void deliver(String message) {
        String shortMsg = message.length() > 22 ? message.substring(0, 22) + "…" : message;
        System.out.println("  [SMS] " + shortMsg);
    }
}

Notification[] alerts = {
    new EmailNotification("asha@example.com"),
    new SmsNotification("+94 77 123 4567")
};

for (Notification n : alerts) {
    n.send("Your order has shipped and will arrive Friday");
}

Sending to asha@example.com via email
  [SMTP] Your order has shipped and will arrive Friday
Sending to +94 77 123 4567 via SMS
  [SMS] Your order has shipped…

The loop treats both objects as a plain Notification, yet each one behaves differently. The shared send() logic was written once. This pattern, where a parent defines the steps and children fill in the details, is called the template method pattern.

What are the rules for abstract classes?

Abstract class vs interface in Java

This is one of the most common Java interview questions. Here's the practical difference:

Where do you see abstract classes in real Java code?

• java.util.AbstractList — implement just get() and size() and you get a working read-only List.
• java.io.InputStream — subclasses only have to implement the single-byte read() method.
• Framework base classes, such as HttpServlet in Jakarta EE, which you extend and override.

Quick recap

What's next?

Learn the more flexible alternative in Java interfaces, or revisit how inheritance in Java works.