Design Patterns with Java: An Introduction

A Warm Welcome to You!
Contents
1: The Term “Design Pattern”
	1.1	 What Are Design Patterns?
		1.1.1	 Historical and Intellectual Background
		1.1.2	 Advantages and Disadvantages of Patterns
			1.1.2.1	 Patterns Transport and Preserve Knowledge
			1.1.2.2	 Patterns Create a Common Vocabulary
			1.1.2.3	 Patterns Help to Understand a Programming Language Better
			1.1.2.4	 Patterns May Lead to Inappropriate Designs
		1.1.3	 A Pattern Is Not a Code Is Not a Pattern
		1.1.4	 So What Are “Design Patterns”?
		1.1.5	 Patterns in Practice
	1.2	 Categorize and Describe Design Patterns
		1.2.1	 Different Categories of Patterns
		1.2.2	 Defining a Sample Template
	1.3	 Summary
2: Object-Oriented Programming and Design Principles
	2.1	 Object-Oriented Programming
	2.2	 Programming Against Interfaces
	2.3	 Single Responsibility Principle (SRP)
	2.4	 Inheritance May Be Evil
	2.5	 Open/Closed Principle (OCP)
	2.6	 Principle of the Right Sense of Proportion
3: Singleton
	3.1	 The Task of the Singleton Pattern
	3.2	 A First Version of the Singleton
	3.3	 Synchronize Access
	3.4	 Double Checked Locking
	3.5	 Early Instantiation – Early Loading
	3.6	 Singleton – The UML Diagram
	3.7	 Antipattern
		3.7.1	 Criticism of the Singleton
		3.7.2	 Is Singleton an Antipattern?
	3.8	 Summary
	3.9	 Description of Purpose
4: Template Method
	4.1	 How Template Method Works
		4.1.1	 A First Approach
		4.1.2	 The Second Approach
		4.1.3	 The Hollywood Principle
		4.1.4	 Introducing Hook Methods
	4.2	 The “ListModel” Interface
	4.3	 Template Method – The UML Diagram
	4.4	 Summary
	4.5	 Description of Purpose
5: Observer
	5.1	 Introduction
	5.2	 A First Realization
	5.3	 Extending the Approach
	5.4	 Observer in the Java Class Library
	5.5	 Concurrent Access
		5.5.1	 Synchronize Accesses
		5.5.2	 Copying the Database
		5.5.3	 Use of a Thread-Safe List
	5.6	 Observer as Listener
	5.7	 Listener in GUI Programming
	5.8	 The Model-View-Controller Pattern
	5.9	 Observer – The UML Diagram
	5.10	 Summary
	5.11	 Description of Purpose
6: Chain of Responsibility
	6.1	 A Real World Example
	6.2	 First Code Example: Grocery Shopping
		6.2.1	 The Foodstuffs Required
		6.2.2	 The Sellers
		6.2.3	 The Client
			6.2.3.1	 Extension of the Project
			6.2.3.2	 Variations of the Pattern
				Designing Hierarchies and Selecting any Entry Point
				Links in the Chain Modify the Request
	6.3	 An Example from the Class Library
	6.4	 Chain of Responsibility – The UML Diagram
	6.5	 Summary
	6.6	 Description of Purpose
7: Mediator
	7.1	 Distinction from the Observer Pattern
	7.2	 Task of the Mediator Pattern
	7.3	 Mediator in Action – An Example
		7.3.1	 Definition of a Consumer
		7.3.2	 Definition of a Producer
		7.3.3	 Mediator Interface
		7.3.4	 Testing the Mediator Pattern
	7.4	 Mediator in Action – The Second Example
		7.4.1	 Mediator in GUI Programming
		7.4.2	 Structure of the GUI
	7.5	 Mediator – The UML Diagram
	7.6	 Criticism of Mediator
	7.7	 Summary
	7.8	 Description of Purpose
8: State
	8.1	 Excursus: The Enum Pattern
		8.1.1	 Representing a State by Numerical Values
		8.1.2	 Representing a State by Objects
		8.1.3	 Implementation in the Java Class Library
	8.2	 Changing the State of an Object
		8.2.1	 A First Approach
		8.2.2	 A Second Approach
	8.3	 The Principle of the State Pattern
		8.3.1	 Defining the Role of All States
		8.3.2	 The Project from the Client’s Point of View
		8.3.3	 Changes to the Project
			8.3.3.1	 Manage State Objects Centrally in Context
			8.3.3.2	 State Objects as Return Values of Method Calls
	8.4	 The State Pattern in Practice
	8.5	 State – The UML Diagram
	8.6	 Summary
	8.7	 Description of Purpose
9: Command
	9.1	 Encapsulating Commands in Classes
		9.1.1	 Version 1 – Basic Version
		9.1.2	 Other Suppliers Appearing
		9.1.3	 Encapsulating a Command
	9.2	 Command in the Class Library
		9.2.1	 Example 1: Concurrency
		9.2.2	 Example 2: Event Handling
	9.3	 Reusing Command Objects
		9.3.1	 The “Action” Interface
		9.3.2	 Use of the “Action” Interface
	9.4	 Undo and Redo of Commands
		9.4.1	 A Simple Example
		9.4.2	 A More Extensive Example
		9.4.3	 Discussion of the Source Code
			9.4.3.1	 The Classes Involved
			9.4.3.2	 Task of the GUI
			9.4.3.3	 Operation of the Command Classes
			9.4.3.4	 Undo and Redo
		9.4.4	 Undo and Redo Considered in Principle
	9.5	 Command – The UML Diagram
	9.6	 Summary
	9.7	 Description of Purpose
10: Strategy
	10.1	 A First Approach
	10.2	 Strategy in Action – Sorting Algorithms
		10.2.1	 The Common Interface
		10.2.2	 The Selection Sort
		10.2.3	 The Merge Sort
		10.2.4	 The Quick Sort
		10.2.5	 The Context
		10.2.6	 Evaluation of the Approach and Possible Variations
	10.3	 The Strategy Pattern in Practice
	10.4	 Strategy – The UML Diagram
	10.5	 Distinction from Other Designs
	10.6	 Summary
	10.7	 Description of Purpose
11: Iterator
	11.1	 Two Ways to Store Data
		11.1.1	 Storing Data in an Array
		11.1.2	 Storing Data in a Chain
	11.2	 The Task of an Iterator
	11.3	 The Interface Iterator in Java
		11.3.1	 The Iterator of the Class MyArray
			11.3.1.1	 Test of the Iterator
			11.3.1.2	 Benefits and Variations of the Iterator
		11.3.2	 The Iterator of the Class MyList
			11.3.2.1	 Test of the Iterator
			11.3.2.2	 Benefits of the Iterator
	11.4	 The Iterable Interface
	11.5	 Iterator – The UML Diagram
	11.6	 Summary
	11.7	 Description of Purpose
12: Composite
	12.1	 Principle of Composite
	12.2	 Implementation 1: Security
	12.3	 Implementation 2: Transparency
	12.4	 Consideration of the Two Approaches
	12.5	 Going One Step Further
		12.5.1	 Creating a Cache
		12.5.2	 Referencing the Parent Components
		12.5.3	 Moving Nodes
	12.6	 Composite – The UML Diagram
	12.7	 Summary
	12.8	 Description of Purpose
13: Flyweight
	13.1	 Task of the Pattern
	13.2	 The Realization
	13.3	 A More Complex Project
		13.3.1	 The First Approach
		13.3.2	 Intrinsic and Extrinsic State
	13.4	 Flyweight in Practice
	13.5	 Flyweight – The UML Diagram
	13.6	 Summary
	13.7	 Description of Purpose
14: Interpreter
	14.1	 The Task in This Chapter
	14.2	 The Scanner
		14.2.1	 The Defined Symbols
		14.2.2	 The Scanner Converts Strings into Symbols
	14.3	 The Parser
		14.3.1	 Abstract Syntax Trees
		14.3.2	 Expressions for the Parser
		14.3.3	 Parse Stroke Calculation
		14.3.4	 Parse Point Calculation
		14.3.5	 Consider Brackets
	14.4	 Interpreter – The UML Diagram
	14.5	 Discussion of the Interpreter Pattern
	14.6	 Summary
	14.7	 Description of Purpose
15: Abstract Factory (Abstract Factory)
	15.1	 Create Gardens
		15.1.1	 The First Attempt
		15.1.2	 The Second Attempt – Inheritance
		15.1.3	 The Third Approach – The Abstract Factory
		15.1.4	 Advantages of the Abstract Factory
		15.1.5	 Defining a New Garden
	15.2	 Discussion of the Pattern and Practice
	15.3	 Chasing Ghosts
		15.3.1	 The First Version
			15.3.1.1	 The Player
			15.3.1.2	 The Four Cardinal Points
			15.3.1.3	 Building the House
			15.3.1.4	 The “House” Class for Controlling the Game
		15.3.2	 The Second Version of the Project
		15.3.3	 Version 3 – Introduction of Another Factory
			15.3.3.1	 Spells
			15.3.3.2	 The New Factory for Doors with Spells
			15.3.3.3	 The New Component: A Door with a Magic Spell
		15.3.4	 Version 4 – The Haunted House
	15.4	 Abstract Factory – The UML Diagram
	15.5	 Summary
	15.6	 Description of Purpose
16: Factory Method
	16.1	 A First Example
	16.2	 Variations of the Example
	16.3	 Practical Application of the Pattern
		16.3.1	 Recourse to the Iterator Pattern
		16.3.2	 At the Abstract Factory
	16.4	 A Larger Example – A Framework
		16.4.1	 And Another Calendar
		16.4.2	 The Interfaces for Entries and Their Editors
		16.4.3	 The Class “Contact” as an Example of an Entry
		16.4.4	 The FactoryMethod Class as a Client
	16.5	 Difference to Abstract Factory
	16.6	 Factory Method – The UML Diagram
	16.7	 Summary
	16.8	 Description of Purpose
17: Prototype
	17.1	 Cloning Objects
		17.1.1	 Criticism of the Implementation
			17.1.1.1	 The Cloneable Interface
			17.1.1.2	 The Problem of Equal References
			17.1.1.3	 What Happens During Cloning
		17.1.2	 Cloning in Inheritance Hierarchies
	17.2	 A Major Project
		17.2.1	 Discussion of the First Version
		17.2.2	 The Second Version – Deep Copy
		17.2.3	 Defining Your Own Prototypes
	17.3	 Prototype – The UML Diagram
	17.4	 Summary
	17.5	 Description of Purpose
18: Builder
	18.1	 An Object Creates Other Objects
		18.1.1	 Telescoping Constructor Pattern
		18.1.2	 JavaBeans Pattern
		18.1.3	 Builder Pattern
	18.2	 A More Complex Design Process
		18.2.1	 Converting XML Files into a TreeModel
		18.2.2	 Displaying XML Files as HTML
	18.3	 Builder – The UML Diagram
	18.4	 Summary
	18.5	 Description of Purpose
19: Visitor
	19.1	 A Simple Example
		19.1.1	 The Power Unit
		19.1.2	 The Visitor
		19.1.3	 The Client
		19.1.4	 Another Visitor
		19.1.5	 Criticism of the Project
	19.2	 Visitor – The UML Diagram
	19.3	 Summary
	19.4	 Description of Purpose
20: Memento
	20.1	 Task of the Memento Pattern
		20.1.1	 Public Data Fields
		20.1.2	 The JavaBeans Pattern
		20.1.3	 Default Visibility
	20.2	 A Possible Realization
	20.3	 A Major Project
	20.4	 Memento – The UML Diagram
	20.5	 Summary
	20.6	 Description of Purpose
21: Facade
	21.1	 An Example Outside IT
	21.2	 The Facade in a Java Example
		21.2.1	 Introduction of a Facade
		21.2.2	 A Closer Look at the Term “System”
	21.3	 The Facade in the Class Library
	21.4	 The “Law of Demeter”
	21.5	 Facade – The UML Diagram
	21.6	 Summary
	21.7	 Description of Purpose
22: Adapter
	22.1	 An Introductory Example
	22.2	 A Class-Based Design
	22.3	 An Object-Based Design
	22.4	 Criticism of the Adapter Pattern
	22.5	 A Labeling Fraud
	22.6	 Adapter – The UML Diagram
	22.7	 Summary
	22.8	 Description of Purpose
23: Proxy
	23.1	 Virtual Proxy
	23.2	 Security Proxy
	23.3	 Smart Reference
		23.3.1	 The Basic Version
		23.3.2	 Introduction of a Proxy
		23.3.3	 Introducing a Second Proxy
		23.3.4	 Dynamic Proxy
			23.3.4.1	 The Reflection API
			23.3.4.2	 The InvocationHandler
			23.3.4.3	 The Proxy Class
	23.4	 Remote Proxy
		23.4.1	 Structure of RMI in Principle
		23.4.2	 The RMI Server
			23.4.2.1	 The PiIF Interface
			23.4.2.2	 The PiImpl Server Class
			23.4.2.3	 The Class ServerStart Starts the Server
		23.4.3	 The RMI Client
		23.4.4	 Making the Project Work
	23.5	 Proxy – The UML Diagram
	23.6	 Summary
	23.7	 Description of Purpose
24: Decorator
	24.1	 Build Cars
		24.1.1	 One Attribute for Each Optional Extra
		24.1.2	 Extending with Inheritance
		24.1.3	 Decorating According to the Matryoshka Principle
			24.1.3.1	 Defining the Basic Models
			24.1.3.2	 Defining the Optional Extras
			24.1.3.3	 The Client Plugs the Components Together
	24.2	 Practical Examples
		24.2.1	 The “JScrollPane” Class
		24.2.2	 Streams in Java
			24.2.2.1	 Streams as Decorator
		24.2.3	 Streams as Non-Decorator
	24.3	 Decorator – The UML Diagram
	24.4	 Summary
	24.5	 Description of Purpose
25: Bridge
	25.1	 Two Definitions
		25.1.1	 What Is an Abstraction?
		25.1.2	 What Is an Implementation?
		25.1.3	 A Problem Begins to Mature
	25.2	 The Bridge Pattern in Use
		25.2.1	 First Step
		25.2.2	 Second Step
			25.2.2.1	 Extending the Abstraction
		25.2.3	 Extending the Implementation
	25.3	 Discussion of the Bridge Pattern
		25.3.1	 Bridge in the Wild
		25.3.2	 Distinction from Other Patterns
	25.4	 Bridge – The UML Diagram
	25.5	 Summary
	25.6	 Description of Purpose
26: Combine Patterns
	26.1	 The Example
	26.2	 Singleton: Logging
	26.3	 Abstract Factory: Building the Sensors
	26.4	 Observer: The Trigger
	26.5	 Adapter: Send Notifications
	26.6	 Command: Actuators and Remote Control
	26.7	 A Sensor Triggers
	26.8	 Class Diagram
	26.9	 The Client
	26.10	 Considerations
	26.11	 Summary
Concluding Remarks