Composite Design Pattern in Kotlin

1. Definition

The Composite Design Pattern is a structural design pattern that lets you compose objects into tree structures to represent part-whole hierarchies. Composite treats individual objects and compositions of objects uniformly, allowing clients to use single objects and compositions of objects uniformly.

2. Problem Statement

Imagine you have a GUI system. In this system, you have elements like Button, Text, and Panel. While Button and Text are singular elements, a Panel can contain multiple elements (including other Panels). The problem arises when you want to perform operations (like rendering) on these elements. The challenge is to treat both single elements and compositions uniformly.

3. Solution

The Composite pattern suggests that you should represent both simple elements and complex elements with the same interface. This way, you can build structures that can be treated uniformly, whether it's an individual object or a composition.

4. Real-World Use Cases

1. GUI components in software where each component might be a singular element or a composition.

2. File system implementations, where each entry can be a file (single element) or a directory (composition of files or other directories).

3. Organizational structures where an entity could be an employee or a department containing multiple entities.

5. Implementation Steps

1. Define a common component interface.

2. Create leaf objects that implement this component interface.

3. Create composite objects (containers) that also implement this component interface and can store child components.

6. Implementation in Kotlin

// Step 1: Common Component Interface
interface GraphicElement {
    fun render()

// Step 2: Leaf Objects
class Text : GraphicElement {
    override fun render() {
        println("Rendering Text")

class Button : GraphicElement {
    override fun render() {
        println("Rendering Button")

// Step 3: Composite Object
class Panel : GraphicElement {
    private val children = mutableListOf<GraphicElement>()

    fun add(element: GraphicElement) {

    override fun render() {
        println("Rendering Panel")
        for (child in children) {

fun main() {
    val text = Text()
    val button = Button()
    val panel = Panel()


    // Treating both single elements and compositions uniformly


Rendering Text
Rendering Button
Rendering Panel
Rendering Text
Rendering Button


1. A common interface GraphicElement is established to treat both simple and complex objects uniformly.

2. Leaf objects (Text and Button) provide their specific implementations for the render method.

3. The composite object (Panel) contains a collection of GraphicElement objects and implements the render method by iterating over its children and invoking their render method.

4. In the main function, we demonstrate how individual elements (text and button) can be rendered directly. Additionally, we show how a composition (panel) can also be rendered uniformly.

7. When to use?

Use the Composite pattern when:

1. You want to represent part-whole hierarchies.

2. You want clients to treat individual objects and compositions uniformly.

3. Your hierarchy contains both simple and complex objects.

By leveraging the Composite pattern, you ensure a unified way to interact with individual objects and their compositions, making your code more generic and easier to maintain.