Introduction

The Composite design pattern is a structural pattern used to treat individual objects and compositions of objects uniformly. It enables you to represent part-whole hierarchies, making it easier to work with tree-like structures.

In this tutorial, we will explore the Composite pattern in Java with a detailed example and explanation.

Key Concepts of Composite Pattern

Components of the Composite Pattern

• Component: An abstract base class or interface that declares common operations for both individual objects and their compositions.
• Leaf: Represents the end objects in the composition. A leaf object does not have any children.
• Composite: A container for leaf objects and other composite objects. It implements operations defined in the Component interface and forwards the requests to its children.

Benefits

• Simplifies client code by providing a unified interface.
• Makes it easier to add new component types.
• Supports recursive structures like trees.

Example: Composite Pattern in Action

Let’s implement a file system simulation where files and folders are treated uniformly.

Step 1: Define the Component Interface

The Component interface declares common methods for both files and folders.

public interface FileSystemComponent {
    void showDetails();
}

Step 2: Implement the Leaf Class

The Leaf class represents individual files in the file system.

public class File implements FileSystemComponent {

    private final String name;

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

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

Step 3: Implement the Composite Class

The Composite class represents a folder that can contain files and other folders.

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

public class Folder implements FileSystemComponent {

    private final String name;
    private final List<FileSystemComponent> components = new ArrayList<>();

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

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

    public void removeComponent(FileSystemComponent component) {
        components.remove(component);
    }

    @Override
    public void showDetails() {
        System.out.println("Folder: " + name);
        for (FileSystemComponent component : components) {
            component.showDetails();
        }
    }
}

Step 4: Use the Composite Pattern in a Client

The client code interacts with FileSystemComponent without worrying about whether it’s dealing with a file or folder.

public class CompositePatternDemo {

    public static void main(String[] args) {
        // Create files
        File file1 = new File("file1.txt");
        File file2 = new File("file2.txt");
        File file3 = new File("file3.txt");

        // Create folders and add files
        Folder folder1 = new Folder("Folder1");
        folder1.addComponent(file1);
        folder1.addComponent(file2);

        Folder folder2 = new Folder("Folder2");
        folder2.addComponent(file3);

        // Create root folder
        Folder rootFolder = new Folder("Root");
        rootFolder.addComponent(folder1);
        rootFolder.addComponent(folder2);

        // Display details
        rootFolder.showDetails();
    }
}

Output of the Program

When you run the CompositePatternDemo class, you will get the following output:

Folder: Root
Folder: Folder1
File: file1.txt
File: file2.txt
Folder: Folder2
File: file3.txt

How It Works

• The File class represents individual files, while the Folder class represents collections of files and folders.
• The showDetails method in the Folder class iterates over its children and calls their showDetails method recursively.
• The client code interacts with the FileSystemComponent interface, making it agnostic to whether it’s dealing with a file or folder.

Advantages and Disadvantages

Advantages

• Simplifies client code by treating leaf and composite objects uniformly.
• Supports easily adding new component types (e.g., new types of files or folders).
• Facilitates working with hierarchical structures such as file systems, graphical interfaces, or organizational charts.

Disadvantages

• Can make the design more complex by introducing multiple classes.
• May require additional effort to enforce constraints (e.g., ensuring a folder can’t be added to itself).

When to Use the Composite Pattern

• When you need to represent part-whole hierarchies.
• When you want clients to treat individual objects and composite objects uniformly.
• When you’re working with recursive structures like trees.

Real-World Examples of Composite Pattern

• File Systems: Files and directories.
• UI Frameworks: Widgets containing other widgets.
• Graphics Rendering: Groups of shapes treated as a single shape.
• Organization Charts: Employees and departments.