Adapter Pattern and Java example

This is a pattern which helps you put a square peg in a round hole. Sound impossible? Not when we have Adapter.

The Adapter Pattern converts the interface of a class into another interface the clients expect.

In fact, Adapter all around us!!! You'll have no trouble understanding what an OO adapter is because the real world is full of them. This is an example:


So if it walks like a duck and quacks like a duck, then it might not be a duck but a turkey wrapped with a duck adapter.


It's time to see an adapter in action. I will create a simple interface of the Duck.

public interface Duck {
    public void quack();

    public void fly();

And here's a subclass of Duck, the VietnamDuck.

public class VietnamDuck implements Duck {
    public void quack() {

    public void fly() {
        System.out.println("I'm flying");

I create a new animal: WildTurkey

public interface Turkey {
    public void gobble();

    public void fly();

public class WildTurkey implements Turkey {
    public void gobble() {

    public void fly() {
        System.out.println("I'm flying a short distance");

Now we have some Duck objects and you'd like to use some Turkey objects in their places. Obviously we can't use the turkeys outright because they have a different interface.

So let's write an Adapter

// First, you need to implement the interface of the type you're adapting to.
// This is the interface your client expects to see.
public class TurkeyAdapter implements Duck {
    Turkey turkey;

    // we need to get a reference to the object that we are adapting
    // here we do that through the constructor
    public TurkeyAdapter(Turkey turkey) {
        this.turkey = turkey;

    // now we need to implement all the methods in the interface;
    // turkey can't do long-distance flying like ducks, so we call 5 times
    public void fly() {
        for (int i = 0; i < 5; i++) {

    // translate from quack to gobble method
    public void quack() {

Test the adapter

Now we just need some code to test drive our adapter:

public class DuckTest {

    // this is a client is implemented against the target interface
    static void testDuck(Duck duck) {

    public static void main(String[] args) {

        // let's create a Duck and a Turkey
        VietnamDuck duck = new VietnamDuck();
        WildTurkey turkey = new WildTurkey();

        // And then wrap the turkey in a TurkeyAdapter, which makes it look like a Duck
        Duck turkeyAdapter = new TurkeyAdapter(turkey);

        System.out.println("The Turkey says ...");

        // using testDuck method which expects a Duck object input
        System.out.println("\nThe Duck says ...");

        // now we try to pass off the turkey as a duck...
        System.out.println("\nThe TurkeyAdapter says ...");


Let's run it and see...


I could explain about how the Client uses the Adapter

  1. The client makes a request to the adapter by calling a method on it using the target interface.
  2. The adapter translates the request into one or more calls on the adaptee using the adaptee interface.

    • The Adapter implements the target interface and holds an instance of the Adaptee.

      Eg: TurkeyAdapter implemented the target interface, Duck. And Turkey was the adaptee interface.

  3. The client receives the results of the call and never knows there is an adapter doing the translation.


Adapter makes your software more flexible.

Now despite having defined the pattern, we haven't told you the whole story yet. There are actually two kinds of adapters: object adapters and class adapters. But I will cover it in another post :)))

See yahh!!!