Adapter Class in Java: Practical Guide with Examples

Have you ever needed to charge your phone while you’re traveling in a car? What do you do? You use a car charger adapter that converts the 12V cigarette lighter socket into a USB port, allowing you to charge your phone effortlessly.

In Java, an adapter class works the same way—it bridges the gap between two incompatible systems, allowing them to work together seamlessly. Whether you’re dealing with legacy systems or integrating third-party libraries, the adapter ensures everything functions as intended, just like your car charger adapter!

Understanding this concept of bridging incompatible systems will definitely make you a standout in the tech world. It will open doors to high-demand roles in cybersecurity, data science, and software development. 

Ready to level up your programming career? Dive into this practical guide and start augmenting your knowledge and skills.

What is an Adapter Class in Java?

An adapter class in Java is a design pattern used to allow two incompatible interfaces to work together. It acts as a middleman that converts the interface of a class into another interface that the client expects. Instead of rewriting code or forcing classes to match, the adapter class simplifies integration and makes systems more flexible.

Adapter classes are often used in situations where you're dealing with abstract classes or interfaces that have multiple methods. By creating an adapter, you don't need to implement every method in the interface. Instead, you can extend an existing class and override only the methods you need. This makes the code cleaner and more efficient.

Here are a few key features of adapter class:

• Implements interfaces or extends abstract classes with multiple methods
• Provides default empty method implementations
• Can be used to make legacy systems compatible with new ones
• Simplifies handling of complex interfaces by only focusing on necessary methods

Also Read: Abstract Class vs Interface: The Differences and the Similarities | upGrad blog

Why Use Adapter Class?

When working with interfaces that contain multiple methods, you often end up implementing methods that aren't relevant to your task. An adapter class offers a cleaner solution by allowing you to implement only the methods you need, simplifying your code.

Common challenges with interfaces containing multiple methods:

• Unnecessary code complexity.
• Forced implementation of irrelevant methods.

How adapter classes simplify your code:

• Makes your code more readable, maintainable, and less prone to errors.
• You only implement the methods you actually need, cutting down on unnecessary code.

Real-world scenarios where adapter classes are helpful:

• Adapting custom UI components to fit into a predefined framework.
• Integrating legacy systems with modern applications without major rewrites.
• Using third-party libraries with incompatible methods, without needing to modify the library code.

Adapter classes aren't just a convenience—they’re a powerful tool that helps you streamline development and work more efficiently.

Also Read: Java Tutorial: Learn Java Programming From Scratch For Beginners

Now that you know what is adapter class is, let's dive into some common types of adapter classes.

What are the Different Types of Adapter Classes in Java? 

An adapter class in Java is used in various libraries to simplify event handling. These classes act as intermediaries between events and listeners, making it easier to implement only the methods you need. 

Let’s explore some common types of adapter classes.

 java.awt.event adapter classes

In Java’s AWT (Abstract Window Toolkit), adapter classes help manage common events like mouse clicks, key presses, and window actions. These classes implement the corresponding listener interfaces and offer default empty implementations, so you only need to override the methods you need.

Examples:

• MouseAdapter handles mouse events.
• KeyAdapter handles keyboard events.

Now, let's see the table for these adapter classes and their associated listener interfaces:

Explanation: These adapter classes make it easier to handle events by providing default methods for each listener interface. You only need to override the specific methods that your program requires, which reduces code clutter and complexity.

java.awt.dnd adapter classes

Drag-and-drop events are managed by the java.awt.dnd package. The adapter classes here simplify the handling of these events, letting you focus on the relevant actions like dragging and dropping items.

Examples:

• DragSourceAdapter for drag actions.
• DropTargetAdapter for drop events.

Here’s a table showing these adapter classes and their corresponding listener interfaces:

Explanation: These adapter classes are specifically designed to handle drag-and-drop events. They provide default implementations of the DragSourceListener and DropTargetListener interfaces, so you only need to focus on the methods that are necessary for your application.

 javax.swing.event adapter classes

For Swing-based applications, adapter classes help manage events in GUI components. These classes make it easier to work with user interface events without dealing with every single method in the listener interfaces.

Examples:

• MouseAdapter for handling mouse actions in Swing.
• WindowAdapter for managing window events in Swing-based applications.

Let’s take a closer look at how these adapter classes are mapped to their listener interfaces:

These adapter classes are key in reducing complexity, ensuring that you only implement the necessary event methods while maintaining a clean, readable codebase.

Also Read: Java Swing Project: Properties, Advantages & Frameworks | upGrad blog

Now that you know what is adapter class and its different types, let's go through the process step by step.

How to Create an Adapter Class in Java?

Creating your own adapter class in Java is a straightforward process. It allows you to bridge the gap between incompatible interfaces by overriding only the methods you need. Let’s walk through how to write a custom adapter class.

Here’s a step-by-step guide:

1. Define the interface: First, you need an interface with multiple methods. This is the interface you want to adapt.
2. Create the Adapter Class: Next, create a class that implements the interface. Instead of implementing every method, you can simply extend an existing adapter class and override only the relevant methods.
3. Override the Necessary Methods: You’ll override only the methods that your program needs, leaving others as default (empty).
4. Use the Adapter Class: Finally, use the custom adapter class in your program, passing it wherever the interface is required.

Example: Creating a Custom Adapter Class

Let’s say you have a custom interface called ShapeListener that defines methods for handling shape events like onDraw and onResize.

// Step 1: Define the Interface
interface ShapeListener {
    void onDraw();
    void onResize();
}

// Step 2: Create the Adapter Class
class ShapeAdapter implements ShapeListener {
    @Override
    public void onDraw() {
        // Default empty implementation
    }

    @Override
    public void onResize() {
        // Default empty implementation
    }
}

// Step 3: Use the Adapter Class
public class MyApp {
    public static void main(String[] args) {
        ShapeListener listener = new ShapeAdapter() {
            @Override
            public void onDraw() {
                System.out.println("Drawing a shape!");
            }
        };

        listener.onDraw();  // Output: Drawing a shape!
}
}

Explanation: In this example, ShapeAdapter implements the ShapeListener interface. Instead of implementing both methods, it provides default (empty) implementations for onDraw and onResize. In the MyApp class, you create an anonymous subclass of ShapeAdapter to override only the method you need—in this case, onDraw. This keeps the code clean and avoids unnecessary method implementations.

Also Read: 22 Best Java Project Ideas & Topics For Beginners With Source Code 2024 [Latest]

Adapter classes are particularly useful when you want to handle specific events without dealing with unnecessary methods. Let’s look at some examples to understand how these adapter classes simplify event handling.

How Are Adapter Classes Used in Java? Examples Explained

To see how adapter classes work in action, let's explore a few practical examples. Each of these will demonstrate how adapter classes help simplify event handling in Java.

Example 1: Using WindowAdapter Class

Overview of the Class: The WindowAdapter class provides default implementations for all the methods in WindowListener. This allows you to focus on the specific event you want to handle, such as window closing.

Example Code:

import java.awt.event.*;

public class WindowExample {
    public static void main(String[] args) {
Frame frame = new Frame("Window Example");

        // Using windowadapter to handle only windowClosing event
        frame.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                System.out.println("Window is closing...");
                System.exit(0);
            }
        });

        frame.setSize(300, 200);
        frame.setVisible(true);
    }
}

Explanation: In this example, the WindowAdapter class is used to handle the windowClosing event. Instead of implementing all the methods in WindowListener, you override just the method you need. This makes the code simpler and cleaner.

Example 2: Using KeyAdapter Class

The KeyAdapter class simplifies handling keyboard events. It implements the KeyListener interface and provides default empty implementations for all the methods, allowing you to focus only on the key events you care about.

Overview of the class: KeyAdapter provides default implementations for keyPressed(), keyReleased(), and keyTyped(). You can override just the ones that are necessary for your application.

Example Code:

import java.awt.event.*;

public class KeyEventExample {
    public static void main(String[] args) {
Frame frame = new Frame("Key Event Example");

        // Using keyadapter to handle keyPressed event
        frame.addKeyListener(new KeyAdapter() {
            @Override
            public void keyPressed(KeyEvent e) {
                System.out.println("Key pressed: " + e.getKeyChar());
            }
        });

        frame.setSize(300, 200);
        frame.setVisible(true);
    }
}

Explanation: Here, the KeyAdapter class is used to listen for key presses. By overriding just keyPressed(), you avoid the need to implement unnecessary methods, keeping the code focused and efficient.

Example 3: Using MouseMotionAdapter Class

The MouseMotionAdapter class is used to handle mouse movement events, such as when the mouse is moved or dragged across the screen. Like the other adapter classes, it provides default implementations for the MouseMotionListener interface.

Overview of the class: MouseMotionAdapter simplifies the handling of mouse movement events by providing empty implementations of methods like mouseMoved() and mouseDragged(). You only need to override the methods that are relevant.

Example Code:

import java.awt.event.*;

public class MouseMotionExample {
    public static void main(String[] args) {
        Frame frame = new Frame("Mouse Motion Example");// Using mousemotionadapter to handle mouseMoved event
        frame.addMouseMotionListener(new MouseMotionAdapter() {
            @Override
            public void mouseMoved(MouseEvent e) {
                System.out.println("Mouse moved to: (" + e.getX() + ", " + e.getY() + ")");
            }
        });

        frame.setSize(300, 200);
        frame.setVisible(true);
    }
}

Explanation: In this example, you use MouseMotionAdapter to track mouse movements. By overriding just the mouseMoved() method, you keep the code concise and relevant, without implementing the entire MouseMotionListener interface.

These examples highlight how adapter classes help reduce boilerplate code, making event handling in Java easier and more manageable.

Also Read: Top 8 Reasons Why Java Is So Popular and Widely Used in 2025

Adapter classes and object adapters both serve to bridge incompatible interfaces, but they do so in different ways. Let’s dive into the key differences.

What is the Difference Between Adapter Class and Object Adapter?

Both the adapter class and object adapter are design patterns used to make incompatible interfaces work together. However, they have key differences in how they function.

Here’s a table differentiating the two:

Example Code: Using Adapter Class in Java

In this example, we’ll use an adapter class to implement a Shape interface that has multiple methods. We’ll create an adapter class for Rectangle that only overrides the methods you need.

Step 1: Define the Shape interface

interface Shape {
    void draw();  // method to draw the shape
    void resize();  // method to resize the shape
    void color();  // method to color the shape
}

Step 2: Create an adapter class that implements Shape

// Adapter class that implements Shape but provides default behavior for unused methods
class ShapeAdapter implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a rectangle.");
    }

    @Override
    public void resize() {
        // Default implementation can be left empty
    }

    @Override
    public void color() {
        // Default implementation can be left empty
    }
}

Step 3: Use the adapter class in your program

public class AdapterExample {
    public static void main(String[] args) {
        Shape rectangle = new ShapeAdapter();
        rectangle.draw();  // Output: Drawing a rectangle.
}
}

Explanation:

• The ShapeAdapter class implements the Shape interface, but it only overrides the draw method, as it's the only one you need.
• The resize and color methods have default (empty) implementations because they aren't required in this scenario.
• This allows you to simplify the code and handle only the relevant methods.

This is a basic demonstration of how an adapter class simplifies interface implementation by overriding only the methods that are needed, making your code cleaner and more focused.

Example Code: Using Object Adapter in Java

Let’s assume you need to adapt a MediaPlayer interface to work with an existing AudioPlayer class that has its own method for playing audio.

Step 1: Define the MediaPlayer interface

interface MediaPlayer {
    void play();
}

Step 2: Define the AudioPlayer class with its own method

class AudioPlayer {
    public void playAudio() {
        System.out.println("Playing audio...");
    }
}

Step 3: Create the Object Adapter that adapts the AudioPlayer class to the MediaPlayer interface

// Object Adapter
class MediaAdapter implements MediaPlayer {
    private AudioPlayer audioPlayer;

    public MediaAdapter(AudioPlayer audioPlayer) {
        this.audioPlayer = audioPlayer;
    }

    @Override
    public void play() {
        audioPlayer.playAudio();  // Adapting the playAudio method to play method
    }
}

Step 4: Use the adapter class in your program

public class AdapterExample {
    public static void main(String[] args) {
        AudioPlayer audioPlayer = new AudioPlayer();
        MediaPlayer mediaPlayer = new MediaAdapter(audioPlayer);  // Pass the AudioPlayer to the adapter
        mediaPlayer.play();  // Output: Playing audio...
    }
}

Explanation:

• In this example, the MediaAdapter class does not extend the AudioPlayer class. Instead, it contains an instance of AudioPlayer and delegates the play method call to audioPlayer.playAudio().
• This is a typical example of object composition where the adapter class adapts one interface (MediaPlayer) to another (AudioPlayer) without using inheritance.

This approach gives you more flexibility, as the adapter can delegate calls to different classes based on the context.

Both the adapter class and object adapter patterns serve to bridge incompatible interfaces, but they do so in different ways. While class adapters use inheritance to extend a class, object adapters rely on composition, making them more flexible and reusable across different scenarios. 

Also Read: Design Patterns: Singleton in Java

Understanding these distinctions is crucial for choosing between an adapter class and a listener interface, depending on your use case complexity and control needs. 

upGrad’s Exclusive Software and Tech Webinar for you –

SAAS Business – What is So Different?

What is the Difference Between an Adapter Class in Java and a Listener Interface?

Both the adapter class and listener interface are used to handle events in Java, but they differ in their purpose, complexity, and how they are implemented. Understanding the key differences can help you choose the right approach for your specific needs.

Here’s a table differentiating the approaches:

Explanation: An adapter class is perfect when you want to handle only a few methods of a larger interface without having to implement the entire interface. It reduces code complexity and makes event handling easier. 

On the other hand, a listener interface gives you full control over all methods but requires more effort and leads to more code. Both approaches have their uses, depending on whether you need simplicity or full customization.

Also Read: Ultimate Guide to Synchronization in Java

However, to understand when and why to use an adapter class, it's important to weigh its advantages and limitations.

What are the Pros and Cons of an Adapter Class in Java? 

The adapter class pattern simplifies event handling by providing default method implementations, allowing you to override only the ones you need. However, like any design pattern, it comes with both benefits and limitations.

Here is a list of pros:

• Enhanced code readability: By reducing the need to implement unused methods, the code becomes cleaner and easier to read.
• Reduced complexity in event handling: With default method implementations, you don’t have to implement every method, making event handling more manageable.
• Flexibility for developers: The adapter class offers flexibility by allowing you to handle only the relevant methods for your use case, while ignoring unnecessary ones.

Here is a list of cons:

• Lack of support for multiple interface implementations: The adapter class can only extend one class, limiting its ability to implement multiple interfaces.
• Increased inheritance depth: In cases where multiple adapter classes are used, inheritance depth can increase, leading to more complex hierarchies.

The adapter class is useful when you want to streamline event handling or interface integration, but it may not be the best option in situations requiring flexibility across multiple interfaces.

As you explore the power of adapter classes and dive deeper into Java programming, the next step is to ensure you're equipped with the right skills to thrive in the industry.

How Can upGrad Help You Build a Career in Programming?

To succeed in the tech world, continuous learning is key. With upGrad, you gain access to one of the leading online learning platforms, trusted by over 10 million learners globally. Choose from 200+ industry-relevant courses and connect with over 1,400 hiring partners to help you land your ideal job. 

Whether you're looking to sharpen your coding skills or dive deeper into specialized fields, upGrad offers the right programming courses to help you achieve your career goals. If you're an aspiring tech professional in India, these courses will set you on the path to success.

Here’s a quick look at some of the relevant programming courses offered by upGrad:

Need help choosing what’s right for your career goals? upGrad offers free one-on-one expert career counseling sessions to help you define your goals, match your skills with the right opportunities, and create a roadmap for long-term success.

Boost your career with our popular Software Engineering courses, offering hands-on training and expert guidance to turn you into a skilled software developer.

Master in-demand Software Development skills like coding, system design, DevOps, and agile methodologies to excel in today’s competitive tech industry.

Stay informed with our widely-read Software Development articles, covering everything from coding techniques to the latest advancements in software engineering.

Build your foundation in software development with our Free Courses – practical, beginner-friendly, and 100% free!