In software development, we frequently face challenges when trying to connect different systems or components. One design pattern that can facilitate this integration is the Class Adapter Pattern. Despite its potential, many developers overlook this pattern in their day-to-day coding due to the complexities of multiple inheritance. However, with the right approach—by cleverly extending and implementing—we can harness its power effectively.

In this blog, we will explore the Class Adapter Pattern in detail. We’ll break down its structure and functionality, walk through a straightforward example, and discuss the advantages and disadvantages of using this pattern. By the end, you’ll have a solid understanding of how to apply the Class Adapter Pattern in your projects, empowering you to create more flexible and maintainable code. Let’s dive in and unlock the possibilities of the Class Adapter Pattern together!

Class Adapter Pattern

The Class Adapter Pattern is a structural design pattern where an adapter class inherits from both the target interface and the adaptee class. Unlike the Object Adapter Pattern, which uses composition (holding an instance of the adaptee), the Class Adapter Pattern uses multiple inheritance to directly connect the client and the adaptee.

In languages like Kotlin, which do not support true multiple inheritance, we simulate it by using interfaces. The adapter will implement the target interface and extend the adaptee class to bridge the gap between incompatible interfaces.

Before going into much detail, let’s first understand the structure of the Class Adapter Pattern.

Structure of Class Adapter Pattern

1. Client: The class that interacts with the target interface.
2. Target Interface: The interface that the client expects to interact with.
3. Adaptee: The class with an incompatible interface that needs to be adapted.
4. Adapter: A class that inherits from both the target interface and the adaptee, adapting the adaptee to be compatible with the client.

In this UML diagram of the Class Adapter Pattern,

• Client → Depends on → Target Interface
• Adapter → Inherits from → Adaptee
• Adapter → Implements → Target Interface
• Adaptee → Has methods incompatible with the target interface

Key Points:

• The Class Adapter pattern relies on inheritance to connect the Adaptee and the Target Interface.
• The adapter inherits from the adaptee and implements the target interface, thus combining both functionalities.

Simple Example of Class Adapter Pattern 

Now, let’s look at an example of the Class Adapter Pattern. We’ll use the same scenario: a charger that expects a USB Type-C interface but has an old phone that only supports Micro-USB.

Step 1: Define the Target Interface

This is the interface that the client (charger) expects.

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

Step 2: Define the Adaptee

This is the class that needs to be adapted. It’s the old phone with a Micro-USB charging port.

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

Step 3: Define the Adapter (Class Adapter)

The Adapter inherits from the MicroUsbPhone (adaptee) and implements the UsbTypeCCharger (target interface). It adapts the MicroUsbPhone to be compatible with the UsbTypeCCharger interface.

// Adapter that inherits from MicroUsbPhone and implements UsbTypeCCharger
class MicroUsbToUsbTypeCAdapter : MicroUsbPhone(), UsbTypeCCharger {
    // Implement the method from UsbTypeCCharger
    override fun chargeWithUsbTypeC() {
        println("Adapter: Converting USB Type-C to Micro-USB")
        // Call the inherited method from MicroUsbPhone
        rechargeWithMicroUsb() // Uses the Micro-USB method to charge
    }
}

Step 4: Client Usage

The Client only interacts with the UsbTypeCCharger interface and charges the phone through the adapter.

fun main() {
    // Adapter that allows charging a Micro-USB phone with a USB Type-C charger
    val usbTypeCAdapter = MicroUsbToUsbTypeCAdapter()

    // Client (USB Type-C Charger) charges the phone through 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 client expects all phones to be charged using the UsbTypeCCharger interface.
• Adapter: The adapter class inherits the behavior of the MicroUsbPhone (adaptee) and implements the UsbTypeCCharger interface. It converts the USB Type-C charging request and delegates it to the inherited rechargeWithMicroUsb() method.
• Adaptee (Micro-USB phone): The MicroUsbPhone class has a method to recharge using Micro-USB, which is directly called by the adapter.

What’s Happening in Each Step

1. Client: The client attempts to charge a phone using the chargeWithUsbTypeC() method.
2. Adapter: The adapter intercepts this request and converts it to the rechargeWithMicroUsb() method, which it inherits from the MicroUsbPhone class.
3. Adaptee: The phone charges using the rechargeWithMicroUsb() method, fulfilling the request.

Class Adapter Pattern Short Recap

• Class Adapter pattern uses inheritance to connect the adaptee and target interface.
• The adapter inherits the functionality of the adaptee and implements the target interface, converting the incompatible interface.
• In this pattern, the adapter can directly access the methods of the adaptee class because it extends it, which may provide better performance in certain situations but can also lead to more coupling between the classes.

Advantages of Class Adapter Pattern

• Simplicity: Since the adapter inherits from the adaptee, there’s no need to explicitly manage the adaptee object.
• Performance: Direct inheritance avoids the overhead of composition (no need to hold a reference to the adaptee), potentially improving performance in certain cases.
• Code Reusability: You can extend the adapter functionality by inheriting additional methods from the adaptee.

Disadvantages of Class Adapter Pattern

• Less Flexibility: Since the adapter inherits from the adaptee, it is tightly coupled to it. It cannot be used to adapt multiple adaptees (unlike the Object Adapter Pattern, which can wrap different adaptees).
• Single Adaptee: It only works with one adaptee due to inheritance, whereas the Object Adapter can work with multiple adaptees by holding references to different objects.

Conclusion

Class Adapter Pattern is a valuable design tool that can simplify the integration of diverse components in your software projects. While it may seem complex due to the challenges of multiple inheritance, understanding its structure and application can unlock significant benefits.

By leveraging the Class Adapter Pattern, you can create more adaptable and maintainable code, enabling seamless communication between different interfaces. As we’ve explored, this pattern offers unique advantages, but it’s essential to weigh its drawbacks in your specific context.

As you continue your development journey, consider how the Class Adapter Pattern can enhance your solutions. Embracing such design patterns not only improves your code quality but also equips you with the skills to tackle increasingly complex challenges with confidence.

Happy coding!