What is composite design pattern and its advantages in java

What is composite design pattern?

The Composite Pattern is a structural design pattern that allows you to compose objects into tree structures to represent part-whole hierarchies. It lets clients treat individual objects and compositions of objects uniformly. This pattern is particularly useful when dealing with hierarchies of objects where clients need to treat individual objects and groups of objects uniformly.

Here’s a simple implementation in Java:

Example# 1:

import java.util.ArrayList;
import java.util.List;

// Component: Abstract class or interface representing both leaf and composite objects
interface OrderComponent {
    void display();
}

// Leaf: Represents individual items like Hammer, Receipt, Phone, Headphones, and Charger
class Item implements OrderComponent {
    private String name;

    public Item(String name) {
        this.name = name;
    }

    @Override
    public void display() {
        System.out.println("Item: " + name);
    }
}

// Composite: Represents a complex order that can contain individual items or other orders
class CompositeOrder implements OrderComponent {
    private List<OrderComponent> components = new ArrayList<>();
    private String orderName;

    public CompositeOrder(String orderName) {
        this.orderName = orderName;
    }

    public void addComponent(OrderComponent component) {
        components.add(component);
    }

    @Override
    public void display() {
        System.out.println("Order: " + orderName);

        // Display all components of the order
        for (OrderComponent component : components) {
            component.display();
        }

        System.out.println("End of Order: " + orderName);
    }
}

public class CompositePatternExample {
    public static void main(String[] args) {
        // Creating individual items
        OrderComponent hammer = new Item("Hammer");
        OrderComponent receipt = new Item("Receipt");
        OrderComponent phone = new Item("Phone");
        OrderComponent headphones = new Item("Headphones");
        OrderComponent charger = new Item("Charger");

        // Creating a composite order
        CompositeOrder complexOrder = new CompositeOrder("Complex Order");
        complexOrder.addComponent(hammer);
        complexOrder.addComponent(receipt);

        // Creating another composite order
        CompositeOrder electronicsOrder = new CompositeOrder("Electronics Order");
        electronicsOrder.addComponent(phone);
        electronicsOrder.addComponent(headphones);
        electronicsOrder.addComponent(charger);

        // Adding the electronics order to the complex order
        complexOrder.addComponent(electronicsOrder);

        // Displaying the entire complex order
        complexOrder.display();
    }
}

In this example:

• The OrderComponent interface represents both individual items and composite orders.
• The Item class is a leaf component representing individual items like a hammer, receipt, phone, headphones, and charger.
• The CompositeOrder class is a composite component representing a complex order that can contain individual items or other composite orders.
• The CompositePatternExample demonstrates how to create a complex order structure and display its contents, treating individual items and composite orders uniformly.

This pattern allows you to build complex structures while keeping the client code simple, as it can treat individual components and compositions of components in a uniform way.

Example# 2:

Let’s create a basic example using a graphic representation, where we have both simple graphic objects (like circles and squares) and composite graphic objects (like a group of circles or squares).

1. Define the Component Interface:

// Component interface
interface Graphic {
    void draw();
}

2. Create Leaf Implementations:

// Leaf implementations (individual graphics)
class Circle implements Graphic {
    @Override
    public void draw() {
        System.out.println("Drawing Circle");
    }
}

class Square implements Graphic {
    @Override
    public void draw() {
        System.out.println("Drawing Square");
    }
}

3. Create Composite Implementations:

// Composite implementations (groups of graphics)
class CompositeGraphic implements Graphic {
    private List<Graphic> graphics = new ArrayList<>();

    public void add(Graphic graphic) {
        graphics.add(graphic);
    }

    @Override
    public void draw() {
        System.out.println("Drawing Composite Graphic");
        for (Graphic graphic : graphics) {
            graphic.draw();
        }
    }
}

4. Client Code:

// Client code
public class CompositePatternExample {
    public static void main(String[] args) {
        // Use the Composite Pattern

        // Create individual graphic objects
        Graphic circle = new Circle();
        Graphic square = new Square();

        // Create a composite graphic object (group of graphics)
        CompositeGraphic compositeGraphic = new CompositeGraphic();
        compositeGraphic.add(circle);
        compositeGraphic.add(square);

        // Draw individual graphics and the composite graphic
        circle.draw();
        System.out.println("---");
        square.draw();
        System.out.println("---");
        compositeGraphic.draw();
    }
}

In this example:

• The Graphic interface is the component interface, declaring the draw method that all leaf and composite objects must implement.
• The Circle and Square classes are leaf implementations representing individual graphic objects.
• The CompositeGraphic class is a composite implementation representing a group of graphic objects. It can contain both individual graphic objects and other composite graphic objects.
• In the CompositePatternExample, we create individual graphic objects (Circle and Square) and a composite graphic object (CompositeGraphic) that contains both types. When we call the draw method on the composite graphic, it internally calls the draw method on all its components, whether they are leaf or composite objects.

This example illustrates how the Composite Pattern allows you to treat both individual objects and compositions of objects uniformly. It’s useful for creating complex hierarchies and structures in a way that clients can interact with them in a consistent manner.

advantages of Composite design Pattern in java

The Composite design pattern in Java offers several advantages that contribute to a more flexible and maintainable code structure. Here are some of the key advantages:

1. Uniform Treatment of Components: The primary advantage of the Composite pattern is that it enables clients to treat individual objects and compositions of objects uniformly. Clients can work with both leaf and composite components in a consistent manner.

2. Simplified Client Code: Clients don’t need to distinguish between leaf and composite components explicitly. This simplifies client code, as it can interact with complex structures without worrying about the specific types of objects being handled.

3. Flexibility and Extensibility: The Composite pattern allows you to create complex structures by composing objects in a tree-like hierarchy. New components (leaf or composite) can be added to the structure without requiring changes to existing client code.

4. Recursive Composition: The pattern supports recursive composition, meaning that a composite object can contain other composite objects, leading to the creation of hierarchical structures. This is particularly useful when dealing with nested or hierarchical relationships between objects.

5. Code Reusability: Both leaf and composite components share a common interface (the component interface), promoting code reusability. Common operations can be defined at the component level, and they are automatically applicable to both leaf and composite components.

6. Improved Maintenance: The Composite pattern makes it easier to maintain code because changes to the structure can often be localized. Adding, removing, or modifying components within a composite structure can be done without affecting the rest of the system.

7. Composite Operations: Composite components can define operations that make sense at the composite level. For example, a composite order may have a calculateTotalCost() method that recursively calculates the total cost of all items in the order, regardless of whether they are individual items or sub-orders.

8. Encapsulation of Complexity: The pattern encapsulates the complexity of managing a tree structure. Clients are shielded from the details of how individual components are organized and can focus on interacting with the structure as a whole.

9. Supports the Open/Closed Principle: The Composite pattern supports the Open/Closed Principle, as new types of components can be added to the system without modifying existing code. This makes the system more extensible and less prone to errors.

10. Useful for GUIs and Document Structures: The Composite pattern is commonly used in graphical user interface frameworks and document structures where elements can be nested or composed to create complex layouts.

In summary, the Composite design pattern provides a powerful mechanism for creating hierarchical structures of objects while allowing clients to treat individual objects and compositions uniformly. It promotes flexibility, extensibility, and code reusability, making it a valuable pattern in software design.