Introduction to the Composite Pattern in Scala

Introduction to the Composite Pattern

Welcome to the second lesson of our "Structural Patterns in Scala" course! 🎉 In the previous lesson, we explored the Adapter Pattern, which enables incompatible interfaces to work harmoniously. Today, we are diving into another significant structural pattern: the Composite Pattern . This pattern helps create complex structures through object composition, arranging them into tree-like models that capture part-whole hierarchies. Think of its applications in scenarios like organizational charts, file directories, or graphical user interfaces where individual components and composite structures need consistent handling.

Understanding the Composite Pattern

To grasp the Composite Pattern, let's imagine an organizational tree at a tech company. Consider a tech company where you have various types of employees. At the lowest level, you have individual contributors like developers. At the mid-level, you have managers who manage these individual contributors, and at the top level, you have directors who manage multiple managers.

Hierarchical Structure Representation

In the organizational tree of this example: Developer (Leaf Node): These are the indivisible elements of the hierarchy, akin to the terminal nodes in a tree, tasked with specific jobs. Manager (Composite Node): These elements represent branches that gather and manage multiple leaves (developers) and other branches (subordinate managers). Director (Higher-Level Composite Node): Directors oversee multiple branches (managers). Here's how it may look in practice: Director ├── Manager A │ ├── Developer 1 │ └── Developer 2 ├── Manager B │ ├── Developer 3 │ └── Manager C │ ├── Developer 4 │ └── Developer 5

Propagation of Function Calls

The strength of the Composite Pattern lies in its function call propagation. When a showDetails method is called on a director, it triggers the showDetails method of the managers, which in turn call the showDetails methods of the developers. This allows for treating individual and composite objects uniformly. This Composite approach allows you to build complex structures by composing objects into tree-like hierarchies, making your code more robust and flexible. This approach is different from inheritance, which does not inherently facilitate part-whole hierarchies.

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Scala

// Define a trait for Employee
trait Employee:
  // An abstract method to show employee details
  def showDetails(): Unit

// Define a trait for Employee
trait Employee:
  // An abstract method to show employee details
  def showDetails(): Unit

Scala

// Define a Developer class inheriting from Employee
class Developer(name: String, position: String) extends Employee:
  // Override method to provide developer details
  def showDetails(): Unit =
    println(s"$name works as $position.")

Scala

// Define a Manager class inheriting from Employee
class Manager extends Employee:
  // Immutable List to track the employees managed by the manager
  private var employees: List[Employee] = List()

  // Method to add an employee to the manager's list
  def add(employee: Employee): Unit =
    employees = employee :: employees

  // Method to remove an employee from the manager's list
  def remove(employee: Employee): Unit =
    employees = employees.filterNot(_ == employee)

  // Override method to provide details of all managed employees
  def showDetails(): Unit =
    employees.foreach(_.showDetails())

// Define a Manager class inheriting from Employee
class Manager extends Employee:
  // Immutable List to track the employees managed by the manager
  private var employees: List[Employee] = List()

  // Method to add an employee to the manager's list
  def add(employee: Employee): Unit =
    employees = employee :: employees

  // Method to remove an employee from the manager's list
  def remove(employee: Employee): Unit =
    employees = employees.filterNot(_ == employee)

  // Override method to provide details of all managed employees
  def showDetails(): Unit =
    employees.foreach(_.showDetails())

Scala

@main def main(): Unit =
  // Create Developer instances with given names and positions
  val dev1 = Developer("John Doe", "Senior Developer")
  val dev2 = Developer("Jane Smith", "Junior Developer")
  
  // Create a Manager instance
  val manager = Manager()
  
  // Add developers to the manager's list
  manager.add(dev1)
  manager.add(dev2)
  
  // Show details of all employees managed by the manager
  manager.showDetails()

@main def main(): Unit =
  // Create Developer instances with given names and positions
  val dev1 = Developer("John Doe", "Senior Developer")
  val dev2 = Developer("Jane Smith", "Junior Developer")
  
  // Create a Manager instance
  val manager = Manager()
  
  // Add developers to the manager's list
  manager.add(dev1)
  manager.add(dev2)
  
  // Show details of all employees managed by the manager
  manager.showDetails()

Scala

// Define a trait for Employee
trait Employee:
  // An abstract method to show employee details
  def showDetails(): Unit

Scala

// Define a Developer class inheriting from Employee
class Developer(name: String, position: String) extends Employee:
  // Override method to provide developer details
  def showDetails(): Unit =
    println(s"$name works as $position.")

Scala

// Define a Manager class inheriting from Employee
class Manager extends Employee:
  // Immutable List to track the employees managed by the manager
  private var employees: List[Employee] = List()

  // Method to add an employee to the manager's list
  def add(employee: Employee): Unit =
    employees = employee :: employees

  // Method to remove an employee from the manager's list
  def remove(employee: Employee): Unit =
    employees = employees.filterNot(_ == employee)

  // Override method to provide details of all managed employees
  def showDetails(): Unit =
    employees.foreach(_.showDetails())

Scala

@main def main(): Unit =
  // Create Developer instances with given names and positions
  val dev1 = Developer("John Doe", "Senior Developer")
  val dev2 = Developer("Jane Smith", "Junior Developer")
  
  // Create a Manager instance
  val manager = Manager()
  
  // Add developers to the manager's list
  manager.add(dev1)
  manager.add(dev2)
  
  // Show details of all employees managed by the manager
  manager.showDetails()

Introduction to the Composite Pattern

Understanding the Composite Pattern

Hierarchical Structure Representation

Propagation of Function Calls

Join the 1M+ learners on CodeSignal

Initial Setup

Creating Individual Employees

Creating a Manager to Manage Employees

Putting it All Together

Conclusion