What is an Abstract Class in Java? | The Basics

Developer.com content and product recommendations are editorially independent. We may make money when you click on links to our partners. Learn More.

Java, one of the most popular programming languages, offers a wide range of features to support object-oriented programming (OOP). One of these key features is abstract classes, which play a pivotal role in designing and organizing complex Java applications. In this tutorial, we will delve into what abstract classes are, how they work, and when to use them in your Java projects. We will also explore practical code examples to solidify your understanding.

Understanding Abstraction

Before diving into abstract classes, it is crucial to grasp the concept of abstraction in object-oriented programming. Abstraction is the process of hiding the implementation details of an object and exposing only the necessary parts to the user. This allows for the creation of generic, reusable components.

For example, consider a simple case of a vehicle. When we talk about a vehicle, we are primarily interested in its common attributes like speed, direction, and fuel level. We do not need to be concerned with the intricate details of the engine or transmission system. This is abstraction in action.

You can learn more about the topic in our tutorial: What is Abstraction in Java?

What is an Abstract Class?

An abstract class in Java is a class that cannot be instantiated on its own. It serves as a blueprint for other classes and may contain one or more abstract methods. An abstract method is a method that is declared but does not have an implementation. Subclasses inheriting from an abstract class must implement these abstract methods.

In essence, an abstract class allows developers to define a common interface for a group of related classes, ensuring that they share a common set of methods. This promotes code reusability and helps in organizing a project’s class hierarchy.

Declaring an Abstract Class

To declare an abstract class in Java, you use the abstract keyword in the class declaration. Here is a simple code example showing how to declare an abstract class in Java:

abstract class Shape {
    int x, y;

    abstract void draw(); // Abstract method
}

In this example, the class Shape is declared as abstract using the abstract keyword. It contains an abstract method draw(). This method is declared without a body (i.e., no implementation details are provided), which means any subclass inheriting from Shape must provide an implementation for draw().

Abstract Methods in Java

Abstract methods are methods that are declared but not implemented in the abstract class. They serve as placeholders for functionality that must be implemented by subclasses. In an abstract class, you declare an abstract method by omitting the method body and using the abstract keyword:

abstract void draw();

Subclasses inheriting from an abstract class that contains abstract methods are required to provide concrete implementations for these methods.

Subclassing an Abstract Class

When you extend an abstract class, you have two options; you can either implement all the abstract methods defined in the abstract class, or you can declare your subclass as abstract as well. In the latter case, it is up to the next subclass in the hierarchy to provide implementations for the abstract methods.

Let’s illustrate this with an example:

abstract class Shape {
    int x, y;

    abstract void draw(); // Abstract method
}

class Circle extends Shape {
    int radius;

    @Override
    void draw() {
        // Implementation for drawing a circle
    }
}

In this example, the Circle class extends the abstract class Shape and provides an implementation for the draw() method. Now, Circle is a concrete class that can be instantiated.

When to Employ Abstract Subclasses

Abstract subclasses are useful for building functionality on objects that are not yet fully realized. For example, a Machine class would probably be too generic to instantiate. So too would a Vehicle. However, a Car, Truck, or Motorcycle would contain enough fine-grained details to exist as a concrete object:

abstract class Machine {
    int year;

    public Machine(int year) {
        this.year = year;
    }

    abstract void start(); // Abstract method
}

abstract class Vehicle extends Machine {
    int wheels;

    public Vehicle(int year, int wheels) {
        super(year);
        this.wheels = wheels;
    }

    abstract void accelerate(); // Abstract method
}

class Car extends Vehicle {
    String model;

    public Car(int year, int wheels, String model) {
        super(year, wheels);
        this.model = model;
    }

    @Override
    void start() {
        System.out.println("The car's engine is running.");
    }

    @Override
    void accelerate() {
        System.out.println("The car is accelerating.");
    }

    void honk() {
        System.out.println("Beep beep!");
    }
}

Read: Top Java Frameworks

Why Use Abstract Classes?

Abstract classes offer several benefits when it comes to designing and organizing Java applications:

1. Code Reusability: Abstract classes allow you to define a common interface for a group of related classes. This encourages code reusability, as subclasses inherit the common behavior defined in the abstract class.
2. Forcing Implementation: By declaring abstract methods, you ensure that any subclass must provide an implementation. This helps enforce a certain level of functionality across a group of related classes.
3. Organizing Class Hierarchies: Abstract classes provide a way to model hierarchies where some classes share common behavior but may also have unique characteristics. This helps in structuring complex applications.
4. Polymorphism: Abstract classes facilitate polymorphism. You can refer to a subclass object using a reference to the abstract class type. This allows you to write more flexible and generic code.

Practical Example: Shape Hierarchy

Let’s further illustrate the use of Java abstract classes with a practical example involving geometric shapes.

abstract class Shape {
    int x, y;

    abstract void draw(); // Abstract method
}

class Circle extends Shape {
    int radius;

    @Override
    void draw() {
        // Implementation for drawing a circle
    }
}

class Rectangle extends Shape {
    int width, height;

    @Override
    void draw() {
        // Implementation for drawing a rectangle
    }
}

class Triangle extends Shape {
    int base, height;

    @Override
    void draw() {
        // Implementation for drawing a triangle
    }
}

In this example, we have an abstract class Shape with an abstract method draw(). We then have concrete subclasses Circle, Rectangle, and Triangle that inherit from Shape and provide specific implementations for the draw() method.

By organizing our shapes in this way, we can treat them polymorphically. For instance, we can create an array of Shape objects and iterate through it, calling the draw() method for each shape. This allows us to draw circles, rectangles, and triangles using a common interface.

Final Thoughts on Abstract Classes in Java

Abstract classes are a powerful tool in Java’s object-oriented programming arsenal. They provide a means to define common behavior for a group of related classes and ensure that certain methods are implemented by subclasses. This promotes code reusability, helps organize class hierarchies, and facilitates polymorphism.

When designing your Java applications, consider using abstract classes in scenarios where you want to establish a common interface for a group of related classes. By doing so, you will create more modular, maintainable, and extensible code.