Developer.com content and product recommendations are editorially independent. When you click on links to our partners, we may earn money. learn more.
Java, one of the most popular programming languages, offers a wide range of features that support object-oriented programming (OOP). One of these key features is abstract classes, which play a vital role in the design and organization of complex Java applications. This tutorial provides a detailed explanation of what abstract classes are, how they work, and when to use them in Java projects. We will also consider real code examples for better understanding.
understand abstraction
Before getting into abstract classes, it is important to understand 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 the simple case of a vehicle. When we talk about vehicles, we are primarily interested in common attributes such as speed, direction, and fuel level. You don’t have to worry about the intricate details of your engine or transmission system. This is a real abstraction.
For more information on this topic, see the tutorial “What is Java abstraction?”
What is an abstract class?
An abstract class in Java is a class that cannot be instantiated by itself. It serves as a blueprint for other classes and can contain one or more abstract methods. Abstract methods are methods that are declared but not implemented. Subclasses that inherit from an abstract class must implement these abstract methods.
Essentially, abstract classes allow developers to define a common interface for a group of related classes so that they share a common set of methods. This promotes code reuse and helps organize your project’s class hierarchy.
Abstract class declaration
To declare an abstract class in Java, abstract Keywords within class declarations. Here is a simple code example that shows how to declare an abstract class in Java.
abstract class Shape
int x, y;
abstract void draw(); // Abstract method
In this example, the class is Shape is declared abstract using abstract keyword.Contains abstract methods draw(). This method is declared without a body (that is, no implementation details are provided). This means subclasses inheriting methods. Shape You must provide an implementation of draw().
Java abstract methods
Abstract methods are methods that are declared but not implemented in an abstract class. These serve as placeholders for functionality that must be implemented by subclasses. Abstract classes omit method bodies, abstract keyword:
abstract void draw();
Subclasses that inherit an abstract class that contains abstract methods must provide concrete implementations of those methods.
Subclassing an abstract class
When extending an abstract class, you have two options. You can implement all abstract methods defined in an abstract class, or you can declare subclasses as abstract as well. In the latter case, it is the next subclass in the hierarchy that provides the implementation of the abstract method.
Let’s explain 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, Circle class extends an abstract class Shape provides an implementation. draw() Method. now, Circle A concrete class that can be instantiated.
When to use abstract subclasses
Abstract subclasses are useful for building functionality of an object that is not yet fully realized. for example, machine Perhaps the class is too generic to be instantiated. Similarly, vehicle. however, car, truckor motorcycle Contains enough detail 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 have several advantages when it comes to designing and organizing Java applications.
- Code reusability: Abstract classes allow you to define a common interface for a group of related classes. This promotes code reuse as subclasses inherit common behavior defined in the abstract class.
- Forced implementation: When you declare an abstract method, all subclasses must provide an implementation. This is useful for applying some level of functionality across a group of related classes.
- Organizing the class hierarchy: Abstract classes provide a way to model hierarchies where some classes share common behavior but may have unique characteristics. This is useful for building complex applications.
- Polymorphism: Abstract classes encourage polymorphism. A reference to an abstract class type can be used to reference subclass objects. This allows you to write more flexible and generic code.
Practical example: shape hierarchy
Let’s further explain the usage of Java abstract classes using a real-world 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 using abstract methods draw().Then you can have a concrete subclass Circle, Rectangleand Triangle inherit from Shape Provides a concrete implementation. draw() Method.
By organizing shapes in this way, you can treat them polymorphically. For example, you can create the following array: Shape Call the object, iterate over it, draw() This is a method for each shape. This allows you to draw circles, rectangles, and triangles using a common interface.
Final thoughts on abstract classes in Java
Abstract classes are a powerful tool in object-oriented programming in Java. They define common behavior for a group of related classes and provide a means to ensure that certain methods are implemented by subclasses. This promotes code reusability, facilitates the organization of class hierarchies, and promotes polymorphism.
When designing Java applications, consider using abstract classes in scenarios where you want to establish a common interface for a group of related classes. Doing so allows you to write more modular, maintainable, and extensible code.
