Design Patterns Course Requirements

This is an intermediate object-oriented design course. You do not need prior experience with the Gang of Four catalog, but you should be able to read and modify a small Java or C++ program without step-by-step language instruction.

Required Foundation

• Classes and objects: create instances, define fields and methods, and separate public behavior from implementation details.
• Inheritance and interfaces: recognize an is-a relationship, override behavior, and program against an abstraction.
• Composition: build an object from collaborating objects and delegate work to them.
• Polymorphism: understand how different implementations can respond through one interface or base type.
• Basic collections and control flow: work with lists, maps, loops, conditionals, and simple algorithms.
• Testing and debugging: compile, run, inspect failures, and verify that a change preserves existing behavior.

Experience with UML class or sequence diagrams will make some illustrations easier to read. Familiarity with SOLID principles, cohesion, coupling, and dependency injection is also useful. These topics are reviewed when they directly affect a pattern decision, so lack of formal architecture training should not prevent you from starting.

Choose either Java or C++ for the programming exercises. The course does not depend on a graphical interface or a particular IDE. You need:

• a current Java Development Kit or standards-conforming C++ compiler;
• a text editor or IDE that can create a small multi-file project;
• a terminal for compiling and running examples;
• a browser for reading lessons and submitting text exercises; and
• optionally, a unit-test framework such as JUnit or a C++ testing library.

Suitable environments include IntelliJ IDEA, Eclipse, Visual Studio, Visual Studio Code, or a command-line toolchain. Use the environment you can debug confidently. The examples focus on standard language features rather than framework-specific annotations or code generation.

• Java Development Kit downloads
• Microsoft Visual Studio and C++ tools
• Visual Studio Code
• Eclipse downloads

You are ready to begin if you can complete this small design task:

1. Define an interface representing a traffic signal.
2. Create two implementations with different displayed states.
3. Place the implementations in a collection through the interface type.
4. Write a test or short driver that invokes both implementations.
5. Explain whether inheritance or composition carries the main reuse responsibility in your design.

If the syntax is unfamiliar, review your chosen language first. If the code is straightforward but the final design question is difficult, this course is the appropriate next step.

The course develops judgment, not pattern-counting ability. Each lesson connects a recurring design problem to a pattern's intent, participants, collaborations, and consequences. You will use the continuing traffic-flow project to compare plausible designs and document why one alternative is more adaptable than another.

Optional reference: Design Patterns: Elements of Reusable Object-Oriented Software. This is an affiliate link; no purchase is required to complete the course.