This lesson follows Singleton and starts the structural patterns. These patterns describe how objects fit together.

Adapter makes incompatible interfaces cooperate. It implements the client's expected contract and translates calls to an existing service. The cost is a translation layer that must preserve meaning.

Find the mismatch before writing the wrapper

Checkout charges in integer cents. A legacy payment library accepts decimal dollars and calls its method submitPayment. The library cannot be changed. Renaming a method is easy. Charging 100 times the expected amount is also easy.

Implement the client's contract

interface PaymentGateway {
  charge(cents: number): Promise<string>;
}
interface LegacyPay {
  submitPayment(dollars: number): Promise<{ transaction_id: string }>;
}

class LegacyPaymentAdapter implements PaymentGateway {
  constructor(private legacy: LegacyPay) {}
  async charge(cents: number): Promise<string> {
    if (!Number.isSafeInteger(cents) || cents <= 0) {
      throw new Error("Charge requires positive integer cents");
    }
    const reply = await this.legacy.submitPayment(cents / 100);
    return reply.transaction_id;
  }
}

class Checkout {
  constructor(private gateway: PaymentGateway) {}
  pay(cents: number) { return this.gateway.charge(cents); }
}

Checkout knows PaymentGateway. The adapter knows both contracts. LegacyPay does its original job and does not know an adapter exists. The money conversion only illustrates the interface. A real payment integration must follow its provider's exact representation and precision rules.

Prefer composition for an existing service

An object adapter holds the service in a field. It works with existing instances and keeps the service's class hierarchy separate. A class adapter inherits service behavior while satisfying the target interface. In languages with suitable multiple inheritance, it can inherit both sides. That ties it more tightly to the inherited implementation.

Map the roles

Role	In this example	Job
Client	Checkout	Contains the business logic and uses only the client interface
Client interface	PaymentGateway	The contract other classes must follow to work with the client
Service (adaptee)	LegacyPay	A useful class, often third-party or legacy, whose interface the client cannot use directly
Adapter	LegacyPaymentAdapter	Implements the client interface, wraps the service, and converts each call into a form the service accepts

Reach for it when a useful class has the wrong interface

• you want to use an existing class, but its interface does not match the rest of your code. The adapter is a middle layer that translates between your code and a legacy class, a third-party class, or any class with an odd interface.
• several existing subclasses lack the same feature, and you cannot add it to their superclass. Copying the feature into a new subclass of each one duplicates code. Instead, put the missing feature in an adapter and wrap any of those objects in it. The objects must share a common interface, and the adapter's field must use that interface. This looks a lot like Decorator.

Implement it in six steps

Refactor existing code toward the pattern in this order:

1. Confirm there are at least two classes with incompatible interfaces: a useful service you cannot change, and one or more clients that would benefit from using it.
2. Declare the client interface. It describes how clients talk to the service.
3. Create the adapter class and make it implement the client interface. Leave its methods empty for now.
4. Add a field that references the service object. Usually the constructor sets it, though sometimes it is easier to pass the service into each method call.
5. Implement every method of the client interface. Delegate the real work to the service. The adapter handles only interface or data-format conversion.
6. Make clients use the adapter through the client interface. You can then change or extend adapters without touching client code.

Name what it costs

You gain	You pay
Interface and data conversion live apart from business logic (single responsibility)	More interfaces and classes, so overall complexity rises
New adapters without breaking client code, as long as clients use the client interface (open/closed)	Sometimes simply changing the service class to match is cheaper

Do not confuse it with its neighbors

Pattern	How it relates
Bridge	Bridge is usually designed up front so parts of an application can be built independently. Adapter is usually applied to existing code to make incompatible classes work together.
Decorator	Adapter changes an object's interface. Decorator enhances an object while keeping its interface, and it supports recursive stacking, which Adapter does not.
Proxy	Adapter gives the wrapped object a different interface. Proxy gives it the same interface. Decorator gives it an enhanced interface.
Facade	Facade defines a new interface over existing objects, often a whole subsystem. Adapter makes an existing interface usable and usually wraps one object.
Strategy, State	Bridge, State, Strategy, and to some degree Adapter share a structure built on composition: delegating work to another object. They solve different problems.

Retrieve and apply

List the unit, format, and failure conversions for one external API. Continue to Bridge for two dimensions that should grow separately.