Description
Introduction
In class, we covered a variety of design patterns. In this assignment, you
get a chance to implement three of them: Decorator, Observer, and
Composite. You may use any Object-Oriented programming language to
implement the patterns: C++, Java. Note: only implement the minimal
amount of code you need to demonstrate the design pattern (e.g. these
should be relatively small programs).
Instructions
1. Write a program that demonstrates the advantages of the Observer
pattern. Your program should create an object that has state that
needs to be observed. It should attach at least two observers to this
object and it should then change the state of the observed object
twice. Each time, the observers should indicate that they received
the state change notification and retrieved and/or did something
with the new state.
2. Write a program that demonstrates the advantages of the Decorator
pattern. Create an object with two operations that produce output
when they are called. Create a decorator for that object that adds
two additional operations that produce output when they are called.
(For simplicity, you should have the operations write to standard
out, e.g. do not try to implement a GUI program that makes use of
decorators graphically.) Instantiate an undecorated object and have
your program call both operations. Then instantiate a decorator, use
it to “decorate” the original object, then call all four operations
provided by the decorator. The output of the original two operations
should be decorated in some way. That is, it should be obvious that
the original output of the undecorated object is being manipulated in
some way by the decorator.
3. Write a program that demonstrates the advantages of the
Composite design pattern. The program should create a tree of
objects consisting of both composite and leaf nodes (demonstrating
that the composite has correctly implemented a subset of the child
management functions, such as addChild(), getChild(), and
getParent()). Make sure that your tree consists of at least three
levels, e.g. a root node with multiple children, where at least one of
those nodes is a composite node with children. The program should
then call an operation on the root of the tree. All composite objects
should delegate the operation to their children while all leaf nodes
should perform the action. Note: you can optionally have the
composite nodes do something in response to the operation but they
should then delegate the operation to their children.
Evaluation
We will be looking to see that your implementations match the structure
of the design pattern as well as match the scenarios described above.
Please create an archive of your source code in .zip format and submit to
BB. Your archive should contain a single directory that contains three
subdirectories, one for each pattern. Each pattern directory should contain
the source code for implementing the pattern and a text file containing the
output produced by the program.
