How Adapter Design Pattern Works: Real-World Examples

1. Introduction and Core Concepts

The adapter design pattern is one of the most practical and frequently used structural design patterns in modern software engineering. At its core, the adapter design pattern acts as a bridge between two incompatible interfaces, allowing classes that otherwise could not work together to collaborate seamlessly. Like a physical power adapter that lets a European plug fit into an American outlet, the software adapter converts the interface of an existing class into another interface that a client expects.

Understanding the adapter design pattern is essential because real-world software systems are rarely built from scratch. Developers constantly integrate legacy code, third-party libraries, external APIs, and microservices that were never designed to work together. Without an adapter, you would be forced to rewrite existing code or modify third-party libraries directly — both of which are risky, expensive, and often impossible. The adapter design pattern solves this by introducing an intermediary layer that handles the translation without altering either the client or the existing service.

The adapter design pattern belongs to the structural pattern family defined by the Gang of Four (GoF). Its primary intent is to promote reusability and adhere to the Open/Closed Principle: software entities should be open for extension but closed for modification. Instead of changing the source code of an adaptee (the existing class with an incompatible interface) or the client (the code that needs a specific interface), you create a new adapter class that wraps the adaptee and exposes the target interface. This approach keeps your codebase clean, decoupled, and testable, which is why the adapter design pattern appears in virtually every enterprise framework, from Java Spring to Python Django.

Why the Adapter Design Pattern Matters

In large-scale systems, incompatibility is inevitable. Consider a payment processing system that was built to work with Stripe, but your business now needs to support PayPal, Square, and a legacy bank API. Each provider has different method names, parameters, and response formats. Rewriting your entire checkout logic for each provider would create massive code duplication and maintenance overhead. The adapter design pattern allows you to define a single, unified payment interface and create adapters for each provider that translate their unique APIs to your common interface.

Another critical reason the adapter design pattern matters is its role in legacy modernization. Organizations often have decades-old systems that are reliable but use outdated interfaces. Rather than performing a high-risk rewrite, engineers can wrap these legacy systems with adapters, allowing new code to interact with them using modern conventions. This incremental approach reduces risk and enables gradual refactoring, a strategy used by companies like Amazon, Netflix, and banks modernizing COBOL systems.

Key Participants in the Pattern

Every implementation of the adapter design pattern involves four key participants. The Target defines the domain-specific interface that the client uses. The Client is the code that needs to work with the Target interface. The Adaptee is the existing class with an incompatible interface that needs to be adapted. Finally, the Adapter is the class that implements the Target interface and internally delegates calls to the Adaptee, performing any necessary data conversion or transformation. Understanding these roles is crucial for correctly applying the pattern without confusing it with similar structural patterns like Facade or Decorator.

2. How It Works

The mechanism of the adapter design pattern is elegantly simple: delegation and translation. The client interacts only with the Target interface, completely unaware that an Adaptee exists behind the scenes. When the client calls a method on the Target, the Adapter intercepts that call, translates the parameters and method name into a form the Adaptee understands, invokes the Adaptee's method, and then translates the result back into the format the client expects. This bidirectional translation is what makes the pattern so powerful.

There are two fundamental ways the adapter design pattern achieves this translation: the Object Adapter and the Class Adapter. The Object Adapter uses composition — the adapter holds an instance of the adaptee and delegates to it. This is the most common approach in languages like Python, Java, and C# because it is flexible, supports adapting multiple adaptees, and works with composition over inheritance. The Class Adapter uses inheritance — the adapter inherits from both the Target and the Adaptee simultaneously. This approach is only possible in languages that support multiple inheritance, such as Python and C++, and is less common because it tightly couples the adapter to a specific adaptee class.

The workflow can be visualized as a three-step translation pipeline. First, the client invokes target.request(). Second, the adapter's implementation of request() internally calls adaptee.specific_request(), often converting data types, reordering arguments, or handling error format differences. Third, the adapter returns the adaptee's result after converting it to the target's expected return type. This indirection adds a negligible performance overhead but provides immense architectural flexibility, enabling polymorphism where it would otherwise be impossible.

The Translation Logic

Translation is not always a simple one-to-one method rename. In real implementations of the adapter design pattern, the adapter may need to aggregate multiple adaptee calls to fulfill a single target request, split one adaptee method into several target methods, or handle complex data transformations such as converting XML to JSON, mapping error codes, or normalizing units of measurement. For example, an adapter for a legacy temperature sensor that returns Fahrenheit might convert the value to Celsius before returning it to a client that expects metric units.

This translation logic should be kept inside the adapter and nowhere else. A well-designed adapter is stateless or minimally stateful, focused solely on interface conversion. It should not contain business logic, validation, or workflow orchestration. Keeping the adapter thin ensures it remains reusable and easy to test. If you find your adapter growing too complex, it may be a sign that you need a Facade or that the adaptee's interface is too divergent and requires a more comprehensive refactoring.

Object Adapter vs. Class Adapter Structure

Choosing between object and class adapters depends on language capabilities and design constraints. The object adapter is more flexible because it can adapt any subclass of the adaptee and can adapt multiple adaptees by holding references to each. It also aligns with the principle of favoring composition over inheritance, leading to more maintainable code. The class adapter, while slightly more efficient due to direct inheritance, is rigid and cannot adapt subclasses without creating new adapters. In Python, both are viable, but object adapters are overwhelmingly preferred in production code for their flexibility and clarity.

3. Implementation

Implementing the adapter design pattern in Python is straightforward thanks to Python's dynamic typing and support for abstract base classes. Python's abc module allows you to define formal Target interfaces, while duck typing often makes explicit interfaces optional. However, for large projects and team collaboration, defining an abstract Target class improves documentation and enables static type checking with tools like mypy.

The following examples demonstrate both object and class adapter implementations, as well as a realistic payment gateway scenario. Each code block includes detailed comments explaining the role of each class and the translation logic. Remember that the goal is to make the client code independent of the adaptee's specific interface.

# Object Adapter - Composition-based (Recommended)
from abc import ABC, abstractmethod

# Target: The interface expected by the Client
class MediaPlayer(ABC):
    @abstractmethod
    def play(self, filename: str) -> str:
        pass

# Adaptee: Existing class with incompatible interface
class AdvancedAudioPlayer:
    def play_mp4(self, file_name: str) -> str:
        return f"Playing MP4 file: {file_name} with advanced codec"

    def play_vlc(self, file_name: str) -> str:
        return f"Playing VLC file: {file_name} with VLC engine"

# Adapter: Translates MediaPlayer interface to AdvancedAudioPlayer
class MediaAdapter(MediaPlayer):
    def __init__(self, audio_type: str):
        self.audio_type = audio_type.lower()
        # Composition: adapter holds an instance of adaptee
        self.advanced_player = AdvancedAudioPlayer()

    def play(self, filename: str) -> str:
        # Translation logic: map generic play() to specific methods
        if self.audio_type == "mp4":
            return self.advanced_player.play_mp4(filename)
        elif self.audio_type == "vlc":
            return self.advanced_player.play_vlc(filename)
        else:
            return f"Unsupported format: {self.audio_type}"

# Client code works only with Target interface
def client_code(player: MediaPlayer, filename: str):
    return player.play(filename)

# Usage
adapter = MediaAdapter("mp4")
print(client_code(adapter, "movie.mp4"))

# Class Adapter - Inheritance-based (Python multiple inheritance)
from abc import ABC, abstractmethod

class TargetPrinter(ABC):
    @abstractmethod
    def print_document(self, text: str) -> str:
        pass

# Adaptee with incompatible method name and signature
class LegacyPrinter:
    def print_legacy(self, content: str, copies: int = 1) -> str:
        return f"[Legacy] Printing '{content}' x{copies} on dot-matrix"

# Adapter inherits from BOTH Target and Adaptee
class PrinterAdapter(TargetPrinter, LegacyPrinter):
    def print_document(self, text: str) -> str:
        # Adapt Target method to Adaptee method
        # Translation: add default copies, rename method
        return self.print_legacy(content=text, copies=1)

# Client expects TargetPrinter
def print_client(printer: TargetPrinter):
    return printer.print_document("Hello Adapter")

adapter = PrinterAdapter()
print(print_client(adapter))
# Works because PrinterAdapter IS-A TargetPrinter and IS-A LegacyPrinter

# Real-World Example: Payment Gateway Adapter
from abc import ABC, abstractmethod

# Target interface for our e-commerce system
class PaymentProcessor(ABC):
    @abstractmethod
    def pay(self, amount: float, currency: str) -> dict:
        pass

# Adaptee 1: Stripe-like SDK (incompatible interface)
class StripeSDK:
    def create_charge(self, amount_cents: int, curr: str) -> dict:
        # Stripe expects amount in cents, different param names
        return {"id": "ch_123", "status": "succeeded", "amount": amount_cents}

# Adaptee 2: PayPal-like SDK (another incompatible interface)
class PayPalSDK:
    def send_payment(self, value: float, currency_code: str) -> dict:
        return {"paymentID": "PAY-456", "state": "approved", "value": value}

# Adapter for Stripe
class StripeAdapter(PaymentProcessor):
    def __init__(self, stripe_sdk: StripeSDK):
        self.stripe = stripe_sdk

    def pay(self, amount: float, currency: str) -> dict:
        # Translate: dollars to cents, normalize response
        cents = int(amount * 100)
        result = self.stripe.create_charge(amount_cents=cents, curr=currency)
        # Normalize to common format
        return {"transaction_id": result["id"], "success": result["status"] == "succeeded"}

# Adapter for PayPal
class PayPalAdapter(PaymentProcessor):
    def __init__(self, paypal_sdk: PayPalSDK):
        self.paypal = paypal_sdk

    def pay(self, amount: float, currency: str) -> dict:
        result = self.paypal.send_payment(value=amount, currency_code=currency)
        return {"transaction_id": result["paymentID"], "success": result["state"] == "approved"}

# Client checkout - unchanged regardless of provider
def checkout(processor: PaymentProcessor, amount: float):
    result = processor.pay(amount, "USD")
    return f"Payment {'success' if result['success'] else 'failed'}: {result['transaction_id']}"

print(checkout(StripeAdapter(StripeSDK()), 49.99))
print(checkout(PayPalAdapter(PayPalSDK()), 49.99))

# Adapter with Data Transformation and Caching
from abc import ABC, abstractmethod
import json

# Target expects JSON in / JSON out
class DataService(ABC):
    @abstractmethod
    def fetch_user(self, user_id: int) -> dict:
        pass

# Adaptee: Legacy XML service with different interface
class LegacyUserService:
    def get_user_xml(self, uid: int) -> str:
        # Returns XML string, uses uid instead of user_id
        return f"<user><id>{uid}</id><name>Alice</name><age>30</age></user>"

# Adapter handles XML -> JSON conversion and interface mapping
class UserServiceAdapter(DataService):
    def __init__(self, legacy_service: LegacyUserService):
        self.legacy = legacy_service
        self.cache = {}  # Simple optimization

    def fetch_user(self, user_id: int) -> dict:
        if user_id in self.cache:
            return self.cache[user_id]

        # Step 1: Call adaptee with translated parameter name
        xml_data = self.legacy.get_user_xml(uid=user_id)

        # Step 2: Transform XML to dict (simplified parsing)
        # In production, use xml.etree.ElementTree
        name = xml_data.split("<name>")[1].split("</name>")[0]
        age = int(xml_data.split("<age>")[1].split("</age>")[0])

        result = {"id": user_id, "name": name, "age": age}
        self.cache[user_id] = result
        return result

# Client uses modern JSON interface
adapter = UserServiceAdapter(LegacyUserService())
print(adapter.fetch_user(42))  # {'id': 42, 'name': 'Alice', 'age': 30}
print(adapter.fetch_user(42))  # Served from cache

These four examples illustrate the versatility of the adapter design pattern. The object adapter is ideal for most Python projects, the class adapter demonstrates inheritance-based adaptation, the payment gateway example shows how to unify multiple third-party services, and the data transformation adapter highlights how adapters can handle complex format conversions and even add optimizations like caching.

4. Step-by-Step Example

To solidify your understanding of the adapter design pattern, let's walk through a concrete, end-to-end scenario: integrating a legacy analytics library into a modern reporting dashboard. Imagine your dashboard expects all analytics providers to implement a AnalyticsProvider interface with a method track(event: str, properties: dict) -> bool. However, your company has a powerful legacy library called OldAnalytics that uses a completely different method: log_event(event_name, event_data_str) where event_data_str is a JSON-encoded string and the method returns an integer status code.

Step 1 is to define the Target interface. This is the contract your dashboard will code against. It should be simple, well-documented, and focused on what the client needs, not how the adaptee works. In this case, AnalyticsProvider defines track with clear parameter types and a boolean return indicating success. This interface becomes the single source of truth for all analytics integrations, whether they are new or legacy.

Step 2 is to examine the Adaptee. The OldAnalytics class cannot be modified — perhaps it is a compiled library, a vendor-provided SDK, or legacy code that is too risky to change. Its method log_event expects a string event name and a JSON string, and it returns 0 for success and 1 for failure. The parameter names, types, and return values all differ from the Target. Documenting these mismatches is crucial before writing the adapter.

Building the Adapter

Step 3 is to create the Adapter class. The adapter implements the AnalyticsProvider interface and holds a reference to an OldAnalytics instance via composition. Inside the track method, it performs three translations: it serializes the properties dictionary to a JSON string using json.dumps, it calls old_analytics.log_event(event, json_str), and it converts the integer status code (0 or 1) to a boolean (True or False). This logic is isolated, testable, and reusable.

Step 4 is to use the adapter in client code. The dashboard's reporting service now accepts any AnalyticsProvider, including the new OldAnalyticsAdapter. The client code does not need to know whether it is talking to a modern Mixpanel adapter, a Google Analytics adapter, or the legacy system. This polymorphism is the core benefit of the adapter design pattern — it enables dependency injection and makes unit testing trivial, as you can mock the Target interface without touching the legacy code.

Verification and Testing

Step 5 is to verify the integration. Write unit tests that mock the OldAnalytics class and assert that the adapter correctly translates inputs and outputs. Test edge cases such as empty properties, special characters in event names, and failure status codes. Integration tests should confirm that events actually appear in the legacy analytics backend. By testing the adapter in isolation, you ensure that the translation layer is robust and that future changes to either the Target or Adaptee will be caught early.

5. Complexity Analysis

From an algorithmic perspective, the adapter design pattern is remarkably lightweight. It does not introduce complex data structures or recursive algorithms; its primary operation is delegation with optional data transformation. Therefore, the time and space complexity of the adapter design pattern is dominated by the cost of the underlying adaptee operation plus any conversion overhead introduced by the adapter itself.

In the best case, where the adapter performs a simple method rename with no data conversion, the overhead is constant time O(1) and constant space O(1). The adapter simply forwards the call. In the average case, where the adapter performs light transformations such as renaming keys, converting units, or serializing small payloads, the overhead remains O(1) or O(n) where n is the size of the payload being transformed. For example, converting a dictionary with k keys to another format takes O(k) time.

In the worst case, the adapter might need to perform expensive transformations such as parsing large XML documents, compressing data, or making multiple adaptee calls to fulfill a single target request. In such scenarios, the complexity could be O(n) or even O(n log n) if sorting or complex mapping is involved. However, this cost is inherent to the integration problem itself, not the pattern — without the adapter, the client would still need to perform the same transformation. The pattern simply centralizes it.

Space complexity is similarly minimal. An object adapter holds a single reference to the adaptee, requiring O(1) additional space. If the adapter implements caching or buffering, space grows to O(c) where c is the cache size. Class adapters have no additional reference overhead since they use inheritance, but they still require O(1) space for the object itself. Overall, the adapter design pattern is one of the most efficient patterns in terms of computational resources, making it suitable for high-throughput systems like web servers and network proxies where per-request overhead must be minimized.

6. Variations and Optimizations

While the classic adapter design pattern is simple, several variations and optimizations have emerged to handle more complex scenarios. The Two-Way Adapter is a notable variant that allows the adapter to work in both directions — it can act as a Target when the client expects the Adaptee interface and vice versa. This is useful in systems where two different clients need to interoperate, each expecting a different interface. The two-way adapter implements both interfaces and delegates appropriately, though it increases complexity and should be used sparingly.

Another powerful variation is the Pluggable Adapter, which uses dynamic adaptation rather than static class structure. Instead of hardcoding the translation logic, a pluggable adapter accepts transformation functions or strategy objects at runtime. For example, you might pass a lambda that converts data formats, allowing a single adapter class to handle multiple adaptees with minimal code duplication. This approach leverages Python's first-class functions and is highly flexible for plugin architectures.

Optimizations often focus on reducing translation overhead. Caching adapters store the results of expensive transformations, as shown in the earlier data service example. Lazy adapters defer the creation of the adaptee until it is actually needed, saving resources if the adapter is instantiated but not used. Batching adapters collect multiple client requests and forward them as a single batch call to the adaptee, which is critical when adapting to APIs with rate limits or high per-call latency, such as database drivers or external REST APIs.

Adapter with Dependency Injection

Modern implementations often combine the adapter design pattern with dependency injection frameworks. Instead of instantiating the adaptee inside the adapter, the adaptee is injected via the constructor. This makes the adapter more testable and allows the same adapter class to work with different adaptee instances or mocks. In frameworks like FastAPI or Django, adapters can be registered as singletons and injected wherever the Target interface is required, promoting loose coupling across the entire application.

Generic and Protocol-Based Adapters

In Python 3.8+, you can use typing.Protocol to define structural Target interfaces without requiring explicit inheritance. This enables more Pythonic, duck-typed adapters that do not need to inherit from an abstract base class. Combined with generics, you can create reusable adapter factories that work across multiple types while retaining type safety. This modern approach reduces boilerplate and aligns with Python's dynamic nature while still benefiting from the adapter design pattern's structure.

7. Real-World Applications

The adapter design pattern is ubiquitous in real-world software, often operating invisibly within frameworks and libraries. One of the most common applications is in database abstraction layers. Python's DB-API 2.0 defines a standard interface for database operations, but each database driver (psycopg2 for PostgreSQL, PyMySQL for MySQL, sqlite3 for SQLite) has its own quirks. ORMs like SQLAlchemy use adapters to normalize these differences, presenting a unified interface to application code while internally translating to each driver's specific API.

Web servers and middleware provide another rich example. The Python Web Server Gateway Interface (WSGI) is essentially an adapter specification that allows web frameworks like Flask and Django to work with any WSGI-compliant server like Gunicorn or uWSGI. Similarly, the newer ASGI specification adapts asynchronous frameworks to handle both HTTP and WebSocket protocols. Without these adapter layers, every framework would need custom server integration code, severely limiting interoperability.

In networking, adapters are used to handle different protocol versions and data formats. For instance, a service that consumes messages from both RabbitMQ and Apache Kafka can define a common MessageQueue target interface and create adapters for each broker. Each adapter translates broker-specific message formats, acknowledgment mechanisms, and connection handling into a uniform API, allowing the business logic to remain agnostic to the underlying transport.

Other notable applications include GUI frameworks, where adapters allow legacy widgets to be used in modern layouts; machine learning pipelines, where adapters normalize different model serving APIs (TensorFlow Serving, ONNX, custom models) behind a common prediction interface; and operating system abstraction, where libraries like pathlib adapt Windows and POSIX path semantics to a single API. The adapter design pattern is also heavily used in testing, where mock adapters simulate external services, enabling fast, deterministic unit tests without network calls.

8. Comparison with Alternatives

The adapter design pattern is often confused with other structural patterns because they all involve wrapping objects. Understanding the distinctions is critical for choosing the right pattern and for technical interviews. The key difference lies in intent: the adapter design pattern is about making incompatible interfaces work together after they have been designed independently, whereas other patterns have different purposes such as simplifying interfaces, adding behavior, or controlling access.

The Bridge pattern, for example, is designed up front to decouple an abstraction from its implementation, allowing both to vary independently. It is a proactive design decision, whereas the adapter is a reactive solution to incompatibility. The Decorator pattern adds new responsibilities to an object dynamically without changing its interface, while the adapter changes the interface itself. The Facade pattern provides a simplified interface to a complex subsystem, but it does not necessarily make incompatible interfaces compatible — it just hides complexity. The Proxy pattern controls access to an object, often adding lazy initialization or access control, but it preserves the original interface.

Choosing the correct pattern depends on your problem. If you have two existing classes that cannot work together due to interface mismatch, use the adapter design pattern. If you are designing a system where you anticipate multiple implementations of an abstraction, use Bridge. If you need to add cross-cutting concerns like logging or caching without modifying the original class, use Decorator. If you want to provide a single, easy-to-use entry point to a complex set of classes, use Facade. Misapplying these patterns leads to confusing code, so always clarify intent before implementing.

9. Common Mistakes and Best Practices

One of the most common mistakes when implementing the adapter design pattern is creating an adapter that does too much. An adapter should only handle interface translation, not business logic, validation, or orchestration. When an adapter starts to contain conditional workflows, database access, or complex calculations, it has become a God Object that violates the Single Responsibility Principle. If you need such logic, consider introducing a separate service layer or using a Facade in conjunction with the adapter.

Another frequent pitfall is overusing adapters to hide poor design. If you find yourself writing adapters for every class in your system, it may indicate that your interfaces are not well-designed or that you are integrating too many incompatible libraries without a coherent abstraction strategy. Adapters are meant to be targeted solutions for specific incompatibilities, not a blanket approach to hide architectural debt. Periodically review whether the adaptee should be refactored or replaced rather than perpetually adapted.

A third mistake is leaking adaptee details through the adapter. The client should never need to know about the adaptee's types, exceptions, or error codes. A well-designed adapter catches adaptee-specific exceptions and translates them into target-specific exceptions. For example, if the adaptee throws a LegacyConnectionError, the adapter should catch it and raise a PaymentFailedError that the client understands. Failing to do so couples the client to the adaptee, defeating the purpose of the pattern.

Best Practices

To use the adapter design pattern effectively, follow these best practices. First, program to an interface, not an implementation. Define a clear Target interface that is driven by client needs, not by the adaptee's structure. This ensures the adapter remains focused and the client remains decoupled. Second, favor object adapters (composition) over class adapters (inheritance) for greater flexibility and testability. Third, keep adapters stateless when possible, or manage state carefully if caching is required, to avoid concurrency issues.

Fourth, write comprehensive tests for your adapters. Since adapters contain translation logic, they are prone to subtle bugs such as off-by-one errors in data conversion or incorrect error mapping. Mock the adaptee and test all translation paths, including edge cases. Fifth, document the mapping clearly. Future maintainers need to understand which target method maps to which adaptee method and what transformations are applied. A simple table in the adapter's docstring can save hours of debugging.

• Do not modify the adaptee or target to make adaptation easier — the adapter should handle all translation.
• Use dependency injection to provide the adaptee to the adapter, enabling easy mocking and configuration.
• Consider using Python's typing.Protocol for flexible, duck-typed target interfaces.
• Avoid creating two-way adapters unless absolutely necessary, as they increase coupling.
• Monitor performance if the adapter performs heavy data transformations on hot paths.

10. Interview Questions

Technical interviews frequently test understanding of the adapter design pattern, both conceptually and through coding exercises. Interviewers want to see that you can distinguish it from similar patterns and apply it to practical problems. Below are common questions with guidance on how to answer them effectively.

Q1: What is the adapter design pattern and when would you use it?

Answer: The adapter design pattern is a structural pattern that allows objects with incompatible interfaces to collaborate. It wraps an existing class (adaptee) with a new interface (target) that the client expects. You would use it when you need to integrate a legacy system, third-party library, or external API without modifying its source code, or when you want to unify multiple providers behind a single interface, such as payment gateways or logging backends. Emphasize that it promotes the Open/Closed Principle and is a retrofit solution, not an upfront design.

Q2: What is the difference between Object Adapter and Class Adapter? Which is preferred in Python?

Answer: An Object Adapter uses composition — it holds an instance of the adaptee and delegates calls to it. A Class Adapter uses multiple inheritance to inherit from both the target and adaptee. In Python, object adapters are preferred because they are more flexible (can adapt subclasses, can adapt multiple adaptees), follow composition over inheritance, and are easier to test via dependency injection. Class adapters are rigid and only work when the adaptee is a class, not an instance, and they tightly couple the adapter to a specific adaptee implementation.

Q3: How does the adapter design pattern differ from Facade, Decorator, and Proxy?

Answer: While all wrap objects, their intents differ. Adapter converts an incompatible interface to one the client expects. Facade simplifies a complex subsystem with a unified, easier interface but does not necessarily handle incompatibility. Decorator adds new behavior without changing the interface and can be stacked recursively. Proxy controls access to an object (e.g., lazy loading, access control) while preserving the same interface. A good answer includes a table or clear examples, such as using Adapter to make a legacy printer work with a new system versus using Decorator to add logging to that printer.

Q4: Can you code a simple adapter in Python? (Live Coding)

Interviewers often ask you to adapt a class like OldPrinter.print_old(text) to a new interface Printer.print(text). The expected solution involves defining a Target abstract class, creating an Adapter that implements the Target and holds an OldPrinter instance, and demonstrating client code that uses the Target interface. Be sure to handle parameter translation, show dependency injection, and explain the translation logic verbally while coding. Also discuss testing strategy and Big O overhead, which is typically O(1) for simple delegation.

Q5: What are the drawbacks of the adapter design pattern?

Answer: The main drawbacks are increased code complexity and indirection — you add an extra layer that can make debugging harder and add slight performance overhead, especially if data transformation is expensive. Overuse can lead to a proliferation of adapter classes that are hard to maintain. Adapters can also mask poor design; if you constantly need adapters, it may be better to refactor the underlying interfaces. Additionally, adapters that perform complex transformations can become hard to test and may introduce subtle bugs if mapping is incorrect. Mention that adapters should be kept thin and well-tested to mitigate these issues.