 (10).png)
Adapter Design Pattern in Java
Introduction
In real-world software development, you often encounter situations where two incompatible interfaces need to work together. The Adapter Pattern solves this problem by acting as a bridge between incompatible interfaces, allowing them to collaborate without changing existing code.
Think of it like an electrical plug adapter: your device has a plug type that doesn’t fit the socket, so you use an adapter to connect it safely and effectively. Similarly, the Adapter Pattern allows classes with incompatible interfaces to interact seamlessly.
Definition
The Adapter Pattern is a structural design pattern that allows objects with incompatible interfaces to work together. It wraps one object and provides a compatible interface to the client.
Key Idea: Convert the interface of a class into another interface that a client expects.
When to Use the Adapter Pattern
- You have existing classes that cannot be modified.
- You need compatibility between old and new interfaces.
- You want to reuse a class but its interface does not match the client’s requirements.
Real-World Example
- Mobile Charger: A charger has a USB-C connector, but the wall socket accepts a different type. The adapter converts the USB-C interface to the socket interface.
- Legacy API Integration: Your system uses a modern payment interface, but the old payment gateway has a different API. An adapter bridges them.
Java Implementation
Let’s implement an Adapter Pattern for a media player scenario:
Step 1: Define the Target Interface
// Target interface expected by client
interface MediaPlayer {
void play(String audioType, String fileName);
}
Step 2: Define the Adaptee (Existing Class)
// Existing class with incompatible interface
class AdvancedMediaPlayer {
void playMp4(String fileName) {
System.out.println("Playing MP4 file: " + fileName);
}
void playVlc(String fileName) {
System.out.println("Playing VLC file: " + fileName);
}
}
Step 3: Create the Adapter
// Adapter class to bridge MediaPlayer and AdvancedMediaPlayer
class MediaAdapter implements MediaPlayer {
private AdvancedMediaPlayer advancedPlayer;
public MediaAdapter(String audioType) {
advancedPlayer = new AdvancedMediaPlayer();
}
@Override
public void play(String audioType, String fileName) {
if (audioType.equalsIgnoreCase("mp4")) {
advancedPlayer.playMp4(fileName);
} else if (audioType.equalsIgnoreCase("vlc")) {
advancedPlayer.playVlc(fileName);
} else {
System.out.println("Format not supported: " + audioType);
}
}
}
Step 4: Create the Client
// Client class using the MediaPlayer interface
class AudioPlayer implements MediaPlayer {
private MediaAdapter adapter;
@Override
public void play(String audioType, String fileName) {
if (audioType.equalsIgnoreCase("mp3")) {
System.out.println("Playing MP3 file: " + fileName);
} else if (audioType.equalsIgnoreCase("mp4") || audioType.equalsIgnoreCase("vlc")) {
adapter = new MediaAdapter(audioType);
adapter.play(audioType, fileName);
} else {
System.out.println("Invalid media format: " + audioType);
}
}
}
Step 5: Test the Implementation
public class Main {
public static void main(String[] args) {
AudioPlayer player = new AudioPlayer();
player.play("mp3", "song1.mp3"); // Native format
player.play("mp4", "video1.mp4"); // Adapter used
player.play("vlc", "movie1.vlc"); // Adapter used
player.play("avi", "clip1.avi"); // Unsupported format
}
}
Output:
Playing MP3 file: song1.mp3
Playing MP4 file: video1.mp4
Playing VLC file: movie1.vlc
Invalid media format: avi
Advantages of Adapter Pattern
- Reusability: Allows existing classes to be reused without modification.
- Flexibility: Clients can work with multiple incompatible interfaces transparently.
- Separation of Concerns: Keeps adapter logic separate from client and adaptee classes.
- Scalability: New adapters can be added without changing client code.
Disadvantages
- Extra Layer: Introduces additional objects in the system, adding slight complexity.
- Overhead: Can become cumbersome if too many adapters are required.
- Limited Control: Adapter only converts interface; it doesn’t enhance underlying functionality.
Summary
The Adapter Pattern is an essential structural pattern in Java that bridges incompatible interfaces. It allows seamless integration of legacy systems, third-party libraries, or multiple APIs. By following this pattern, developers achieve flexibility, reusability, and maintainable code.
Next, we will explore the Bridge Pattern, which focuses on decoupling abstraction from implementation, allowing both to evolve independently.
 (17).png)
.png)
 (18).png)
.png)
.png)
 (1).png)
 (2).png)
 (3).png)
 (4).png)
 (5).png)
 (6).png)
 (9).png)
 (7).png)
 (8).png)
 (10).png)
 (12).png)
 (13).png)
 (13).png)
 (15).png)
 (16).png)
 (19).png)
 (20).png)
 (21).png)
 (22).png)
 (23).png)
 (24).png)
 (25).png)
 (26).png)
 (27).png)
 (28).png)
 (29).png)
 (30).png)
 (31).png)
 (32).png)
 (33).png)
 (34).png)
 (35).png)
 (36).png)
 (37).png)
 (38).png)
 (39).png)
