At the time of the midterm exam, a student should be able to:

• State the motivation behind using patterns.
• Define "software design pattern."
• Identify and make use of appropriate connectors in UML class diagrams that illustrate generalization (Java extends), realization (Java implements), composition, and usage, along with labeling connectors to indicate navigability (arrows), multiplicity (numbers), and end roles (attribute names).

Design Principles

Design principles covered:

• Loose Coupling
• Abstract Variations
• Program to Interface
• Favor Composition
• Open to extension closed to modification

For each of the above design principles:

• Describe the motivation behind each principle.
• Give an example application of each principle.
• State which design patterns make use of or violate the principle.

Design Patterns

Design patterns covered:

• Strategy
• Singleton
• Observer
• Proxy

For each of the above design patterns:

• Describe intent and motivation behind each pattern.
• Describe how to apply the pattern, including a structural UML representation.
• Describe the consequences of applying the pattern, both positive and negative (should there be any).

Patterns specific outcomes:

• Explain the concept of push versus pull with respect to how an observer acquires an update from a subject.
• Define the function of each of the following proxies: stub proxy, virtual proxy, protection proxy, caching proxy, and remote proxy.
• Describe the contexts in which the stub proxy, virtual proxy, protection proxy, caching proxy, and remote proxy patterns apply.

Java Constructs

• Explain when it makes sense to provide some implementation in an abstract class, even though the class is not instantiable.
• Explain when use of an abstract class may be more favorable than use of a pure interface.
• Explain the meaning of a thread and its purpose.
• Apply multithreading using the Java API to create and run multiple threads.
• Apply anonymous inner classes to the creation of threads.
• Explain the purpose of the Runnable interface and its association with thread creation.
• Explain the purpose of thread synchronization.
• Create synchronized methods and synchronized blocks of code.
• Synchronize threads using notify() and wait() methods from the Java API.
• Explain the concept of thread-safety as to how it pertains to non-thread-safe classes such as those of the JCF.
• Explain the concept of Socket-based I/O streams.
• Apply socket-based I/O streams to exchanging data between processes on the same computer as well as between processes distributed among networked computers.
• Explain the concept of eager versus lazy initialization.
• Implement Java code that creates a server-side TCP socket.
• Implement Java code that creates a client-side socket that connects to a server-side socket.
• Implement sending and receiving data between a remote proxy and real subject using socket I/O.

Javadoc for classes/methods used would be provided if students were asked to implement code on the exam.

At the time of the Final Exam, a student should be able to:

• Describe and apply the null object pseudo pattern.
• Describe how the decorator pattern is applied in the java.io package to various Java I/O classes, such as OutputStream, FileOutputStream, FilterOutputStream, along with the corresponding InputStream-related classes.
• Apply the decorator pattern to implement a FilterOutputStream-based or FilterInputStream-based I/O concrete decorator class that manipulates the data within an output or input stream.

Additional Design Principles

Design principles covered since midterm:

• Dependency Inversion Principle
• High Cohesion
• Principle of Least Knowledge

Design Patterns

Design patterns covered since the midterm:

• Decorator
• Iterator
• Composite
• Command
• Builder
• Factory Method
• Abstract Factory
• Visitor
• Facade
• Adapter
• Mediator