All 15 Design Patterns in Java questions
More in Design Patterns in Java
What is the Factory Method pattern's simplest form -- a basic static factory returning different subtype instances based on input -- and why might you prefer it over exposing constructors directly? How does the Builder pattern solve the "telescoping constructor" problem, and how would you implement it for a class with many optional parameters? What is the Strategy pattern, and how do Java 8's functional interfaces and lambdas make implementing it significantly more concise than the traditional interface-plus-implementation-classes approach? What is the Factory Method pattern, and how does it differ from the simpler Static Factory Method idiom (like List.of() or Optional.of())? What is the Template Method pattern, and how is it used to define the skeleton of an algorithm while letting subclasses customize specific steps? What is the difference between composition and inheritance as ways to reuse code, and why does the design principle "favor composition over inheritance" generally guide modern Java design (including many design patterns themselves)? How would you implement the Composite pattern to treat individual objects and groups of objects uniformly, such as a file system with files and directories? How would you implement the Observer pattern in Java, and how does it compare to using the built-in PropertyChangeSupport or a reactive streams library? How would you implement the Decorator pattern in Java, and how does java.io's InputStream/OutputStream class hierarchy exemplify this pattern in the JDK itself? How would you implement the Dependency Injection pattern manually (without a framework like Spring) using constructor injection, and what testability benefits does this provide?
Advertisement
Back to results for “OOP”
Java › Design Patterns in Java

What is the Adapter pattern, and when would you use it to make an existing class compatible with an interface it wasn't originally designed to implement?

Intermediate

Answer

Adapter wraps an existing class (with an incompatible interface) inside a new class that implements the interface your code actually needs, translating calls between the two -- commonly used when integrating a third-party library or legacy class whose API doesn't match what your code expects, letting you avoid modifying the original class (which you may not even have access to modify) while still making it usable wherever the target interface is expected.
// Third-party class with an incompatible interface you can't modify
class LegacyRectangle {
    void oldDraw(int x1, int y1, int x2, int y2) { /* ... */ }
}

// Your application's expected interface
interface Shape { void draw(); }

// Adapter bridges the two
class RectangleAdapter implements Shape {
    private final LegacyRectangle legacy;
    private final int x, y, width, height;
    public RectangleAdapter(LegacyRectangle legacy, int x, int y, int w, int h) {
        this.legacy = legacy; this.x = x; this.y = y; this.width = w; this.height = h;
    }
    public void draw() { legacy.oldDraw(x, y, x + width, y + height); }
}
Real-world example A modern application integrating a legacy third-party billing library (with an API predating the application's own PaymentProcessor interface) wraps the legacy library's class in an Adapter implementing PaymentProcessor, letting the rest of the codebase interact with it through the consistent modern interface without any changes to the legacy library itself.

Common follow-ups: How does the Adapter pattern differ from the Facade pattern, given both seem to 'wrap' existing functionality?;What's the difference between a class adapter (using inheritance) and an object adapter (using composition) approach?

Interfaces & Abstract Classes;OOP & Classes
All 15 Design Patterns in Java questions