All 15 Design Patterns in Java questions
More in Design Patterns in Java
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 Adapter pattern, and when would you use it to make an existing class compatible with an interface it wasn't originally designed to implement? What is the Template Method pattern, and how is it used to define the skeleton of an algorithm while letting subclasses customize specific steps? 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? How would you implement the Visitor pattern in Java to add new operations to an existing class hierarchy without modifying those classes, and how do Java's sealed classes and pattern matching (switch expressions) provide a modern alternative? How would you use the Chain of Responsibility pattern to implement a request-processing pipeline (such as middleware-style validation/authentication/logging), and how does this relate conceptually to servlet filters or web framework middleware?
Advertisement
Back to results for “Design Patterns in Java”
Java › Design Patterns in Java

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)?

Intermediate

Answer

Inheritance creates a tight, static "is-a" coupling between a subclass and its superclass (fixed at compile time, exposing all of a superclass's protected/public members and behavior, including behavior the subclass might not want, a problem known as the fragile base class problem where superclass changes can unexpectedly break subclasses); composition instead builds behavior by holding references to other objects (a "has-a" relationship) and delegating to them, which can be reconfigured at runtime, exposes only the specific behavior you choose to delegate, and avoids fragile base class issues entirely -- many design patterns (Strategy, Decorator, Composite) exist specifically as composition-based alternatives to what inheritance-based designs would otherwise attempt, which is why "favor composition over inheritance" is such a widely cited principle in object-oriented design.
// Inheritance-based (rigid, exposes ALL of Vehicle's behavior, fixed at compile time)
class Car extends Vehicle { }

// Composition-based (flexible, exposes only what Car chooses to delegate, reconfigurable at runtime)
class Car {
    private final Engine engine;  // composition: Car "has-a" Engine
    public Car(Engine engine) { this.engine = engine; }
    public void start() { engine.start(); }  // delegates, exposing only what Car chooses to
}
Real-world example A vehicle simulation initially modeled with deep inheritance hierarchies (ElectricCar extends Car extends Vehicle) is refactored to use composition instead (Car holds an Engine interface reference), letting the same Car class be reconfigured with different engine implementations at runtime and avoiding the fragile base class problems the original rigid inheritance hierarchy had caused as requirements evolved.

Common follow-ups: What specific problems does the 'fragile base class' issue cause in practice as a codebase evolves over time?;In what scenarios is inheritance still the genuinely correct and appropriate choice over composition?

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