LiveLessons: Design Patterns in Java Douglas C. Schmidt (d.schmidt@vanderbilt.edu) Cornelius Vanderbilt Professor of Engineering (Computer Science), Associate Provost of Research, and Data Science Institute Co-Director at Vanderbilt University

Table of Contents

Course Summary

Course Topics

Course Objectives

Recommended Background

Java Source Code

Facebook Group

Additional Resources

About the Instructor

Course Topics

• Lesson 1 presents an overview of patterns to help you recognize the importance of design experience, understand how patterns can help improve software quality and developer productivity, identify common characteristics in pattern descriptions, and know the history of the Gang of Four book and its patterns, as well as know key relationships between patterns.

• Lesson 2 presents the functional and non-functional requirements of object-oriented expression tree app that we'll use throughout the course as a realistic--yet tractable--case study to motivate the need for--and benefits of--key Gang of Four patterns written in Java that run on a range of runtime platforms, including Android and Eclipse.

• Lesson 3 presents an algorithmic decomposition of the expression tree processing app to help you understand and evaluate the benefits and limitations of this historically popular design paradigm.

• Lesson 4 presents an object-oriented design of the expression tree processing app to help you understand and evaluate the benefits and limitations of this paradigm.

• Lesson 5--which is the bulk of the course--describes how more than a dozen patterns from the ``Gang of Four'' book can be applied to resolve various design problems in the Java expression tree processing app implementation, including improving its modularity, extensibility, portability, and quality. The Gang of Four patterns we cover in detail include the following:
  • Composite, which treats individual objects and multiple, recursively-composed objects uniformly.

  • Bridge, which separates an abstraction from its implementation(s) so the two can vary independently.

  • Interpreter, which when given a language, define a representation for its grammar, along with an interpreter that uses the representation to interpret sentences in the language.

  • Builder, which separate the construction of a complex object from its representation.

  • Iterator, which accesses elements of an aggregate without exposing its representation.

  • Strategy, which defines a family of algorithms, encapsulate each one, and make them interchangeable to let clients and algorithms vary independently.

  • Visitor, which centralizes operations on an object structure so that they can vary independently, but still behave polymorphically.

  • Command, which encapsulates the request for a service as an object.

  • Factory Method, which provide an interface for creating an object, but leaves choice of object's concrete type to a subclass.

  • State, which allows an object to alter its behavior when its internal state changes.the object will appear to change its class.

  • Template Method, which provides a skeleton of an algorithm in a method, deferring some steps to subclasses.

  • and finally Singleton, which ensures a class only has one instance and provides a global point of access.

  We'll also touch on several other Gang of Four patterns, including Abstract Factory, Observer, Adapter, and Decorator.

• Lesson 6--wraps up the course by discussing of the benefits and limitations of patterns.

Java Source Code

Suggestions for improvement are welcome (especially if they are accompanied with updates to the source code). Note that the GUI version of the Calculator "Verbose Mode" is still a work-in-progress. If you'd like to help improve it please let me know.

Facebook Group

Additional Resources

• GoF Wikipedia page
• Vince Huston's design patterns page
• The Hillside Group's Facebook page
• The Pattern Languages of Program Design page

Back to Douglas C. Schmidt's LiveLessons page.