In the fast-paced world of software development, it’s easy to overlook some of the powerful design patterns that can streamline our code and enhance its flexibility. One such pattern is the Object Adapter Design Pattern. While many developers use it in their projects, it often gets sidelined amid tight deadlines and urgent tasks. However, understanding this pattern can significantly improve the quality of our software architecture.

In this blog, we’ll dive into the Object Adapter Design Pattern, exploring its structure and purpose. I’ll guide you through a simple example to illustrate its implementation, showcasing how it can bridge the gap between incompatible interfaces. By the end, you’ll see why this pattern is an essential tool in your development toolkit—making your code not only more adaptable but also easier to maintain and extend. Let’s unlock the potential of the Object Adapter Design Pattern together!

Object Adapter Pattern Definition

The Object Adapter Pattern is a structural design pattern that allows objects with incompatible interfaces to collaborate by using composition rather than inheritance. Instead of modifying the existing class (adaptee), the adapter creates a bridge between the client and the adaptee by holding a reference to the adaptee. This approach enables flexible and reusable solutions without altering existing code.

In the Object Adapter Pattern, the adapter contains an instance of the adaptee and implements the interface expected by the client. It “adapts” the methods of the adaptee to fit the expected interface.

Structure of Object Adapter Pattern

1. Client: The class that interacts with the target interface.
2. Target Interface: The interface that the client expects.
3. Adaptee: The class with an incompatible interface that needs to be adapted.
4. Adapter: The class that implements the target interface and holds a reference to the adaptee, enabling the two incompatible interfaces to work together.

In this UML diagram of the Object Adapter Pattern,

• Client → Depends on → Target Interface
• Adapter → Implements → Target Interface
• Adapter → Has a reference to → Adaptee
• Adaptee → Has methods incompatible with the Target Interface

Key Points:

• Object Adapter uses composition (by containing the adaptee) instead of inheritance, which makes it more flexible and reusable.
• The adapter doesn’t alter the existing Adaptee class but makes it compatible with the Target Interface.

Simple Example 

Let’s consider a simple scenario where we want to charge different types of phones, but their charging ports are incompatible.

1. The Client is a phone charger that expects to use a USB type-C charging port.
2. The Adaptee is an old phone that uses a micro-USB charging port.
3. The Adapter bridges the difference by converting the micro-USB interface to a USB type-C interface.

Step 1: Define the Target Interface

The charger (client) expects all phones to implement this interface (USB Type-C).

// Target interface that the client expects
interface UsbTypeCCharger {
    fun chargeWithUsbTypeC()
}

Step 2: Define the Adaptee

This is the old phone, which only has a Micro-USB port. The charger can’t directly use this interface.

// Adaptee class that uses Micro-USB for charging
class MicroUsbPhone {
    fun rechargeWithMicroUsb() {
        println("Micro-USB phone: Charging using Micro-USB port")
    }
}

Step 3: Create the Adapter

The adapter will “adapt” the Micro-USB phone to make it compatible with the USB Type-C charger. It wraps the MicroUsbPhone and translates the charging request.

// Adapter that makes Micro-USB phone compatible with USB Type-C charger
class MicroUsbToUsbTypeCAdapter(private val microUsbPhone: MicroUsbPhone) : UsbTypeCCharger {
    override fun chargeWithUsbTypeC() {
        println("Adapter: Converting USB Type-C to Micro-USB")
        microUsbPhone.rechargeWithMicroUsb() // Delegating the charging to the Micro-USB phone
    }
}

Step 4: Implement the Client

The client (charger) works with the target interface (UsbTypeCCharger). It can now charge a phone with a Micro-USB port by using the adapter.

fun main() {
    // Old phone with a Micro-USB port (Adaptee)
    val microUsbPhone = MicroUsbPhone()

    // Adapter that makes the Micro-USB phone compatible with USB Type-C charger
    val usbTypeCAdapter = MicroUsbToUsbTypeCAdapter(microUsbPhone)

    // Client (USB Type-C Charger) charges the phone using the adapter
    println("Client: Charging phone using USB Type-C charger")
    usbTypeCAdapter.chargeWithUsbTypeC()
}

Output:

Client: Charging phone using USB Type-C charger
Adapter: Converting USB Type-C to Micro-USB
Micro-USB phone: Charging using Micro-USB port

Here,

• Client: The charger expects all phones to be charged using a USB Type-C port, so it calls chargeWithUsbTypeC().
• Adapter: The adapter receives the request from the client to charge using USB Type-C. It converts this request and adapts it to the MicroUsbPhone by calling rechargeWithMicroUsb() internally.
• Adaptee (MicroUsbPhone): The phone knows how to charge itself using Micro-USB. The adapter simply makes it compatible with the client’s expectation.

What’s Happening in Each Step

1. Client: The charger (client) is asking to charge a phone via USB Type-C.
2. Adapter: The adapter intercepts this request and converts it to something the old phone understands, which is charging via Micro-USB.
3. Adaptee (Micro-USB phone): The old phone proceeds with charging using its Micro-USB port.

This structure makes the responsibilities of each component clearer:

• The adapter’s job is to convert between incompatible interfaces.
• The client only works with the UsbTypeCCharger interface, while the old phone uses its own rechargeWithMicroUsb() method.

Object Adapter Pattern Short Recap

• Object Adapter relies on composition rather than inheritance to adapt one interface to another.
• It is used when you need to integrate an existing class (adaptee) with an interface that it does not implement.
• This pattern ensures that you do not need to modify the adaptee class to make it compatible with a new system.

Advantages of Object Adapter Pattern

• Flexibility: By using composition, the adapter pattern allows multiple adaptees to be wrapped by the same adapter without modifying the adaptee classes.
• Code Reusability: The adapter allows reusing existing classes even if their interfaces do not match the required one.
• Separation of Concerns: The client is decoupled from the adaptee, making the system easier to maintain and extend.

Conclusion

The Object Adapter Design Pattern serves as a powerful solution for integrating incompatible interfaces, making it a vital asset in our software development arsenal. By facilitating communication between different classes without modifying their source code, this pattern promotes flexibility and reusability, ultimately leading to cleaner, more maintainable code.

As we’ve explored, implementing the Object Adapter not only simplifies complex interactions but also enhances the scalability of your applications. Whether you’re working on legacy systems or integrating new functionalities, the Object Adapter Design Pattern can help you tackle challenges with ease.

Embracing design patterns like the Object Adapter allows us to write code that is not just functional, but also elegant and robust. So, the next time you find yourself in a hurry, take a moment to consider how the Object Adapter can streamline your solution. By investing a little time to understand and apply this pattern, you’ll be well-equipped to create software that stands the test of time. Happy coding!