Adaptor design patterns.

Two incompatible interfaces or systems can cooperate by using the adapter design pattern, a structural design pattern. Because of incompatible interfaces, it serves as a bridge between two classes that would not otherwise be able to communicate. The adapter approach is very helpful when attempting to incorporate third-party libraries or legacy code into a new system.


Real-World Example of Adapter Design Pattern

Let’s understand this concept using a simple example:

Suppose you have two buddies, one of them speaks French exclusively and the other English exclusively. The language barrier prevents them from communicating the way you want them to.

  • You act as an adapter, translating messages between them. Your role allows the English speaker to convey messages to you, and you convert those messages into French for the other person.
  • In this way, despite the language difference, your adaptation enables smooth communication between your friends.
  • This role you play is similar to the Adapter design pattern, bridging the gap between incompatible interfaces.

Scenario:

You have an app that expects to print text using a Printer interface.
But you found an old class called OldPrinter that doesn't fit your Printer interface.
You want to adapt it!

1. Target Interface (what the app expects)

java
public interface Printer {
    void print(String message);
}

2. Adaptee (the old class)

java
public class OldPrinter {
    public void oldPrintMethod(String text) {
        System.out.println("Old Printer: " + text);
    }
}

3. Adapter

java
public class PrinterAdapter implements Printer {
    private OldPrinter oldPrinter;

    public PrinterAdapter(OldPrinter oldPrinter) {
        this.oldPrinter = oldPrinter;
    }

    @Override
    public void print(String message) {
        oldPrinter.oldPrintMethod(message);  // adapt the call
    }
}

4. Client Code

java
public class Main {
    public static void main(String[] args) {
        OldPrinter oldPrinter = new OldPrinter();
        Printer printer = new PrinterAdapter(oldPrinter);  // adapt OldPrinter to Printer

        printer.print("Hello, World!");  // works through adapter
    }
}

✨ Output:

sql
Old Printer: Hello, World!

Comments

Post a Comment

Popular posts from this blog

Archunit test

  ArchUnit  integrates nicely with the  JUnit  test framework, and so, they are typically used together.  All we have to do is add the  archunit-junit 5  dependency to match our  JUnit  version: < dependency > < groupId > com.tngtech.archunit </ groupId > < artifactId > archunit-junit5 </ artifactId > < version > 0.14.1 </ version > < scope > test </ scope > </ dependency > Step 1: The first step is to create a set of Java classes that will be checked for rules violations . We do this by instantiating the  ClassFileImporter  class and then using one of its  importXXX()  methods: JavaClasses jc = new ClassFileImporter () .importPackages( "com.baeldung.archunit.smurfs" ); Step 2:  Let’s try to implement the first rule defined above using this API. We’ll use the  classes()  method as our anchor and add additional constraints ...
Read more

visitor design pattern

Image
  The Visitor design pattern is a  behavioral pattern  that allows you to add new operations to a group of related classes without modifying their structures. Real-World Example of Visitor Design Pattern A simple example of the Visitor design pattern is in an online shopping cart. Imagine you have different items like books, electronics, and clothing. Each item can accept a visitor that performs actions like calculating the total price or applying discounts. This way, you can add new features without changing the item classes, making the system easier to maintain and update. UML Class Diagram of Visitor design pattern Components of Visitor Design Pattern The Visitor design pattern consists of several key components that work together to enable its functionality. Here’s a breakdown of these components: Visitor Interface : This interface declares a visit method for each type of element in the object structure. Each method is designed to handle a specific element type. Concr...
Read more

Observer design pattern

Image
Observer Design Pattern Example To understand observer design pattern, lets take an example: Consider a scenario where you have a weather monitoring system. Different parts of your application need to be updated when the weather conditions change. Challenges or difficulties while implementing this system without Observer Design Pattern Components interested in weather updates would need direct references to the weather monitoring system, leading to  tight coupling . Adding or removing components that react to weather changes requires modifying the core weather monitoring system code, making it hard to maintain. How Observer Pattern helps to solve above challenges? The Observer Pattern facilitates the decoupling of the weather monitoring system from the components that are interested in weather updates (via interfaces). Every element can sign up as an observer, and observers are informed when the weather conditions change. The weather monitoring system is thus unaffected by the add...
Read more