If you look at the definition of this design pattern on websites like Wikipedia, you could be a little bit confused. First time when I was reading about this pattern I stopped read and I just thinking wait what, what this pattern do? After looking at practical examples I started to understand it.
In this post, you can find:
- example situation when to use a Composite design pattern
- Composite pattern code structure in Java
- example how to use the Composite pattern
If your application needs to manipulate the hierarchy of objects that have various types of complexifying, you probably should use this pattern. The common example of this is the directory tree. You have directories and files. The file is written with the pattern: name + new line. Writing the directory is more complicated. After the name and new line, command display some space and then every file or directory in this directory is written with this space.
Composite pattern example in Java
In this post, I want to show you simple Composite pattern Java code. We would have something like directory tree from the above example. We have music, music has genres like rock and we have artists that play rock music. Artist has albums with songs on them. Hope you see this hierarchy that we would create. Songs are like files in the previous example.
Interface
|
1 2 3 |
public interface AbstractItem { void ls(); } |
We would implement this interface in all classes. Name that I used is from Linux command used to list directory content (just saying it, if you don’t know the Linux command line).
Classes
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
public class Song implements AbstractItem { private String name; public Song(String name) { this.name = name; } @Override public void ls() { System.out.println(Client.compositeBuilder + name); } } |
Very simple class, we create an object, single item and implement ls() function and print Client class property with song name (listing of Client class you can see below).
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
public class Group implements AbstractItem { private String name; private ArrayList<Object> includedItems = new ArrayList<>(); public Group(String name) { this.name = name; } public void add(Object obj) { includedItems.add(obj); } @Override public void ls() { System.out.println(Client.compositeBuilder + name); Client.compositeBuilder.append(" "); for (Object includedItem : includedItems) { AbstractItem obj = (AbstractItem) includedItem; obj.ls(); } Client.compositeBuilder.setLength(Client.compositeBuilder.length()); } } |
Group is also a single item like Song but it can have items in it. We have ArrayList and method to add items to it. Method ls() is more complicated as you can see, we iterate array and running ls() function on its objects.
Client class
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
public class Client { static StringBuffer compositeBuilder = new StringBuffer(); public static void main(String[] args) { Group music = new Group("Music"); Group rock = new Group("Rock"); Group acdc = new Group("AC/DC"); Group theRazorEdge = new Group("The Razor Edge"); Song track1 = new Song("Rock or Bust"); Song track2 = new Song("Shake It Off"); Song track3 = new Song("Thunderstruck"); Song track4 = new Song("Fire Your Guns"); music.add(track2); music.add(rock); rock.add(acdc); acdc.add(track1); acdc.add(theRazorEdge); theRazorEdge.add(track3); theRazorEdge.add(track4); music.ls(); } } |
Console output:
Here, we have StringBuffer that contains a string that we working on in classes that you have seen above. And now we create objects and we add them to groups. In the end, we using method ls() on the oldest object to see our hierarchy tree.
You can find the code used in this article on my GitHub: Composite Pattern
So the composite design pattern is easy when you have some practical examples. Hence I always tell that the best way to learn design pattern is to write it in your own example because it’s hard to learn and fully understand when you depend only on theory.
Good luck!
Want more? Look at my others post about Design Patterns
Be First to Comment