Design Patterns in Java

Description

4+ Hours of Video Instruction

Design Patterns in Java LiveLessons is a clear, concise introduction to one of the most important concepts in software engineering–design patterns. It introduces patterns both conceptually and through the application of many classic “Gang of Four” design patterns to the development of a case study application written in Java.

Douglas C. Schmidt, Professor of Computer Science at Vanderbilt University’s School of Engineering, provides students and professional programmers with 4+ hours of example and case study based video learning on the concepts and application of design patterns. Design Patterns in Java LiveLessons describes how to master the complexity of developing software by learning and applying object-oriented patterns and frameworks. It centers on a case study that showcases pattern- and object-oriented design and programming techniques using Java. This case study will help you evaluate the limitations of alternative software development methods (such as algorithm decomposition) and demonstrate by example how patterns and object-orientation help to alleviate such limitations. More than a dozen patterns from the book Design Patterns: Elements of Reusable Object-Oriented Software (the so-called “Gang of Four”' book) are applied in the case study.

Skill Level

• Intermediate

What You Will Learn

• How to recognize the inherent and accidental complexities involved with developing object-oriented software.
• How pattern-oriented software architecture techniques can and cannot help to alleviate this complexity.
• How to apply key pattern-oriented software architecture techniques to develop reusable object-oriented software infrastructure and apps.
• How to apply Java programming language features and libraries to develop reusable and robust object-oriented software.
• Where to find additional sources of information on how to successfully apply pattern-oriented software architecture techniques to object-oriented software.

Who Should Take This Course

• Developers looking for a practical introduction to developing pattern-oriented software with Java.

Course Requirements

• Basic understanding of object-oriented programming and development
• Familiarity with the Java programming language

Table of Contents

Lesson 1:

Experts in most domains perform quite differently than beginners. For example, professional athletes, musicians, and dancers move fluidly and effortlessly, without focusing on each individual movement. Likewise, when master software developers write code, they approach it differently than novices, drawing on years of design experience to help guide their solutions.

When watching experts perform, it's often easy to forget how much effort they put into reaching these high levels of achievement. Continuous practice, repetition, and mentoring from other experts are crucial to their success. At the heart of all these activities is knowledge and mastery of patterns, which are reusable solutions to common problems that arise within particular contexts.

In this lesson you learn to recognize the importance of design experience when becoming a master software developer. You also learn what patterns are and how they help codify design experience to improve software quality and developer productivity. In addition, you learn the common characteristics of patterns and pattern descriptions. Finally, you learn about the history of the Gang of Four book and its patterns, as well as learn about key types of relationships among patterns.

Lesson 2:

While it’s certainly possible to discuss patterns in the abstract, good design and programming practices are not best learned through generalities and platitudes. Instead, it’s more effective to see how significant programs can be made easier to write and read, easier to maintain and modify, and more efficient and robust via the application of time-proven software patterns.

This lesson therefore presents an overview of an expression tree processing app that we use as a case study throughout the course. You learn about the goals of this case study, which provides a realistic–yet tractable–context in which to explore the why, the how, and the benefits and limitations of applying many Gang of Four design patterns to an application written in Java. Using the case study as a guide, you also learn how to recognize key structural and behavioral properties in a domain, as well as understand the case study's functional and non-functional requirements.

All the pattern-oriented software presented in the case study is available in open-source form from the course website. You can see throughout the course that applying Gang of Four patterns in the case study not only improves the application’s modularity, extensibility, and quality but also enhances its portability so that it runs on a range of Java platforms, including Android and Eclipse.

Lesson 3:

Algorithmic decomposition is a historically popular software development method that structures software based on the actions performed by algorithms in a program. It decomposes general actions in an algorithm iteratively and recursively into more specific actions. The design components in an algorithmic decomposition typically correspond to processing steps in an execution sequence, which are usually implemented via functions or procedures.

In this lesson you learn how to develop an algorithmic decomposition of the expression tree processing app case study. You also learn how to evaluate the benefits and limitations of algorithmic decomposition. This material provides a baseline for comparison with our pattern- and object-oriented expression tree processing app presented in subsequent lessons.

Lesson 4:

Object-oriented design is a method of planning a system of interacting objects to solve software problems. This design paradigm employs hierarchical data abstraction, where components are structured based on stable class/object roles and relationships, rather than functions corresponding to actions (as is the case with algorithmic decomposition). Moreover, object-oriented design associates actions with classes of objects in a manner that emphasizes high cohesion and low coupling. In many well-designed object-oriented programs, classes and objects are defined and associated in accordance with patterns and combined to form frameworks.

In this lesson you learn how to develop an object-oriented design for the expression tree processing app case study. In addition, you learn how to evaluate the benefits and limitations of object-oriented design relative to the algorithmic decomposition approach presented in Lesson 3.

Lesson 5:

The book Design Patterns: Elements of Reusable Object-Oriented Software (the so-called “Gang of Four” book) presents 23 patterns that document recurring solutions to common problems that arise when developing software in particular contexts. In this lesson you learn how more than a dozen patterns from the Gang of Four book can be applied to the Java-based expression tree processing app case study to resolve key design problems and improve the apps modularity, extensibility, portability, and quality. This lesson forms the bulk of the course and covers the following patterns:

• 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, defines a representation for its grammar.
• Builder, which separates 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, encapsulates each one, and makes them interchangeable.
• Visitor, which centralizes operations on an object structure so that they can vary independently.
• Command, which encapsulates the request for a service as an object.
• Factory Method, which provides an interface for creating an object, but leaves the choice of the concrete type to a subclass.
• State, which allows an object to alter its behavior when its internal state changes, making object appear to change its class.
• Template Method, which provides a skeleton of an algorithm in a method, deferring some steps to subclasses.
• Singleton, which ensures a class only has one instance and provides a global point of access.

The lesson also touches on several other Gang of Four patterns, including Abstract Factory, Adaptor, Decorator, and Observer.

Lesson 6:

The pattern- and object-oriented version of the expression tree processing app case study presented in Lesson 5 provided many improvements compared with the algorithmic decomposition approach described in Lesson 3. For example, it's much more modular and extensible, its design matches the domain better, and it incurs less space overhead. The design of the expression tree process app also exhibits “high pattern density.” For instance, nearly all its classes play a role in one or more Gang of Four patterns. In addition, patterns help clarify the relationships of the many classes comprising the case study’s design. The same pattern-oriented design can be implemented readily in many popular object-oriented programming languages. For example, the Java and C++ solutions are nearly identical, modulo minor syntactic and semantic differences in these two languages. Although pattern- and object-oriented solutions are powerful, becoming a master software developer requires a balanced and nuanced understanding of the pros and cons of patterns. In this lesson, you learn how to evaluate both the benefits and limitations of patterns.

LiveLessons Video Training series publishes hundreds of hands-on, expert-led video tutorials covering a wide selection of technology topics designed to teach you the skills you need to succeed. This professional and personal technology video series features world-leading author instructors published by your trusted technology brands: Addison-Wesley, Cisco Press, IBM Press, Pearson IT Certification, Prentice Hall, Sams, and Que. Topics include: IT Certification, Programming, Web Development, Mobile Development, Home & Office Technologies, Business & Management, and more. View All LiveLessons on InformIT: http://www.informit.com/imprint/series_detail.aspx?ser=2185116

Sample Content

Excerpt

Design Patterns in Java: Evaluating an Objective-Oriented Design of the Expression Tree Processing App

Table of Contents

Introduction

Lesson 1: Overview of Patterns
Learning objectives
1.1 Recognize the importance of design experience when becoming a master software developer
1.2 Understand what patterns are and how they codify design experience to help improve quality and productivity
1.3 Identify common characteristics of patterns and pattern descriptions
1.4 Know the history of the GoF book and its patterns
1.5 Know the key relationships between patterns
Putting all the pieces together

Lesson 2: Overview of the Expression Tree Processing App Case Study
Learning objectives
2.1 Understand the goals of the object-oriented (OO) expression tree case study
2.2 Recognize key structural and behavioral properties in the expression tree domains
2.3 Evaluate the functional and non-functional requirements of the case study
Putting all the pieces together

Lesson 3: Evaluating an Algorithmic Decomposition of the Expression Tree Processing App
Learning objectives
3.1 Develop an algorithmic decomposition of the expression tree processing app
3.2 Evaluate the benefits and limitations of algorithmic decomposition
Putting all the pieces together

Lesson 4: Evaluating an Object-Oriented Design of the Expression Tree Processing App
Learning objectives
4.1 Understand how to develop an object-oriented design of the expression tree processing app
4.2 Evaluate the benefits and limitations of object-oriented design relative to algorithmic decomposition
Putting all the pieces together

Lesson 5: A Pattern-Oriented Expression Tree Processing App
Learning objectives
5.1 Understand the history of the Gang-of-Four book and recognize which patterns are used in the expression tree processing app
5.2 Understand the Composite pattern
5.3 Understand the Bridge pattern
5.4 Understand the Interpreter pattern
5.5 Understand the Builder pattern
5.6 Understand the Iterator pattern
5.7 Understand the Strategy pattern
5.8 Understand the Visitor pattern
5.9 Understand the Command pattern
5.10 Understand the Factory Method pattern
5.11 Understand the State pattern
5.12 Understand the Template Method pattern
5.13 Understand the Singleton pattern

Lesson 6: Putting All the Pieces Together
Learning objectives
6.1 Evaluate the benefits of applying patterns to designing and implementing software
6.2 Evaluate the limitations of applying patterns to designing and implementing software
Putting all the pieces together

Summary

Updates

Submit Errata