The Composite design pattern facilitates the composition of objects into tree structures, enabling the manipulation of these structures as if the

Composite Design Pattern

The Composite design pattern is a structural pattern used in software engineering to compose objects into tree-like structures to represent part-whole hierarchies. It allows clients to treat individual objects and compositions of objects uniformly.

Key Components:

  1. Component: Defines the common interface for both leaf and composite objects. It typically declares methods for accessing and managing children and may include default implementations for common operations.

  2. Leaf: Represents the individual objects in the composition. These are the building blocks that don't have children.

  3. Composite: Contains other components, including both leaves and other composites. It implements methods to manipulate children's components.


Let's illustrate the Composite pattern with a file system representation consisting of directories and files.

// Component
interface FileSystemComponent {
    void display();

// Leaf
class File implements FileSystemComponent {
    private String name;

    public File(String name) { = name;

    public void display() {
        System.out.println("File: " + name);

// Composite
class Directory implements FileSystemComponent {
    private String name;
    private List<FileSystemComponent> components;

    public Directory(String name) { = name;
        components = new ArrayList<>();

    public void addComponent(FileSystemComponent component) {

    public void removeComponent(FileSystemComponent component) {

    public void display() {
        System.out.println("Directory: " + name);
        for (FileSystemComponent component : components) {

In this example:

  • FileSystemComponent is the component interface.

  • File is a leaf component representing individual files.

  • Directory is a composite component representing directories. It can contain both files and other directories.

Now, let's create a file system structure:

public class Main {
    public static void main(String[] args) {
        Directory root = new Directory("Root");

        Directory documents = new Directory("Documents");
        documents.addComponent(new File("Resume.docx"));
        documents.addComponent(new File("Presentation.pptx"));

        Directory pictures = new Directory("Pictures");
        pictures.addComponent(new File("Family.jpg"));
        pictures.addComponent(new File("Vacation.jpg"));



Directory: Root
Directory: Documents
File: Resume.docx
File: Presentation.pptx
Directory: Pictures
File: Family.jpg
File: Vacation.jpg

In this example, we demonstrated the Composite pattern by representing a file system structure. The Directory class acts as a composite that can contain both files and directories, while the File class represents individual files. This pattern allows for a unified treatment of files and directories, making client code simpler and more manageable.