Head First Design Patterns: Building Extensible and Maintainable Object-Oriented Software

Authors of Head First Design Patterns
Creators of the Head First Series
Table of Contents (summary)
Table of Contents (the real thing)
Intro
Who is this book for?
We know what you’re thinking.
Metacognition: thinking about thinking
Here’s what WE did:
Here’s what YOU can do to bend your brain into submission
Read Me
Tech Reviewers
Tech Reviewers, 2nd Edition
Acknowledgments
Very Special Thanks
1: intro to Design Patterns: Welcome to Design Patterns
It started with a simple SimUDuck app
But now we need the ducks to FLY
But something went horribly wrong...
Joe thinks about inheritance...
How about an interface?
What would you do if you were Joe?
The one constant in software development
Zeroing in on the problem...
Separating what changes from what stays
Designing the Duck Behaviors
Implementing the Duck Behaviors
Integrating the Duck Behaviors
More integration...
Testing the Duck code
Setting behavior dynamically
The Big Picture on encapsulated behavior
HAS-A can be better than IS-A
Speaking of Design Patterns...
Overheard at the local diner...
Overheard in the next cubicle...
The power of a shared pattern vocabulary
How do I use Design Patterns?
Skeptical Developer
Friendly Patterns Guru
Tools for your Design Toolbox
2: the Observer Pattern: Keeping your Objects in the Know
The Weather Monitoring application overview
Unpacking the WeatherData class
Our Goal
Taking a first, misguided implementation of the Weather Station
What’s wrong with our implementation anyway?
Meet the Observer Pattern
Publishers + Subscribers = Observer Pattern
A day in the life of the Observer Pattern
Five-minute drama: a subject for observation
Two weeks later...
The Observer Pattern defined
The Observer Pattern: the Class Diagram
The Power of Loose Coupling
Cubicle conversation
Designing the Weather Station
Implementing the Weather Station
Implementing the Subject interface in WeatherData
Now, let’s build those display elements
Power up the Weather Station
Looking for the Observer Pattern in the Wild
Coding the life-changing application
Meanwhile, back at Weather-O-Rama
Test Drive the new code
Tools for your Design Toolbox
Design Principle Challenge
3: the Decorator Pattern: Decorating Objects
Welcome to Starbuzz Coffee
The Open-Closed Principle
Meet the Decorator Pattern
Constructing a drink order with Decorators
Now let’s see how this all really works
The Decorator Pattern defined
Decorating our Beverages
Cubicle Conversation
New barista training
Writing the Starbuzz code
Coding beverages
Coding condiments
Serving some coffees
Real-World Decorators: Java I/O
Decorating the java.io classes
Writing your own Java I/O Decorator
Test out your new Java I/O Decorator
Tools for your Design Toolbox
4: the Factory Pattern: Baking with OO Goodness
Identifying the aspects that vary
But the pressure is on to add more pizza
Encapsulating object creation
Building a simple pizza factory
Reworking the PizzaStore class
The Simple Factory defined
Franchising the pizza store
We’ve seen one approach...
But you’d like a little more quality control
A framework for the pizza store
Allowing the subclasses to decide
Let’s make a Pizza Store
Declaring a factory method
Let’s see how it works: ordering pizzas
So how do they order?
Let’s check out how these pizzas are really made to order
We're just missing one thing: Pizzas!
You’ve waited long enough. Time for some pizzas!
It’s finally time to meet the Factory Method Pattern
View Creators and Products in Parallel
Factory Method Pattern defined
Looking at object dependencies
The Dependency Inversion Principle
Applying the Principle
Inverting your thinking...
A few guidelines to help you follow the Principle
Meanwhile, back at the Pizza Store...
Ensuring consistency in your ingredients
Families of ingredients...
Building the ingredient factories
Building the New York ingredient factory
Reworking the pizzas...
Revisiting our pizza stores
What have we done?
More pizza for Ethan and Joel...
Abstract Factory Pattern defined
Factory Method and Abstract Factory compared
Tools for your Design Toolbox
5 the Singleton Pattern: One-of-a-Kind Objects
The Little Singleton
Dissecting the classic Singleton Pattern
The Chocolate Factory
Singleton Pattern defined
Hershey, PA, we have a problem...
Dealing with multithreading
Can we improve multithreading?
Meanwhile, back at the Chocolate Factory
Congratulations!
Tools for your Design Toolbox
6: the Command Pattern: Encapsulating Invocation
Free hardware! Let’s check out the Remote Control
Taking a look at the vendor classes
Cubicle Conversation
Meanwhile, back at the Diner..., or, A brief introduction to the Command Pattern
Let’s study the interaction in a little more detail
The Objectville Diner roles and responsibilities
From the Diner to the Command Pattern
Our first command object
Using the command object
Creating a simple test to use the Remote Control
The Command Pattern defined
Assigning Commands to slots
Implementing the Remote Control
Implementing the Commands
Putting the Remote Control through its paces
Time to write that documentation...
The updated code, using lambda expressiobs
What are we doing?
Time to QA that Undo button!
Using state to implement Undo
Adding Undo to the Ceiling Fan commands
Get ready to test the ceiling fan
Testing the ceiling fan...
Every remote needs a Party Mode!
Using a macro command
More uses of the Command Pattern: queuing requests
More uses of the Command Pattern: logging requests
Command Pattern in the Real World
Tools for your Design Toolbox
7: the Adapter and Facade Patterns: Being Adaptive
Adapters all around us
Object-oriented adapters
If it walks like a duck and quacks like a duck...
Test drive the adapter
The Adapter Pattern explained
Here’s how the Client uses the Adapter
Adapter Pattern defined
Object and class adapters
Real-world adapters
Adapting an Enumeration to an Iterator
Designing the Adapter
Dealing with the remove() method
Writing the EnumerationIterator adapter
And now for something different...
Home Sweet Home Theater
Watching a movie (the hard way)
Lights, Camera, Facade!
Constructing your home theater facade
Implementing the simplified interface
Time to watch a movie (the easy way)
Facade Pattern defined
The Principle of Least Knowledge
How NOT to Win Friends and Influence Objects
Keeping your method calls in bounds...
The Facade Pattern and the Principle of
Tools for your Design Toolbox
8: the Template Method Pattern: Encapsulating Algorithms
It’s time for some more caffeine
Whipping up some coffee and tea classes (in Java)
And now the Tea...
Let’s abstract that Coffee and Tea
Taking the design further...
Abstracting prepareRecipe()
What have we done?
Meet the Template Method
Let’s make some tea...
What did the Template Method get us?
Template Method Pattern defined
Hooked on Template Method...
Using the hook
Let’s run the Test Drive
The Hollywood Principle
The Hollywood Principle and Template Method
Template Methods in the Wild
Sorting with Template Method
We’ve got some ducks to sort...
What is compareTo()?
Comparing Ducks and Ducks
Let’s sort some Ducks
Let the sorting commence!
The making of the sorting duck machine
Swingin’ with Frames
Custom Lists with AbstractList
Tools for your Design Toolbox
9: the Iterator and Composite Patterns: Well-Managed Collections
Breaking News: Objectville Diner and Objectville Pancake House Merge
Check out the Menu Items
Lou and Mel’s Menu implementations
What’s the problem with having two different menu representations?
Implementing the spec: our first attempt
What now?
Can we encapsulate the iteration?
Meet the Iterator Pattern
Adding an Iterator to DinerMenu
Reworking the DinerMenu with Iterator
Fixing up the Waitress code
Testing our code
Here’s the test run...
What have we done so far?
Reviewing our current design...
Making some improvements...
Cleaning things up with java.util.Iterator
We are almost there...
What does this get us?
Iterator Pattern defined
The Iterator Pattern Structure
The Single Responsibility Principle
Meet Java’s Iterable interface
Java’s enhanced for loop
Not so fast; Arrays are not Iterables
Taking a look at the Café Menu
Reworking the Café Menu code
Adding the Cafe Menu to the Waitress
Breakfast, lunch, AND dinner
What did we do?
Code Magnets
Is the Waitress ready for prime time?
Just when we thought it was safe...
What do we need?
The Composite Pattern defined
Designing Menus with Composite
Implementing MenuComponent
Implementing the MenuItem
Implementing the Composite Menu
Fixing the print() method
Getting ready for a test drive...
Now for the test drive...
Getting ready for a test drive...
Tools for your Design Toolbox
Code Magnets Solution
10: the State Pattern: The State of Things
Java Breakers
Cubicle Conversation
State machines 101
Writing the code
In-house testing
You knew it was coming...a change request
The messy STATE of things...
The new design
Defining the State interfaces and classes
Implementing our State classes
Reworking the Gumball Machine
Now, let’s look at the complete GumballMachine class
Implementing more states
Let’s take a look at what we’ve done so far
The State Pattern defined
We still need to finish the Gumball 1 in 10 game
Finishing the game
Demo for the CEO of Mighty Gumball, Inc.
Sanity check...
We almost forgot!
Tools for your Design Toolbox
11: the Proxy Pattern: Controlling Object Access
Coding the Monitor
Testing the Monitor
The role of the ‘remote proxy’
Adding a remote proxy to the Gumball Mac
Remote methods 101
Walking through the design
How the method call happens
Java RMI, the Big Picture
Making the Remote service
Step one: make a Remote interface
Step two: make a Remote implementation
Step three: run rmiregistry
Step four: start the service
Complete code for the server side
Complete code for the client side
Back to our GumballMachine remote proxy
Getting the GumballMachine ready to be a remote service
Registering with the RMI registry...
Now for the GumballMonitor client...
Writing the Monitor test drive
Another demo for the CEO of Mighty Gumball
The Proxy Pattern defined
Get ready for the Virtual Proxy
Displaying Album covers
Designing the Album Cover Virtual Proxy
Writing the Image Proxy
Testing the Album Cover Viewer
What did we do?
Using the Java API’s Proxy to create a protection proxy
Geeky Matchmaking in Objectville
The Person implementation
Five-minute drama: protecting subjects
Big Picture: creating a Dynamic Proxy for the Person
Step one: creating Invocation Handlers
Step two: creating the Proxy class and instantiating the Proxy object
Testing the matchmaking service
Running the code...
The Proxy Zoo
Tools for your Design Toolbox
The code for the Album Cover Viewer
12: compound patterns: Patterns of Patterns
Working together
Duck reunion
Safety versus transparency
What did we do?
A duck’s-eye view: the class diagram
The King of Compound Patterns
Meet Model-View-Controller
A closer look...
Understanding MVC as a set of Patterns
Using MVC to control the beat...
Putting the pieces together
Building the pieces
Now let’s have a look at the concrete BeatModel class
The View
Implementing the View
Now for the Controller
And here’s the implementation of the controller
Putting it all together...
Exploring Strategy
Adapting the Model
And now for a test run...
Tools for your Design Toolbox
13: better living with patterns: Patterns in the Real World
Design Pattern defined
Looking more closely at the Design Pattern definition
May the force be with you
So you wanna be a Design Patterns writer
Organizing Design Patterns
Thinking in Patterns
Your Mind on Patterns
Don’t forget the power of the shared vocabulary
Cruisin’ Objectville with the Gang of Four
Your journey has just begun...
The Patterns Zoo
Annihilating evil with Anti-Patterns
Tools for your Design Toolbox
Leaving Objectville...
14: appendix: Leftover Patterns
Bridge
Builder
Chain of Responsibility
Flyweight
Interpreter
Mediator
Memento
Prototype
Visitor
Index