Adapter Pattern · Design Patterns

What is the Adapter pattern?

Adapter means: wrap a class with one interface so it looks like a different interface your code already expects.

You keep both sides unchanged. The adapter sits in the middle and translates calls from the shape the caller uses into the shape the existing class actually understands.

Three roles show up every time:

Target — the interface your code already calls.
Adaptee — the existing class with a different, incompatible interface.
Adapter — the new class that implements Target and calls Adaptee underneath.

The problem it solves

Your code expects one interface for playing media. A third-party library exposes a different one, with different method names.

class MediaPlayer:
    def play(self, audio_type: str, file_name: str) -> None:
        raise NotImplementedError


class AdvancedMediaPlayer:
    def play_vlc(self, file_name: str) -> None:
        print(f"Playing VLC file: {file_name}")

    def play_mp4(self, file_name: str) -> None:
        print(f"Playing MP4 file: {file_name}")

public interface MediaPlayer {
    void play(String audioType, String fileName);
}

public class AdvancedMediaPlayer {
    public void playVlc(String fileName) {
        System.out.println("Playing VLC file: " + fileName);
    }

    public void playMp4(String fileName) {
        System.out.println("Playing MP4 file: " + fileName);
    }
}

package media

import "fmt"

type MediaPlayer interface {
	Play(audioType, fileName string)
}

type AdvancedMediaPlayer struct{}

func (a *AdvancedMediaPlayer) PlayVlc(fileName string) {
	fmt.Println("Playing VLC file:", fileName)
}

func (a *AdvancedMediaPlayer) PlayMp4(fileName string) {
	fmt.Println("Playing MP4 file:", fileName)
}

interface MediaPlayer {
  play(audioType: string, fileName: string): void;
}

class AdvancedMediaPlayer {
  playVlc(fileName: string) {
    console.log(`Playing VLC file: ${fileName}`);
  }

  playMp4(fileName: string) {
    console.log(`Playing MP4 file: ${fileName}`);
  }
}

AdvancedMediaPlayer has no play(audioType, fileName) method. You cannot easily rewrite a library you do not own, and you do not want its method names spreading through your app. Adapter bridges the two without touching either.

The object adapter

The common form uses composition. The adapter holds the adaptee and implements the target interface, forwarding each call to the right method underneath.

class MediaAdapter(MediaPlayer):
    def __init__(self) -> None:
        self._advanced_player = AdvancedMediaPlayer()

    def play(self, audio_type: str, file_name: str) -> None:
        if audio_type == "vlc":
            self._advanced_player.play_vlc(file_name)
        elif audio_type == "mp4":
            self._advanced_player.play_mp4(file_name)


class AudioPlayer(MediaPlayer):
    def __init__(self) -> None:
        self._adapter = MediaAdapter()

    def play(self, audio_type: str, file_name: str) -> None:
        if audio_type == "mp3":
            print(f"Playing MP3 file: {file_name}")
        else:
            self._adapter.play(audio_type, file_name)


# use
player = AudioPlayer()
player.play("mp3", "song.mp3")
player.play("mp4", "video.mp4")

public class MediaAdapter implements MediaPlayer {
    private final AdvancedMediaPlayer advancedPlayer = new AdvancedMediaPlayer();

    @Override
    public void play(String audioType, String fileName) {
        if (audioType.equalsIgnoreCase("vlc")) {
            advancedPlayer.playVlc(fileName);
        } else if (audioType.equalsIgnoreCase("mp4")) {
            advancedPlayer.playMp4(fileName);
        }
    }
}

public class AudioPlayer implements MediaPlayer {
    private final MediaAdapter adapter = new MediaAdapter();

    @Override
    public void play(String audioType, String fileName) {
        if (audioType.equalsIgnoreCase("mp3")) {
            System.out.println("Playing MP3 file: " + fileName);
        } else {
            adapter.play(audioType, fileName);
        }
    }
}

// use
MediaPlayer player = new AudioPlayer();
player.play("mp3", "song.mp3");
player.play("mp4", "video.mp4");

type MediaAdapter struct {
	advancedPlayer *AdvancedMediaPlayer
}

func NewMediaAdapter() *MediaAdapter {
	return &MediaAdapter{advancedPlayer: &AdvancedMediaPlayer{}}
}

func (m *MediaAdapter) Play(audioType, fileName string) {
	switch audioType {
	case "vlc":
		m.advancedPlayer.PlayVlc(fileName)
	case "mp4":
		m.advancedPlayer.PlayMp4(fileName)
	}
}

type AudioPlayer struct {
	adapter *MediaAdapter
}

func NewAudioPlayer() *AudioPlayer {
	return &AudioPlayer{adapter: NewMediaAdapter()}
}

func (a *AudioPlayer) Play(audioType, fileName string) {
	if audioType == "mp3" {
		fmt.Println("Playing MP3 file:", fileName)
		return
	}
	a.adapter.Play(audioType, fileName)
}

// use
var player MediaPlayer = NewAudioPlayer()
player.Play("mp3", "song.mp3")
player.Play("mp4", "video.mp4")

class MediaAdapter implements MediaPlayer {
  private advancedPlayer = new AdvancedMediaPlayer();

  play(audioType: string, fileName: string) {
    if (audioType === 'vlc') {
      this.advancedPlayer.playVlc(fileName);
    } else if (audioType === 'mp4') {
      this.advancedPlayer.playMp4(fileName);
    }
  }
}

class AudioPlayer implements MediaPlayer {
  private adapter = new MediaAdapter();

  play(audioType: string, fileName: string) {
    if (audioType === 'mp3') {
      console.log(`Playing MP3 file: ${fileName}`);
    } else {
      this.adapter.play(audioType, fileName);
    }
  }
}

// use
const player: MediaPlayer = new AudioPlayer();
player.play('mp3', 'song.mp3');
player.play('mp4', 'video.mp4');

AudioPlayer only ever calls play. Whether that call is handled directly or routed through MediaAdapter is invisible to the caller.

The class adapter (less common)

Instead of holding the adaptee as a field, a class adapter inherits from it and implements the target interface on top.

class Target:
    def request(self) -> None:
        raise NotImplementedError


class Adaptee:
    def specific_request(self) -> None:
        print("Adaptee specific request")


class ClassAdapter(Target, Adaptee):
    def request(self) -> None:
        self.specific_request()


# use
target: Target = ClassAdapter()
target.request()  # calls specific_request() underneath

public interface Target {
    void request();
}

public class Adaptee {
    public void specificRequest() {
        System.out.println("Adaptee specific request");
    }
}

public class ClassAdapter extends Adaptee implements Target {
    @Override
    public void request() {
        specificRequest();
    }
}

// use
Target target = new ClassAdapter();
target.request(); // calls specificRequest() underneath

// Go has no inheritance, so there is no true class adapter.
// Embedding gets you method reuse, but Request() still has to be
// written by hand — which makes this the same shape as the object
// adapter above.
type Target interface {
	Request()
}

type Adaptee struct{}

func (a Adaptee) SpecificRequest() {
	fmt.Println("Adaptee specific request")
}

type ClassAdapter struct {
	Adaptee
}

func (c ClassAdapter) Request() {
	c.SpecificRequest()
}

// use
var target Target = ClassAdapter{}
target.Request()

interface Target {
  request(): void;
}

class Adaptee {
  specificRequest() {
    console.log('Adaptee specific request');
  }
}

class ClassAdapter extends Adaptee implements Target {
  request() {
    this.specificRequest();
  }
}

// use
const target: Target = new ClassAdapter();
target.request(); // calls specificRequest() underneath

This locks the adapter to one adaptee, chosen at compile time, and it inherits everything the adaptee exposes. Prefer the object adapter unless you have a specific reason to reach for inheritance.

Worked example: a legacy payment system

A legacy payment method with its own signature, sitting next to a newer interface your app now standardizes on.

class PaymentProcessor:
    def process_payment(self, amount: float) -> None:
        raise NotImplementedError


class LegacyPaymentSystem:
    def make_payment(self, currency: str, amount: float) -> None:
        print(f"Legacy payment: {amount} {currency}")


class LegacyPaymentAdapter(PaymentProcessor):
    def __init__(self, legacy_system: LegacyPaymentSystem) -> None:
        self._legacy_system = legacy_system

    def process_payment(self, amount: float) -> None:
        self._legacy_system.make_payment("USD", amount)


class ModernPaymentProcessor(PaymentProcessor):
    def process_payment(self, amount: float) -> None:
        print(f"Modern payment: ${amount}")


# use
modern = ModernPaymentProcessor()
modern.process_payment(100.0)

via_adapter = LegacyPaymentAdapter(LegacyPaymentSystem())
via_adapter.process_payment(100.0)

public interface PaymentProcessor {
    void processPayment(double amount);
}

public class LegacyPaymentSystem {
    public void makePayment(String currency, double amount) {
        System.out.println("Legacy payment: " + amount + " " + currency);
    }
}

public class LegacyPaymentAdapter implements PaymentProcessor {
    private final LegacyPaymentSystem legacySystem;

    public LegacyPaymentAdapter(LegacyPaymentSystem legacySystem) {
        this.legacySystem = legacySystem;
    }

    @Override
    public void processPayment(double amount) {
        legacySystem.makePayment("USD", amount);
    }
}

public class ModernPaymentProcessor implements PaymentProcessor {
    @Override
    public void processPayment(double amount) {
        System.out.println("Modern payment: $" + amount);
    }
}

// use
PaymentProcessor modern = new ModernPaymentProcessor();
modern.processPayment(100.0);

PaymentProcessor viaAdapter = new LegacyPaymentAdapter(new LegacyPaymentSystem());
viaAdapter.processPayment(100.0);

type PaymentProcessor interface {
	ProcessPayment(amount float64)
}

type LegacyPaymentSystem struct{}

func (l *LegacyPaymentSystem) MakePayment(currency string, amount float64) {
	fmt.Printf("Legacy payment: %.2f %s\\n", amount, currency)
}

type LegacyPaymentAdapter struct {
	legacySystem *LegacyPaymentSystem
}

func (a *LegacyPaymentAdapter) ProcessPayment(amount float64) {
	a.legacySystem.MakePayment("USD", amount)
}

type ModernPaymentProcessor struct{}

func (m *ModernPaymentProcessor) ProcessPayment(amount float64) {
	fmt.Printf("Modern payment: $%.2f\\n", amount)
}

// use
var modern PaymentProcessor = &ModernPaymentProcessor{}
modern.ProcessPayment(100.0)

var viaAdapter PaymentProcessor = &LegacyPaymentAdapter{legacySystem: &LegacyPaymentSystem{}}
viaAdapter.ProcessPayment(100.0)

interface PaymentProcessor {
  processPayment(amount: number): void;
}

class LegacyPaymentSystem {
  makePayment(currency: string, amount: number) {
    console.log(`Legacy payment: ${amount} ${currency}`);
  }
}

class LegacyPaymentAdapter implements PaymentProcessor {
  constructor(private legacySystem: LegacyPaymentSystem) {}

  processPayment(amount: number) {
    this.legacySystem.makePayment('USD', amount);
  }
}

class ModernPaymentProcessor implements PaymentProcessor {
  processPayment(amount: number) {
    console.log(`Modern payment: $${amount}`);
  }
}

// use
const modern: PaymentProcessor = new ModernPaymentProcessor();
modern.processPayment(100.0);

const viaAdapter: PaymentProcessor = new LegacyPaymentAdapter(new LegacyPaymentSystem());
viaAdapter.processPayment(100.0);

Both processors are constructed and called the same way. One happens to route through an adapter and an old system underneath; the caller cannot tell.

When it helps

Reach for Adapter when you are integrating with something you cannot change — a third-party library, a legacy module, an external API — and its interface does not match what your code expects.

It also helps during a gradual migration: wrap the old implementation in an adapter that satisfies the new interface, ship the new interface everywhere, and swap the real implementation later without anyone noticing.

The signal to look for is a shape mismatch, not a missing feature. Adapter does not add capability — the adaptee could already do the job.

When it hurts

If you own both sides of the interface, just change the interface directly instead of adding a translation layer to maintain forever. A pile of adapters is often a sign an interface needs redesigning, not patching around.

Watch for adapters that quietly grow business logic. An adapter’s job is translation only. Once it starts validating input or branching on business rules, it has become a hidden layer of application logic wearing an adapter’s name.

Practical tips

Default to the object adapter (composition) over the class adapter (inheritance).
Keep each adapter focused on one adaptee and one target interface.
Name and document what is being adapted — a short comment saves the next reader from tracing two classes.
Do not confuse Adapter with Facade: Adapter fixes a mismatch between two interfaces; Facade simplifies access to a subsystem whose interfaces already work fine.

Check your understanding

What is Adapter, in one sentence?
A class that translates one interface into another so two otherwise incompatible pieces of code can work together unchanged.

Object adapter vs. class adapter?
Object adapter holds the adaptee as a field and uses composition; class adapter extends the adaptee and uses inheritance. Prefer the object adapter for its flexibility.

When should you reach for Adapter?
When you cannot, or should not, modify one side of a mismatched interface — typically a third-party library, a legacy class, or an external API.

What is the biggest misuse of Adapter?
Letting it accumulate business logic instead of staying a pure translation layer.

What to learn next

Next: Decorator Pattern — add optional behavior to an object without touching its class or creating a mountain of subclasses.