Composite Design Pattern Java

The composite design pattern is a design pattern that allows us to arrange objects in a tree structure to represent a part-whole design. It allows customers to handle individual items and packages with precision. Simply put, it allows us to work with individual objects as well as sets of objects on a regular basis.

Features of Composite Design Pattern

Components:

It is an abstract class or interface that declares a common interface for all concrete classes. It can be an interface or an abstract class with methods that define generic operations.

public interface Component {
    void operation();
}

leaf:

The leaf class represents individual objects that have no children. It uses the functionality defined by the Component interface.

public class Leaf implements Component {
    @Override
    public void operation() {
        // Leaf-specific operation
    }
}

Composite:

The Composite magnificence represents the composite items that may have children. It implements the operations declared by the Component interface and can also outline operations for adding and putting off children.

import java.util.ArrayList;
import java.util.List;
public class Composite implements Component {
    private List<Component> children = new ArrayList<>();
    public void add(Component component) {
        children.add(component);
    }
    public void remove(Component component) {
        children.remove(component);
    }
    @Override
    public void operation() {
        // Composite-specific operation
        for (Component component : children) {
            component.operation();
        }
    }
}

How does it work?

Composite pattern allows customers to handle individual items and packages in the same way. Customers can use the same types of functionality without having to distinguish between Leaf and Composite objects. It is achieved by defining a common interface (Component) and having it used by the Leaf and Composite classes.

Implementation of Composite Design Pattern in Java

Let's go through a simple example to illustrate the use of Composite Design Pattern in Java. Suppose, we want to model a corporate structure, where individual employees and departments can be treated equally.

public interface CompanyComponent {
    void showDetails();
}
// Leaf
public class Employee implements CompanyComponent {
    private String name;
    public Employee(String name) {
        this.name = name;
    }
    @Override
    public void showDetails() {
        System.out.println("Employee: " + name);
    }
}
// Composite
import java.util.ArrayList;
import java.util.List;
public class Department implements CompanyComponent {
    private String name;
    private List<CompanyComponent> employees = new ArrayList<>();
    public Department(String name) {
        this.name = name;
    }
    public void addEmployee(CompanyComponent employee) {
        employees.add(employee);
    }
    @Override
    public void showDetails() {
        System.out.println("Department: " + name);
        for (CompanyComponent employee : employees) {
            employee.showDetails();
        }
    }
}

Now, we can use the Composite pattern to create a company hierarchy that includes both individual employees and departments.

Client.java

public class Client {
    public static void main(String[] args) {
        Employee emp1 = new Employee("Manoj Mamilla");
        Employee emp2 = new Employee("Kamal bittu");
        Department engineering = new Department("Engineering");
        engineering.addEmployee(new Employee("Narasimha Rao"));
        engineering.addEmployee(new Employee("Manoj kumar"));
        Department marketing = new Department("Marketing");
        marketing.addEmployee(new Employee("Pradeep marchi"));
        Department company = new Department("Tejas Cropo");
        company.addEmployee(emp1);
        company.addEmployee(emp2);
        company.addEmployee(engineering);
        company.addEmployee(marketing);
        company.showDetails();
    }
}

Output:

Department: Tejas Corpo
Employee: Manoj Mamilla
Employee: Kamal bittu
Department: Engineering
Employee: Narasimha Rao
Employee: Manoj kumar
Department: Marketing
Employee: Pradeep marchi

Real-World Applications

Image systems

Consider a graphical layout in which we have to create shapes such as circles, triangles, and rectangles. Using a composite pattern allows us to treat individual shapes and compositions as one.

Client.java

import java.util.ArrayList;
import java.util.List;
// Component
public interface Shape {
    void draw();
}
// Leaf
public class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing Circle");
    }
}
// Leaf
public class Square implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing Square");
    }
}
// Composite
public class CompositeShape implements Shape {
    private List<Shape> shapes = new ArrayList<>();
    public void addShape(Shape shape) {
        shapes.add(shape);
    }
    @Override
    public void draw() {
        for (Shape shape : shapes) {
            shape.draw();
        }
    }
}
public class Client {
    public static void main(String[] args) {
        Circle circle = new Circle();
        Square square = new Square();
        CompositeShape compositeShape = new CompositeShape();
        compositeShape.addShape(circle);
        compositeShape.addShape(square);
        compositeShape.draw();
    }
}

Output:

Drawing Circle
Drawing Square

Advantages of Composite Designs Patterns

Similarities: Consumers can view individual products and packages as one.
Simplified customer rules: Clients do not need to distinguish between Leaf and Composite classes, resulting in simplified client code.
Simple modifications: The pattern allows new features to be added without modifying the existing client code.
Repeatable Scheduling: The model supports repetitive compositions, allows us to create complex layouts.

The composite design pattern in Java is a powerful tool for creating hierarchical structures that can be transformed into a composite. By understanding its components and usage, we can increase the flexibility, maintainability, and readability of the code. Whether we work with graphical systems, file systems, or any other application that involves part-whole hierarchies, Composite pattern is a valuable addition to our design pattern toolbox.

Next TopicDefault and Static Methods in Interface Java 8

← prev next →