Practising the use of the Abstract Factory, Composite and Observer design patterns in Java.

• rework the composite pattern to more closely resemble a general approach

• (+) removes new() calls from most functions.
• (+) ideally, it can create an additional abstraction layer for interacting and using the included classes.
• (-) adds an additional layer of complexity and abstraction.
• (-) doesn't really make sense unless there's a bunch of classes that exhibit similar behavior.
• (-) small changes of components of factories might require more wide-ranging changes / restructuring or related or dependent components.

• (+) allows interacting with objects in the same way as with a collection of objects
• (+) is recursive, which is often of advantage, and generally allows for shorter code
• (+) the most intuitive way of representing many data structures, such as trees or file directories (also trees)
• (-) might overly generalize the data structure.

• (+) allows for efficient separation of trigger and reaction, loosely connecting interacting objects; thus reinforcing the core principles of OOP.
• (+) removes the need for observing clients to check a condition constantly, since once the condition is met, the info is pushed to the Observers.
• (+) multiple protocols possible, including pushing and pulling.
• (-) as with any of the above: might add unnecessary complexity.