Java abstract Keyword
Usage and Examples

abstract Keyword in Java

The abstract keyword in Java is used to define abstract classes and abstract methods. These are essential components of Java's powerful object-oriented programming capabilities. If you're building a system where certain classes shouldn't be instantiated directly and must be extended, this keyword is your go-to tool.

What is an Abstract Class?

An abstract class is a class that cannot be instantiated. It's designed to be a blueprint for other classes. You can think of it as an incomplete class that other classes are expected to complete by extending it.

Syntax

abstract class Animal {
    // Fields and methods
}

Example

abstract class Animal {
    abstract void makeSound(); // abstract method

    void breathe() {
        System.out.println("Breathing...");
    }
}

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

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.makeSound();
        dog.breathe();
    }
}

Woof Woof!
Breathing...

Key Takeaways from the Example

• makeSound() is an abstract method, meaning it has no body in the Animal class.
• Subclasses like Dog are required to provide an implementation for the abstract method.
• breathe() is a regular method and can be inherited as-is.

Why Use Abstract Classes?

Abstract classes help you define a contract for subclasses. They are useful when you want multiple classes to share a common method signature but implement it differently.

What is an Abstract Method?

An abstract method is a method declared without a body, using the abstract keyword. It must be implemented by all non-abstract subclasses.

Abstract Method Syntax

abstract returnType methodName();

Abstract Class with Constructor

Abstract classes can have constructors, and they are invoked when a subclass is instantiated.

abstract class Shape {
    Shape() {
        System.out.println("Shape constructor called");
    }

    abstract void draw();
}

class Circle extends Shape {
    Circle() {
        System.out.println("Circle constructor called");
    }

    void draw() {
        System.out.println("Drawing Circle");
    }
}

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

Shape constructor called
Circle constructor called
Drawing Circle

Rules of Using abstract

• You cannot instantiate an abstract class.
• If a class has one or more abstract methods, it must be declared abstract.
• Subclasses must override all abstract methods or be declared abstract themselves.
• Abstract methods cannot have a body.
• Constructors, static methods, and final methods cannot be abstract.

Abstract Class vs Interface

Abstract Class	Interface
Can have method bodies	All methods are abstract by default (until Java 8+)
Can have constructors	Cannot have constructors
Supports access modifiers	Members are public by default
Can extend only one abstract class	Can implement multiple interfaces

Real-Life Example

Imagine you're building a payment system with different modes: credit card, UPI, PayPal. You could use an abstract class Payment with an abstract method process(). Each mode would implement this method in its own way.

abstract class Payment {
    abstract void process();
}

class CreditCardPayment extends Payment {
    void process() {
        System.out.println("Processing credit card payment");
    }
}

class UpiPayment extends Payment {
    void process() {
        System.out.println("Processing UPI payment");
    }
}