Composition in Java

In object-oriented programming (OOP), one of the most important principles is composition. It allows you to design flexible and modular programs by combining objects in a way that makes them more reusable and easier to maintain. In Java, composition is a key concept for creating complex systems by building objects using other objects.

In this blog post, we will delve into the concept of composition in Java, explain how it differs from inheritance, and provide examples to demonstrate its use and advantages.

What is Composition in Java?

Composition is a design principle in OOP where one class contains references to objects of other classes, essentially “composing” an object using other objects. This relationship between classes is often referred to as a has-a relationship.

In composition, a class is composed of one or more objects from other classes. Instead of inheriting the properties and behaviors of a superclass (as in inheritance), a class that uses composition includes the functionality of other classes through instance variables.

Composition vs. Inheritance

Both composition and inheritance allow you to build relationships between classes, but they serve different purposes and are used in different scenarios:

• Inheritance: This is when a class derives from another class, inheriting its properties and methods. It represents an is-a relationship. For example, a Dog class might inherit from an Animal class because a dog is an animal.
• Composition: In contrast, composition represents a has-a relationship. It implies that an object is made up of other objects. For example, a Car class might “have” an Engine and a Wheel because a car has an engine and wheels.

Why Use Composition?

• Flexibility: Composition allows greater flexibility in the design of your program. You can easily swap out one object for another, making the system more adaptable to change.
• Loose Coupling: Classes that use composition are often less tightly coupled, meaning that changing one class does not require changing others. This makes your code more maintainable and easier to extend.
• Code Reusability: Objects that are composed into other objects can be reused in multiple places, reducing code duplication.
• Avoids Inheritance Pitfalls: Overusing inheritance can lead to tightly coupled classes and inheritance hierarchies that are hard to manage. Composition helps avoid these issues.

How Composition Works in Java

In Java, composition is implemented by defining instance variables of one class inside another class. These instance variables are typically of types that represent other classes.

Here’s an example of how composition can be used in Java:

Example of Composition in Java

Let’s consider a real-world example of a Car class that contains instances of the Engine and Wheel classes. The car has an engine and wheels, which are components of a car. Here’s how we can implement this:

Step 1: Define the Component Classes

// Engine class
class Engine {
    private String model;
    
    public Engine(String model) {
        this.model = model;
    }
    
    public void start() {
        System.out.println("Engine " + model + " started.");
    }
}

// Wheel class
class Wheel {
    private String type;
    
    public Wheel(String type) {
        this.type = type;
    }
    
    public void rotate() {
        System.out.println("Wheel of type " + type + " is rotating.");
    }
}

Step 2: Define the Car Class Using Composition

class Car {
    private Engine engine; // Composition: Car "has a" Engine
    private Wheel[] wheels; // Car "has a" Wheel (Array of Wheels)
    
    public Car(Engine engine, Wheel[] wheels) {
        this.engine = engine;
        this.wheels = wheels;
    }
    
    public void drive() {
        engine.start(); // Starting the engine
        for (Wheel wheel : wheels) {
            wheel.rotate(); // Rotating each wheel
        }
        System.out.println("Car is driving.");
    }
}

Step 3: Create and Test the Objects

public class Main {
    public static void main(String[] args) {
        // Creating engine and wheel objects
        Engine engine = new Engine("V8");
        Wheel[] wheels = {
            new Wheel("Alloy"),
            new Wheel("Alloy"),
            new Wheel("Alloy"),
            new Wheel("Alloy")
        };

        // Creating the car object, passing engine and wheels as components
        Car car = new Car(engine, wheels);
        
        // Driving the car
        car.drive();
    }
}

Output:

Engine V8 started.
Wheel of type Alloy is rotating.
Wheel of type Alloy is rotating.
Wheel of type Alloy is rotating.
Wheel of type Alloy is rotating.
Car is driving.

Key Points About Composition in Java

1. No Inheritance Hierarchy: Unlike inheritance, composition does not create a hierarchical relationship. The Car class does not extend the Engine or Wheel classes; it simply contains instances of those classes.
2. Delegation: Composition often works with delegation, meaning that a class can delegate tasks to its composed objects. In the example above, the Car class delegates the behavior of starting the engine and rotating the wheels to the Engine and Wheel classes.
3. Object Composition: A class can compose multiple objects. In the example, a Car is composed of one Engine and four Wheel objects. Each of these objects provides specific functionality that the Car depends on.
4. Dynamic Behavior: One advantage of composition is that you can change the behavior of a class dynamically. For instance, you could change the type of engine or wheel in the Car without modifying the entire class.

When to Use Composition in Java

• When you want to avoid rigid inheritance structures: Inheritance can be too restrictive, leading to unnecessary dependencies. Composition offers more flexibility and a better solution when you need to build complex objects using smaller, reusable parts.
• When you want to model “has-a” relationships: If your class represents a “has-a” relationship rather than an “is-a” relationship, composition is the way to go. For example, a Person “has an” Address, while a Dog “is an” Animal.
• When you want greater modularity and reusability: Composition allows you to build objects from smaller, independent components. These components can often be reused in other parts of the program, making your code more modular and easier to maintain.

Conclusion

Composition is a powerful design concept in Java and OOP in general. It allows for greater flexibility, maintainability, and code reuse by enabling objects to be built from other objects. By understanding when and how to use composition, you can design more modular and adaptable systems.

While inheritance provides a way to create relationships between classes through shared behavior, composition provides a more flexible and maintainable approach by emphasizing the idea that one class can have another class, rather than be another class.

By practicing composition and applying it in real-world scenarios, you can create cleaner, more robust Java applications that are easier to scale and maintain.