The **composite [design pattern](https://www.educative.io/answers/design-patterns-in-java)** is used when two classes have a common parent, and one sibling can contain objects of its own and its sibling's type. For example, a *file* and a *folder* are types of data (parent abstract class), but a folder can contain many files and folders.

The composite design pattern is used to write less code because it uses *[polymorphism](https://www.educative.io/answers/what-is-polymorphism)* to execute code of the right class. There are three main parts of this design pattern:

1. **Component:** The abstract parent class.
2. **Leaf:** The child class, which is the smaller sibling and cannot contain anything (e.g., a *file*).
3. **Composite:** The child class which can contain itself and the *leaf* (e.g., a *folder*).

# UML diagram

#include <iostream>
#include <vector>

using namespace std;

// Component:
class Data{
private:
    int size;
public:
    // make the class abstract:
    virtual int getSize() = 0;
};

// Leaf:
class File: public Data{
private:
    int size;
public:
    File(int i){
        size = i;
    }
    int getSize(){
        return size;
    }
};

// Composite:
class Folder: public Data{
private:
    int size;
    vector<Data*> d;
public:
    int getSize(){
        int sum = 0;
        
        // Using polymorphism and recursion
        // to calculate the size of folder:
        for(int i = 0; i < d.size(); i++)
            sum = sum + (*(d.at(i))).getSize();
        
        return sum;
    }
    void add(Data* f){
        d.push_back(f);
    }
};

int main(){
    File f1(5), f2(10), f3(5), f4(10);
    
    Folder folder1;
    folder1.add(&f1);
    folder1.add(&f2);
    
    Folder folder2;
    folder2.add(&f3);
    
    folder1.add(&folder2);
    
    Folder folder3;
    folder3.add(&f4);
    
    // Print folder sizes:
    cout << "Folder 1 size: " << folder1.getSize()
    << endl << "Folder 3 size: " << folder3.getSize()
    << endl;
    
    return 0;
}


import java.util.ArrayList;

class CompositePattern {
	abstract class Data{
		int size;
		abstract int getSize();
	}
	class File extends Data{
		File(int i){
			size = i;
		}
		int getSize() {
			return size;
		}
	}
	class Folder extends Data{
		ArrayList<Data> d = new ArrayList<>();
		void add(Data f) {
			this.d.add(f);
		}
		int getSize() {
			int sum = 0;
			for(int i = 0; i < d.size(); i++)
				sum = sum + d.get(i).getSize();
			
			return sum;
		}
	}
	Folder folder1, folder2, folder3;
	File f1, f2, f3, f4;
	void createPattern() {
		// Folder 1 -> file1, file2 and folder2:
		folder1 = new Folder();
		f1 = new File(5);
		f2 = new File(10);
		folder1.add(f1);
		folder1.add(f2);
		
		folder2 = new Folder();
		f3 = new File(5);
		folder2.add(f3);
		
		folder1.add(folder2);
		
		// Folder 3 -> f4:
		folder3 = new Folder();
		f4 = new File(10);
		folder3.add(f4);
	}
	public static void main(String[] args) {
		CompositePattern cp = new CompositePattern();
		cp.createPattern();
		
		System.out.println("Folder 1 size: " + cp.folder1.getSize());
		System.out.println("Folder 3 size: " + cp.folder3.getSize());
	}
}


Java

class Data:
    pass


class File(Data):
    def __init__(self, i):
        self.size = i

    def get_size(self):
        return self.size


class Folder(Data):
    def __init__(self):
        self.dataList = []

    def add(self, d):
        self.dataList.append(d)

    def get_size(self):
        s = 0
        for x in range(len(self.dataList)):
            s = s + self.dataList[x].get_size()

        return s


f1 = File(5)
f2 = File(10)

folder1 = Folder()
folder1.add(f1)
folder1.add(f2)

folder2 = Folder()
f3 = File(5)
folder2.add(f3)

folder1.add(folder2)

folder3 = Folder()
f4 = File(10)
folder3.add(f4)

print("Folder 1 size: ", folder1.get_size())
print("Folder 3 size: ", folder3.get_size())


Python

What is the composite design pattern?

Facilitates managing hierarchies by treating individual objects and compositions uniformly, reducing code. Components: Component, Leaf, Composite. Example: File, Folder.

What is the composite design pattern?

UML diagram

Implementation