Index

A note on the digital index

A link in an index entry is displayed as the section title in which that entry appears. Because some sections have multiple index markers, it is not unusual for an entry to have several links to the same section. Clicking on any link will take you directly to the place in the text in which the marker appears.

A

abstract class
about, Our PizzaStore isn’t going to be very popular without some pizzas, so let’s implement them
definition of, Template Method Pattern defined
methods in, Template Method Pattern defined
Abstract Factory Pattern
about, What have we done?
building ingredient factories, Building the ingredient factories, A very dependent PizzaStore
combining patterns, Duck reunion, Exercise Solutions
definition of, Abstract Factory Pattern defined
exercise matching description of, So you wanna be a Design Patterns writer, Boy, it’s been great having you in Objectville.
Factory Method Pattern and, Abstract Factory Pattern defined
implementing, Abstract Factory Pattern defined
abstract superclasses, Designing the Duck Behaviors
ACM Conference, Your journey has just begun...
Adapter Pattern
about, The Adapter Pattern explained
adapting to Iterator Enumeration interface, Adapting an Enumeration to an Iterator
combining patterns, Duck reunion
dealing with remove() method, Dealing with the remove() method
Decorator Pattern vs., Writing the EnumerationIterator adapter
definition of, Adapter Pattern defined
designing Adapter, Adapting an Enumeration to an Iterator
exercise matching description of, The magic of Iterator & Composite together..., Tools for your Design Toolbox, Running the code..., So you wanna be a Design Patterns writer, Boy, it’s been great having you in Objectville.
exercise matching pattern with its intent, And now for something different..., Tools for your Design Toolbox
Facade Pattern vs., Lights, Camera, Facade!
in Model-View-Controller, Adapting the Model
object and class adapters, Object and class adapters
Proxy Pattern vs., What did we do?
simple real world adapters, Real-world adapters
writing Enumeration Iterator Adapter, Dealing with the remove() method
adapters, OO (Object-Oriented)
about, Adapters all around us
creating Two Way Adapters, Here’s how the Client uses the Adapter
in action, If it walks like a duck and quacks like a duck, then it must might be a duck turkey wrapped with a duck adapter...
object and class object and class, Object and class adapters
test driving, Test drive the adapter
aggregates, Meet the Iterator Pattern, Iterator Pattern defined
Alexander, Christopher
A Pattern Language, Your journey has just begun...
The Timeless Way of Building, Your journey has just begun...
algorithms, encapsulating
about, The Template Method Pattern: Encapsulating Algorithms
abstracting prepareRecipe(), Abstracting prepareRecipe()
Template Method Pattern and
about, Meet the Template Method
applets in, Applets
code up close, Template Method Pattern defined
definition of, Template Method Pattern defined
hooks in, Template Method Pattern defined
in real world, Template Methods in the Wild
sorting with, Sorting with Template Method
Swing and, Swingin’ with Frames
testing code, Let’s run the Test Drive
The Hollywood Principle and, The Hollywood Principle
Anti-Patterns, Annihilating evil with Anti-Patterns
Applet, Template Method Pattern and, Applets
Applicability section, in pattern catalog, Looking more closely at the Design Pattern definition
Application Patterns, The Patterns Zoo
Architectural Patterns, The Patterns Zoo
ArrayList, arrays and, Lou and Mel’s Menu implementations, Iterators and Collections
arrays
iteration and, Can we encapsulate the iteration?
iterator and hasNext() method with, Adding an Iterator to DinerMenu
iterator and next() method with, Adding an Iterator to DinerMenu
removing an element, Cleaning things up with java.util.Iterator
sorting with Template Method Pattern, Sorting with Template Method

B

Basham, Bryan, (Head First Servlets & JSP), Model 2: DJ’ing from a cell phone
Be the JVM solution exercises, dealing with multithreading, Houston, Hershey, PA we have a problem..., Tools for your Design Toolbox
behavior, encapsulating, Designing the Duck Behaviors
behavioral patterns category, Design Patterns, Pattern Categories, Pattern Categories
behaviors
classes as, Implementing the Duck Behaviors
classes extended to incorporate new, The Open-Closed Principle
declaring variables, Integrating the Duck Behavior
delegating to decorated objects while adding, Constructing a drink order with Decorators
designing, Designing the Duck Behaviors
encapsulating, The Big Picture on encapsulated behaviors
implementing, Implementing the Duck Behaviors
integrating, Integrating the Duck Behavior
setting dynamically, Setting behavior dynamically
Bert Bates, (Head First Servlets & JSP), Model 2: DJ’ing from a cell phone
Bridge Pattern, Bridge
Builder Pattern, Builder
Business Process Patterns, The Patterns Zoo

C

Caching Proxy, as form of Virtual Proxy, What did we do?, The Proxy Zoo
Cafe Menu, integrating into framework (Iterator Pattern)
about, Taking a look at the Café Menu
reworking code, Reworking the Café Menu code
CD covers, displaying using Proxy Pattern
about, Displaying CD covers
code for, Compound Patterns: Patterns of Patterns
designing Virtual Proxy, Designing the CD cover Virtual Proxy
reviewing process, What did we do?
testing viewer, Testing the CD Cover Viewer
writing Image Proxy, Writing the Image Proxy
Chain of Responsibility Pattern, Chain of Responsibility
change
constant in software development, The one constant in software development
identifying, The power of Loose Coupling
iteration and, Single Responsibility
Chocolate Factory, using Singleton Pattern
about, The Chocolate Factory
fixing Chocolate Boiler code, Meanwhile, back at the Chocolate Factory...
class adapters, object vs., Object and class adapters
class design, of Observer Pattern, The Observer Pattern defined
class hierarchies, parallel, Another perspective: parallel class hierarchies
class patterns, Design Patterns, Pattern Categories
classes., Welcome to Starbuzz Coffee
(see also subclasses)
abstract, Our PizzaStore isn’t going to be very popular without some pizzas, so let’s implement them
adapter, Here’s how the Client uses the Adapter, Tools for your Design Toolbox
Adapter Pattern, Adapter Pattern defined
altering decorator, Tools for your Design Toolbox
as behaviors, Implementing the Duck Behaviors
command
about, The Command Pattern means lots of command classes
passing method references, Simplifying even more with method references
using lambda expressions, Simplifying the Remote Control with lambda expressions
creating, Separating what changes from what stays the same
Factory Method Pattern creator and product, It’s finally time to meet the Factory Method Pattern
having single responsibility, Single Responsibility
high-level component, The Dependency Inversion Principle
identifying as Proxy class, Running the code...
Open-Closed Principle, The Open-Closed Principle
state
defining, Defining the State interfaces and classes
implementing, Implementing our State classes, Implementing more states, We still need to finish the Gumball 1 in 10 game
increasing number in design of, The State Pattern defined
reworking state classes, Reworking the Gumball Machine
state transitions in, The State Pattern defined
using composition with, HAS-A can be better than IS-A
using instance variables instead of, Welcome to Starbuzz Coffee
using instead of Singletons static, Congratulations!
using new operator for instantiating concrete, The Factory Pattern: Baking with OO Goodness
Classification section, in pattern catalog, Looking more closely at the Design Pattern definition
classloaders, using with Singletons, Congratulations!
client heap, Remote methods 101
client helper (stubs), in RMI, Java RMI, the Big Picture, Java RMI, the Big Picture, How does the client get the stub object?, And now let’s put the monitor in the hands of the CEO. Hopefully, this time he’ll love it
Code Magnets exercise
for DinerMenu Iterator, Iterators and Collections, Tools for your Design Toolbox
for Observer Pattern, Reworking the Weather Station with the built-in support, Tools for your Design Toolbox
cohesion, Single Responsibility
Collaborations section, in pattern catalog, Looking more closely at the Design Pattern definition
collection classes, Iterators and Collections
collection of objects
abstracting with Iterator Pattern
about, The Iterator and Composite Patterns: Well-Managed Collections
adding Iterators, Adding an Iterator to DinerMenu
cleaning up code using java.util.Iterator, Cleaning things up with java.util.Iterator
remove() method in, Making some improvements...
implementing Iterators for, Meet the Iterator Pattern
integrating into framework
about, Taking a look at the Café Menu
reworking code, Reworking the Café Menu code
meaning of, Meet the Iterator Pattern
using Composite Pattern
about, Designing Menus with Composite
implementing components, Implementing the Menu Component
testing code, Getting ready for a test drive...
tree structure, The Composite Pattern defined, Getting ready for a test drive...
using with Iterators, Flashback to Iterator
using whole-part relationships, The magic of Iterator & Composite together...
Collections, Iterators and, Iterators and Collections
Combining Patterns
Abstract Factory Pattern, Duck reunion
Adapter Pattern, Duck reunion
class diagram for, A duck’s eye view: the class diagram
Composite Pattern, Duck reunion
Decorator Pattern, Duck reunion
Iterator Pattern, Duck reunion
Observer Pattern, Duck reunion
command classes, in Command Pattern
about, The Command Pattern means lots of command classes
passing method references, Simplifying even more with method references
using lambda expressions, Simplifying the Remote Control with lambda expressions
command objects
encapsulating requests to do something, Cubicle Conversation
mapping, From the Diner to the Command Pattern
using, Using the command object
Command Pattern
command classes in
about, The Command Pattern means lots of command classes
passing method references, Simplifying even more with method references
using lambda expressions, Simplifying the Remote Control with lambda expressions
command objects
building, Our first command object
encapsulating requests to do something, Cubicle Conversation
mapping, From the Diner to the Command Pattern
using, Using the command object
definition of, The Command Pattern defined
dumb and smart command objects, Using a macro command
exercise matching description of, So you wanna be a Design Patterns writer, Boy, it’s been great having you in Objectville.
home automation remote control
about, Taking a look at the vendor classes
building, Our first command object, Tools for your Design Toolbox
class diagram, The Command Pattern defined: the class diagram
command classes in, The Command Pattern means lots of command classes, Simplifying even more with method references
creating commands to be loaded, The Command Pattern defined: the class diagram
defining, The Command Pattern defined
designing, Cubicle Conversation
display of on and off slots, Check out the results of all those lambda expression commands...
implementing, Implementing the Commands
macro commands, Every remote needs a Party Mode!, Using a macro command, Tools for your Design Toolbox
mapping, From the Diner to the Command Pattern, Tools for your Design Toolbox
Null Object in, Now, let’s check out the execution of our remote control test..., Test the remote control with lambda expressions
testing, Using the command object, Putting the Remote Control through its paces, Using a macro command, Test the remote control with lambda expressions
undo commands, Time to write that documentation..., Get ready to test the ceiling fan, Using a macro command, Tools for your Design Toolbox
vendor classes for, Taking a look at the vendor classes
writing documentation, Time to write that documentation...
logging requests using, More uses of the Command Pattern: logging requests
mapping, From the Diner to the Command Pattern, Tools for your Design Toolbox
Null Object, Now, let’s check out the execution of our remote control test...
queuing requests using, More uses of the Command Pattern: queuing requests
understanding, Meanwhile, back at the Diner..., or, A brief introduction to the Command Pattern
Complexity Hiding Proxy, The Proxy Zoo
components of object, The Principle of Least Knowledge
Composite Iterator, Flashback to Iterator
Composite Pattern
combining patterns, Duck reunion
definition of, The Composite Pattern defined
dessert submenu using
about, Just when we thought it was safe...
designing, Designing Menus with Composite, Getting ready for a test drive...
implementing, Implementing the Menu Component
testing, Getting ready for a test drive...
using Iterators in, Flashback to Iterator
exercise matching description of, The magic of Iterator & Composite together..., Tools for your Design Toolbox, So you wanna be a Design Patterns writer, Boy, it’s been great having you in Objectville.
in Model 2, Strategy
in Model-View-Controller, Looking at MVC through patterns-colored glasses, Composite
Iterator Pattern and, Flashback to Iterator
on implementation issues, The magic of Iterator & Composite together...
safety versus transparency, Duck reunion
transparency in, Getting ready for a test drive...
tree structure of, The Composite Pattern defined, Getting ready for a test drive...
try/catch, using, The magic of Iterator & Composite together...
using with Iterator, Flashback to Iterator
vegetarian menu using Iterators, Give me the vegetarian menu
composition
adding behavior at runtime, Welcome to Starbuzz Coffee
favoring over inheritance, HAS-A can be better than IS-A, Welcome to Starbuzz Coffee
inheritance vs., Cubicle Conversation
object adapters and, Object and class adapters
compound patterns, using
about, Compound Patterns: Patterns of Patterns
Model 2
about, MVC and the Web
Composite Pattern, Strategy
from cell phone, Model 2: DJ’ing from a cell phone
Observer Pattern, Design Patterns and Model 2
Strategy Pattern, Strategy
Model-View-Controller
about, If Elvis were a compound pattern, his name would be Model-View-Controller, and he’d be singing a little song like this..., Meet the Model-View-Controller
Adapter Pattern, Exploring Strategy
Beat model, Meet the Java DJ View, Exercise Solutions
Composite Pattern, Looking at MVC through patterns-colored glasses, Composite
controllers per view, Composite
Heart controller, Now we’re ready for a HeartController, Exercise Solutions
Heart model, Exploring Strategy, Exercise Solutions
implementing controller, Now for the Controller
implementing DJ View, Using MVC to control the beat..., Exercise Solutions
Mediator Pattern, Composite
model in, Composite
Observer Pattern, Looking at MVC through patterns-colored glasses, Building the pieces
song, If Elvis were a compound pattern, his name would be Model-View-Controller, and he’d be singing a little song like this...
state of model, Composite
Strategy Pattern, Looking at MVC through patterns-colored glasses, Now for the Controller, Exploring Strategy
testing, Putting it all together...
views accessing model state methods, Composite
web and, MVC and the Web
multiple patterns vs., Duck reunion
concrete classes
deriving from, A few guidelines to help you follow the Principle...
Factory Pattern and, Factory Method Pattern defined
getting rid of, Reworking the PizzaStore class
instantiating objects and, Looking at object dependencies
using new operator for instantiating, The Factory Pattern: Baking with OO Goodness
variables holding reference to, A few guidelines to help you follow the Principle...
concrete creators, Factory Method Pattern defined
concrete implementation object, assigning, Designing the Duck Behaviors
concrete methods, as hooks, Template Method Pattern defined
concrete subclasses
abstract class methods defined by, Let’s run the Test Drive
in Pizza Store project, Allowing the subclasses to decide
Consequences section, in pattern catalog, Looking more closely at the Design Pattern definition
constant in software development, The one constant in software development
controlling object access, using Proxy Pattern
about, The Proxy Pattern: Controlling Object Access
Caching Proxy, What did we do?, The Proxy Zoo
Complexity Hiding Proxy, The Proxy Zoo
Copy-On-Write Proxy, The Proxy Zoo
Firewall Proxy, The Proxy Zoo
Protection Proxy
about, Using the Java API’s Proxy to create a protection proxy
creating dynamic proxy, Big Picture: creating a Dynamic Proxy for the PersonBean
implementing matchmaking service, The PersonBean implementation
protecting subjects, Five-minute drama: protecting subjects
testing matchmaking service, Testing the matchmaking service
using dynamic proxy, Using the Java API’s Proxy to create a protection proxy
Remote Proxy
about, Testing the Monitor
adding to monitoring code, Adding a remote proxy to the Gumball Machine monitoring code
preparing for remote service, Getting the GumballMachine ready to be a remote service
registering with RMI registry, Registering with the RMI registry...
reusing client for, Now for the GumballMonitor client...
reviewing process, And now let’s put the monitor in the hands of the CEO. Hopefully, this time he’ll love it
role of, The role of the ‘remote proxy’
testing, Writing the Monitor test drive
wrapping objects and, What did we do?
Smart Reference Proxy, The Proxy Zoo
Synchronization Proxy, The Proxy Zoo
Virtual Proxy
about, Get ready for Virtual Proxy
designing Virtual Proxy, Designing the CD cover Virtual Proxy
reviewing process, What did we do?
testing, Testing the CD Cover Viewer
writing Image Proxy, Writing the Image Proxy
Copy-On-Write Proxy, The Proxy Zoo
create method
replacing new operator with, Reworking the PizzaStore class
static method vs., Building a simple pizza factory
using subclasses with, Allowing the subclasses to decide
creating static classes instead of Singleton, Houston, Hershey, PA we have a problem...
creational patterns category, Design Patterns, Pattern Categories, Pattern Categories
creator classes, in Factory Method Pattern, It’s finally time to meet the Factory Method Pattern, Factory Method Pattern defined
crossword puzzle, Tools for your Design Toolbox
Cunningham, Ward, Your journey has just begun...

D

Decorator Pattern
about, Meet the Decorator Pattern, Give it a spin
Adapter Pattern vs., Writing the EnumerationIterator adapter
combining patterns, Duck reunion
definition of, The Decorator Pattern defined
disadvantages of, Decorating the java.io classes
exercise matching description of, Running the code..., So you wanna be a Design Patterns writer, Boy, it’s been great having you in Objectville.
exercise matching pattern with its intent, And now for something different..., Tools for your Design Toolbox
in Java I/O, Real World Decorators: Java I/O
in Structural patterns category, Pattern Categories
Proxy Pattern vs., What did we do?
Starbuzz Coffee project
about, Welcome to Starbuzz Coffee
adding sizes to code, Serving some coffees
constructing drink orders, Constructing a drink order with Decorators
decorating beverages in, Decorating our Beverages
drawing beverage order process, New barista training, Tools for your Design Toolbox
testing order code, Serving some coffees
using Java decorators, Real World Decorators: Java I/O
writing code, Writing the Starbuzz code
decoupling, Iterator allowing, What we have so far..., What does this get us?, Iterator Pattern defined, Iterators and Collections
delegation, adding behavior at runtime, Welcome to Starbuzz Coffee
dependence, in Observer Pattern, The Observer Pattern defined: the class diagram
Dependency Inversion Principle, The Dependency Inversion Principle, The Hollywood Principle and Template Method
dependency rot, The Hollywood Principle
Design Patterns
becoming writer of, So you wanna be a Design Patterns writer
behavioral patterns category, Pattern Categories, Pattern Categories
categories of, Pattern Categories
class patterns, Pattern Categories
creational patterns category, Pattern Categories, Pattern Categories
definition of, Design Pattern defined
discovering own, Looking more closely at the Design Pattern definition
exercise matching description of, Boy, it’s been great having you in Objectville.
frameworks vs., How do I use Design Patterns?
guide to better living with, Better Living with Patterns: Patterns in the Real World
implement on interface in, The Simple Factory defined
libraries vs., How do I use Design Patterns?
object patterns, Pattern Categories
organizing, Organizing Design Patterns
overusing, Your Mind on Patterns
resources for, Your journey has just begun...
rule of three applied to, So you wanna be a Design Patterns writer
structural patterns category, Pattern Categories, Pattern Categories
thinking in patterns, Thinking in Patterns
using, How do I use Design Patterns?, If you don’t need it now, don’t do it now., Your Mind on Patterns
your mind on patterns, Your Mind on Patterns
Design Patterns: Reusable Object-Oriented Software (Gamma et al.), Your journey has just begun...
design principles
Dependency Inversion Principle, The Dependency Inversion Principle
designing upon abstractions, The Dependency Inversion Principle
encapsulate what varies, Zeroing in on the problem..., Tools for your Design Toolbox, Tools for your Design Toolbox, Factory Method Pattern defined
favor composition over inheritance, HAS-A can be better than IS-A, Tools for your Design Toolbox, Tools for your Design Toolbox, The messy STATE of things...
One Class, One Responsibility Principle, Congratulations!, Single Responsibility, Getting ready for a test drive...
one instance. (see Singleton Pattern)
Open-Closed Principle, The Open-Closed Principle, Is the Waitress ready for prime time?, The messy STATE of things...
Principle of Least Knowledge, The Principle of Least Knowledge
program to an interface, not an implementation, Designing the Duck Behaviors, The dark side of java.util.Observable, Tools for your Design Toolbox, Tools for your Design Toolbox, What does this get us?
Single Responsibility Principle, Single Responsibility
strive for loosely coupled designs between objects that interact, The power of Loose Coupling
The Hollywood Principle, The Hollywood Principle
using Observer Pattern, Tools for your Design Toolbox, Tools for your Design Toolbox
Design Puzzles
drawing class diagram making use of view and controller, Now for the Controller, Exercise Solutions
drawing parallel set of classes, Another perspective: parallel class hierarchies, Tools for your Design Toolbox
drawing state diagram, You knew it was coming... a change request!, Tools for your Design Toolbox
of classes and interfaces, Speaking of Design Patterns..., Tools for your Design Toolbox
redesigning classes to remove redundancy, It’s time for some more caffeine
redesigning Image Proxy, Writing the Image Proxy, Tools for your Design Toolbox
dessert submenu, using Composite Pattern
about, Just when we thought it was safe...
designing, Designing Menus with Composite, Getting ready for a test drive...
implementing, Implementing the Menu Component
testing, Getting ready for a test drive...
using Iterators in, Flashback to Iterator
diner menus, merging (Iterator Pattern)
about, Breaking News: Objectville Diner and Objectville Pancake House Merge
adding Iterators, Adding an Iterator to DinerMenu
cleaning up code using java.util.Iterator, Cleaning things up with java.util.Iterator
encapsulating Iterator, Can we encapsulate the iteration?
implementing Iterators for, Meet the Iterator Pattern
implementing of, Lou and Mel’s Menu implementations
DJ View, Using MVC to control the beat..., Exercise Solutions
Domain-Specific Patterns, The Patterns Zoo
double-checked locking, reducing use of synchronization using, 3. Use “double-checked locking” to reduce the use of synchronization in getInstance().
Duck Magnets exercises, object and class object and class adapters, Object and class adapters
duck simulator, rebuilding
about, Duck reunion
adding Abstract Factory Pattern, Duck reunion, Exercise Solutions
adding Adapter Pattern, Duck reunion
adding Composite Pattern, Duck reunion
adding Decorator Pattern, Duck reunion
adding Iterator Pattern, Duck reunion
adding Observer Pattern, Duck reunion
class diagram, A duck’s eye view: the class diagram
dumb command objects, Using a macro command
dynamic aspect of dynamic proxies, Running the code...
dynamic proxy
creating, Big Picture: creating a Dynamic Proxy for the PersonBean
using to create proxy implementation, Using the Java API’s Proxy to create a protection proxy

E

encapsulate what varies, Zeroing in on the problem..., Tools for your Design Toolbox, Tools for your Design Toolbox, Factory Method Pattern defined, The messy STATE of things...
encapsulating algorithms
about, The Template Method Pattern: Encapsulating Algorithms
abstracting prepareRecipe(), Abstracting prepareRecipe()
encapsulating behavior, Designing the Duck Behaviors
encapsulating code
in behaviors, The Big Picture on encapsulated behaviors
in object creation, Encapsulating object creation
object creation, Factory Method Pattern defined
Template Method Pattern and
about, Meet the Template Method
applets in, Applets
code up close, Template Method Pattern defined
definition of, Template Method Pattern defined
hooks in, Template Method Pattern defined
in real world, Template Methods in the Wild
sorting with, Sorting with Template Method
Swing and, Swingin’ with Frames
testing code, Let’s run the Test Drive
The Hollywood Principle and, The Hollywood Principle
encapsulating iteration, Can we encapsulate the iteration?
encapsulating method invocation, The Command Pattern: Encapsulating Invocation, The Command Pattern defined
encapsulating object construction, Builder
encapsulating requests, The Command Pattern defined
encapsulating subsystem, Facades, Lights, Camera, Facade!
Enumeration
about, Real-world adapters
adapting to Iterator, Adapting an Enumeration to an Iterator
java.util.Enumeration as older implementation of Iterator, Real-world adapters, Iterator Pattern defined
remove() method and, Dealing with the remove() method
writing Adapter that adapts Iterator to, Writing the EnumerationIterator adapter, Tools for your Design Toolbox
exercises
Be the JVM solution, dealing with multithreading, Houston, Hershey, PA we have a problem..., Tools for your Design Toolbox
Code Magnets
for DinerMenu Iterator, Iterators and Collections, Tools for your Design Toolbox
for Observer Pattern, Reworking the Weather Station with the built-in support, Tools for your Design Toolbox
dealing with multithreading, Object and class adapters
Design Puzzles
drawing class diagram making use of view and controller, Now for the Controller, Exercise Solutions
drawing state diagram, You knew it was coming... a change request!, Tools for your Design Toolbox
of classes and interfaces, Speaking of Design Patterns..., Tools for your Design Toolbox
redesigning classes to remove redundancy, And now the Tea...
redesigning Image Proxy, Writing the Image Proxy, Tools for your Design Toolbox
Duck Magnets exercises, object and class object and class adapters, Object and class adapters
implementing Iterator, Reworking the Diner Menu with Iterator
implementing undo button for macro command, Using a macro command, Tools for your Design Toolbox
Sharpen Your Pencil
altering decorator classes, Serving some coffees, Tools for your Design Toolbox
annotating Gumball Machine states, Let’s take a look at what we’ve done so far..., Tools for your Design Toolbox
annotating state diagram, Defining the State interfaces and classes, Tools for your Design Toolbox
building ingredient factory, Building the New York ingredient factory, A very dependent PizzaStore
changing classes for Decorator Pattern, Duck reunion, Exercise Solutions
changing code to fit framework in Iterator Pattern, Taking a look at the Café Menu, Tools for your Design Toolbox
choosing descriptions of state of implementation, The messy STATE of things..., Tools for your Design Toolbox
class diagram for implementation of prepareRecipe(), Abstracting prepareRecipe(), Tools for your Design Toolbox
creating commands for off buttons, Using a macro command, Tools for your Design Toolbox
determining classes violating Principle of Least Knowledge, Keeping your method calls in bounds..., Tools for your Design Toolbox
drawing beverage order process, Tools for your Design Toolbox
fixing Chocolate Boiler code, Meanwhile, back at the Chocolate Factory..., Tools for your Design Toolbox
identifying factors influencing design, Welcome to Starbuzz Coffee
implementing garage door command, Creating a simple test to use the Remote Control, Tools for your Design Toolbox
implementing state classes, Implementing more states, Tools for your Design Toolbox
matching patterns with categories, Organizing Design Patterns
method for refilling gumball machine, We almost forgot!, Tools for your Design Toolbox
on adding behaviors, Implementing the Duck Behaviors
on implementation of printmenu(), The Java-Enabled Waitress Specification, Tools for your Design Toolbox
on inheritance, Joe thinks about inheritance..., Tools for your Design Toolbox
sketching out classes, The power of Loose Coupling
things driving change, The one constant in software development, Tools for your Design Toolbox
turning class into Singleton, The Chocolate Factory, Tools for your Design Toolbox
weather station SWAG, Taking a first, misguided SWAG at the Weather Station, Tools for your Design Toolbox
writing Abstract Factory Pattern, Duck reunion, Exercise Solutions
writing classes for adapters, Here’s how the Client uses the Adapter, Tools for your Design Toolbox
writing dynamic proxy, Step two: creating the Proxy class and instantiating the Proxy object, Tools for your Design Toolbox
writing Flock observer code, Duck reunion, Exercise Solutions
writing methods for classes, Welcome to Starbuzz Coffee, Tools for your Design Toolbox
Who Does What
matching objects and methods to Command Pattern, From the Diner to the Command Pattern, Tools for your Design Toolbox
matching pattern with description, The Hollywood Principle and Template Method, Tools for your Design Toolbox, The magic of Iterator & Composite together..., Tools for your Design Toolbox, We almost forgot!, Tools for your Design Toolbox, Running the code..., Tools for your Design Toolbox, So you wanna be a Design Patterns writer, Boy, it’s been great having you in Objectville.
matching patterns with its intent, And now for something different..., Tools for your Design Toolbox
writing Adapter that adapts Iterator to Enumeration, Writing the EnumerationIterator adapter, Tools for your Design Toolbox
writing handler for matchmaking service, Creating Invocation Handlers continued..., Tools for your Design Toolbox
external iterators, Iterator Pattern defined

F

Facade Pattern
about, And now for something different...
Adapter Pattern vs., Lights, Camera, Facade!
advantages, Lights, Camera, Facade!
benefits of, Lights, Camera, Facade!
building home theater system
about, Home Sweet Home Theater
constructing Facade in, Constructing your home theater facade
implementing Facade class, Lights, Camera, Facade!
implementing interface, Implementing the simplified interface
testing, Time to watch a movie (the easy way)
class diagram, Facade Pattern defined
Complexity Hiding Proxy vs., The Proxy Zoo
definition of, Facade Pattern defined
exercise matching description of, The magic of Iterator & Composite together..., Tools for your Design Toolbox, Running the code..., So you wanna be a Design Patterns writer, Boy, it’s been great having you in Objectville.
exercise matching pattern with its intent, And now for something different..., Tools for your Design Toolbox
Principle of Least Knowledge and, Tools for your Design Toolbox
factory method
about, Declaring a factory method, Factory Method Pattern defined
as abstract, Factory Method Pattern defined
declaring, Declaring a factory method
parallel class hierarchies and, Another perspective: parallel class hierarchies
Factory Method Pattern
about, It’s finally time to meet the Factory Method Pattern
about factory objects, Encapsulating object creation
Abstract Factory Pattern and, Abstract Factory Pattern defined
code up close, Reworking the pizzas, continued...
concrete classes and, Factory Method Pattern defined
creator classes, It’s finally time to meet the Factory Method Pattern
declaring factory method, Declaring a factory method
definition of, Factory Method Pattern defined
Dependency Inversion Principle, The Dependency Inversion Principle
drawing parallel set of classes, Another perspective: parallel class hierarchies, Tools for your Design Toolbox
exercise matching description of, So you wanna be a Design Patterns writer, Boy, it’s been great having you in Objectville.
looking at object dependencies, Looking at object dependencies
parallel class hierarchies, Another perspective: parallel class hierarchies
product classes, It’s finally time to meet the Factory Method Pattern
Simple Factory and, Factory Method Pattern defined
Factory Pattern
Abstract Factory
about, What have we done?
building ingredient factories, Building the ingredient factories, A very dependent PizzaStore
combining patterns, Duck reunion, Exercise Solutions
definition of, Abstract Factory Pattern defined
exercise matching description of, So you wanna be a Design Patterns writer, Boy, it’s been great having you in Objectville.
Factory Method Pattern and, Abstract Factory Pattern defined
implementing, Abstract Factory Pattern defined
exercise matching description of, The Hollywood Principle and Template Method, Tools for your Design Toolbox
Factory Method
about, It’s finally time to meet the Factory Method Pattern
Abstract Factory and, Abstract Factory Pattern defined
Abstract Factory in, What have we done?, Abstract Factory Pattern defined
advantages of, Factory Method Pattern defined
code up close, Reworking the pizzas, continued...
creator classes, It’s finally time to meet the Factory Method Pattern
declaring factory method, Declaring a factory method
definition of, Factory Method Pattern defined
Dependency Inversion Principle, The Dependency Inversion Principle
drawing parallel set of classes, Another perspective: parallel class hierarchies, Tools for your Design Toolbox
exercise matching description of, So you wanna be a Design Patterns writer, Boy, it’s been great having you in Objectville.
looking at object dependencies, Looking at object dependencies
parallel class hierarchies, Another perspective: parallel class hierarchies
product classes, It’s finally time to meet the Factory Method Pattern
Simple Factory and, Factory Method Pattern defined
Simple Factory
about factory objects, Encapsulating object creation
building factory, Building a simple pizza factory
definition of, The Simple Factory defined
Factory Method Pattern and, Factory Method Pattern defined
pattern honorable mention, The Simple Factory defined
using new operator for instantiating concrete classes, The Factory Pattern: Baking with OO Goodness
favor composition over inheritance, HAS-A can be better than IS-A, Tools for your Design Toolbox, Tools for your Design Toolbox, The messy STATE of things...
Firewall Proxy, The Proxy Zoo
Flyweight Pattern, Flyweight
forces, Looking more closely at the Design Pattern definition
frameworks vs. libraries, How do I use Design Patterns?

G

Gamma, Erich, Cruisin’ Objectville with the Gang of Four
Gang of Four (GoF)
about, Looking more closely at the Design Pattern definition, Cruisin’ Objectville with the Gang of Four
catalogs, Looking more closely at the Design Pattern definition
garbage collectors, Congratulations!
global access point, Singleton Pattern defined
global variables vs. Singleton, Congratulations!
guide to better living with Design Patterns, Better Living with Patterns: Patterns in the Real World
gumball machine controller implementation, using State Pattern
about, Jawva Breakers
cleaning up code, Sanity check...
demonstration of, Demo for the CEO of Mighty Gumball, Inc.
diagram to code, State machines 101
finishing, Finishing the game
one in ten contest
about, You knew it was coming... a change request!
annotating state diagram, Defining the State interfaces and classes, Tools for your Design Toolbox
changing code, The messy STATE of things...
drawing state diagram, You knew it was coming... a change request!, Tools for your Design Toolbox
implementing state classes, Implementing our State classes, Implementing more states, We still need to finish the Gumball 1 in 10 game
new design, The new design
reworking state classes, Reworking the Gumball Machine
refilling gumball machine, We almost forgot!
SoldState and WinnerState in, Demo for the CEO of Mighty Gumball, Inc.
testing code, In-house testing
writing code, Writing the code
gumball machine monitoring, using Proxy Patterns
about, The Proxy Pattern: Controlling Object Access
Remote Proxy
about, Testing the Monitor
adding to monitoring code, Adding a remote proxy to the Gumball Machine monitoring code
preparing for remote service, Getting the GumballMachine ready to be a remote service
registering with RMI registry, Registering with the RMI registry...
reusing client for, Now for the GumballMonitor client...
reviewing process, And now let’s put the monitor in the hands of the CEO. Hopefully, this time he’ll love it
role of, The role of the ‘remote proxy’
testing, Writing the Monitor test drive
wrapping objects and, What did we do?

H

HAS-A relationships
about, HAS-A can be better than IS-A
wrapping components, The Decorator Pattern defined
HashMap, Reworking the Café Menu code, Iterators and Collections, Iterators and Collections
hasNext() method
in arrays, Adding an Iterator to DinerMenu
in java.util.Iterator, Iterator Pattern defined
Head First learning principles, And we know what your brain is thinking.
Head First Servlets & JSP (Basham, Sierra and Bates), Model 2: DJ’ing from a cell phone
Helm, Richard, Cruisin’ Objectville with the Gang of Four
high-level component classes, The Dependency Inversion Principle
The Hillside Group (website), Your journey has just begun...
The Hollywood Principle, The Hollywood Principle
home automation remote control, using Command Pattern
about, Taking a look at the vendor classes
building, Our first command object, Tools for your Design Toolbox
class diagram, The Command Pattern defined: the class diagram
command classes in
about, The Command Pattern means lots of command classes
passing method references, Simplifying even more with method references
using lambda expressions, Simplifying the Remote Control with lambda expressions
creating commands to be loaded, The Command Pattern defined: the class diagram
defining, The Command Pattern defined
designing, Cubicle Conversation
display of on and off slots, Check out the results of all those lambda expression commands...
implementing, Implementing the Commands
macro commands
about, Every remote needs a Party Mode!
hard coding vs., Using a macro command
undo button, Using a macro command, Tools for your Design Toolbox
using, Using a macro command
mapping, From the Diner to the Command Pattern, Tools for your Design Toolbox
Null Object, Now, let’s check out the execution of our remote control test..., Test the remote control with lambda expressions
testing, Using the command object, Putting the Remote Control through its paces, Using a macro command, Test the remote control with lambda expressions
undo commands
creating, Time to write that documentation...
creating multiple, Using a macro command
implementing for macro command, Tools for your Design Toolbox
testing, Time to QA that Undo button!, Get ready to test the ceiling fan
using state to implement, Using state to implement Undo
vendor classes for, Taking a look at the vendor classes
writing documentation, Time to write that documentation...
home theater system, building
about, Home Sweet Home Theater
constructing Facade in, Constructing your home theater facade
implementing interface, Implementing the simplified interface
Sharpen Your Pencil, Keeping your method calls in bounds...
testing, Time to watch a movie (the easy way)
using Facade Pattern, Lights, Camera, Facade!
hooks, in Template Method Pattern, Template Method Pattern defined

I

Image Proxy, writing, Writing the Image Proxy
implement on interface, in design patterns, The Simple Factory defined
Implementation section, in pattern catalog, Looking more closely at the Design Pattern definition
implementations
coding to, What’s wrong with our implementation?
programming, More integration...
implementing behaviors, Implementing the Duck Behaviors
import and package statements, Our PizzaStore isn’t going to be very popular without some pizzas, so let’s implement them
inheritance
about, Joe thinks about inheritance...
composition vs., Cubicle Conversation
disadvantages, Joe thinks about inheritance...
disadvantages of, Welcome to Starbuzz Coffee
favoring composition over, HAS-A can be better than IS-A
for maintenance, But something went horribly wrong...
for reuse, But something went horribly wrong..., Implementing the Duck Behaviors
implementing multiple, Object and class adapters
instance variables
using instead of classes, Welcome to Starbuzz Coffee
wrapping to object, Coding condiments
instantiating concrete classes
in objects, Looking at object dependencies
using new operator for, The Factory Pattern: Baking with OO Goodness
instantiating one object, The Singleton Pattern: One of a Kind Objects
integrating behaviors, Integrating the Duck Behavior
integrating Cafe Menu, using Iterator Pattern
about, Taking a look at the Café Menu
reworking code, Reworking the Café Menu code
Intent section, in pattern catalog, Looking more closely at the Design Pattern definition
interface
coding to, The Factory Pattern: Baking with OO Goodness
programming to, Designing the Duck Behaviors, The dark side of java.util.Observable
interface type, Integrating the Duck Behavior, Testing the Duck code
internal iterators, Iterator Pattern defined
Interpreter Pattern, Interpreter
inversion, in Dependency Inversion Principle, Applying the Principle
invoker, From the Diner to the Command Pattern, The Command Pattern defined, Assigning Commands to slots, Tools for your Design Toolbox
Iterator Pattern
about, Meet the Iterator Pattern
class diagram, Iterator Pattern defined
code up close using HashMap, Reworking the Café Menu code
code violating Open-Closed Principle, Is the Waitress ready for prime time?
Collections and, Iterators and Collections
combining patterns, Duck reunion
Composite Pattern and, Getting ready for a test drive...
definition of, Iterator Pattern defined
exercise matching description of, The magic of Iterator & Composite together..., Tools for your Design Toolbox, So you wanna be a Design Patterns writer, Boy, it’s been great having you in Objectville.
integrating Cafe Menu
about, Taking a look at the Café Menu
reworking code, Reworking the Café Menu code
java.util.Iterator, Making some improvements...
merging diner menus
about, Breaking News: Objectville Diner and Objectville Pancake House Merge
adding Iterators, Adding an Iterator to DinerMenu
cleaning up code using java.util.Iterator, Cleaning things up with java.util.Iterator
encapsulating Iterator, Can we encapsulate the iteration?
implementing Iterators for, Meet the Iterator Pattern
implementing of, Lou and Mel’s Menu implementations
Null Iterator, Flashback to Iterator, The Null Iterator
removing objects, Making some improvements...
Single Responsibility Principle, Single Responsibility
Iterators
adding, Adding an Iterator to DinerMenu
allowing decoupling, What we have so far..., What does this get us?, Iterator Pattern defined, Iterators and Collections
cleaning up code using java.util.Iterator, Cleaning things up with java.util.Iterator
Collections and, Iterators and Collections
encapsulating, Can we encapsulate the iteration?
Enumeration adapting to, Adapting an Enumeration to an Iterator, Iterator Pattern defined
external, Iterator Pattern defined
HashMap and, Iterators and Collections
implementing, Meet the Iterator Pattern
internal and external, Iterator Pattern defined
ordering of, Iterator Pattern defined
polymorphic code using, Iterator Pattern defined, Iterator Pattern defined
using ListInterator, Iterator Pattern defined
using with Composite Pattern, Flashback to Iterator
writing Adapter for Enumeration, Dealing with the remove() method
writing Adapter that adapts to Enumeration, Writing the EnumerationIterator adapter, Tools for your Design Toolbox

J

Java Collections Framework, Iterators and Collections
Java decorators (java.io packages), Real World Decorators: Java I/O
Java Virtual Machines (JVMs)
bug in garbage collector, Congratulations!
Remote Method Invocation (RMI), Adding a remote proxy to the Gumball Machine monitoring code
support of volatile keyword, 3. Use “double-checked locking” to reduce the use of synchronization in getInstance().
java.lang.reflect package, proxy support in, Java RMI, the Big Picture, Using the Java API’s Proxy to create a protection proxy, Creating Invocation Handlers continued...
java.util, built-in Observer Pattern, Using Java’s built-in Observer Pattern
java.util.Collection, Iterators and Collections
java.util.Enumeration, as older implementation of Iterator, Real-world adapters, Iterator Pattern defined
java.util.Iterator
cleaning up code using, Cleaning things up with java.util.Iterator
interface of, Making some improvements...
using, Iterator Pattern defined
JButton, in Swing API, Other places you’ll find the Observer Pattern in the JDK
JFrames, Swing, Swingin’ with Frames
Johnson, Ralph, Cruisin’ Objectville with the Gang of Four

K

Kathy Sierra, (Head First Servlets & JSP), Model 2: DJ’ing from a cell phone
KISS (Keep It Simple), in designing patterns, Thinking in Patterns
Known Uses section, in pattern catalog, Looking more closely at the Design Pattern definition

L

lambda expressions, And the code..., Simplifying the Remote Control with lambda expressions
Law of Demeter, Keeping your method calls in bounds...
lazy instantiation, Singleton Pattern defined
leaves, in Composite Pattern tree structure, The Composite Pattern defined, Getting ready for a test drive...
libraries
design patterns vs., How do I use Design Patterns?
frameworks vs., How do I use Design Patterns?
LinkedList, Iterators and Collections
ListInterator, Iterator Pattern defined
logging requests, using Command Pattern, More uses of the Command Pattern: logging requests
looping through array items, The Java-Enabled Waitress Specification, What now?
loose coupling, The power of Loose Coupling

M

macro commands
about, Every remote needs a Party Mode!
macro commands
hard coding vs., Using a macro command
undo button, Using a macro command, Tools for your Design Toolbox
using, Using a macro command
magic bullet, Design Patterns as not, Thinking in Patterns
maintenance, inheritance for, But something went horribly wrong...
matchmaking service, using Proxy Pattern
about, Matchmaking in Objectville
creating dynamic proxy, Big Picture: creating a Dynamic Proxy for the PersonBean
implementing, The PersonBean implementation
protecting subjects, Five-minute drama: protecting subjects
testing, Testing the matchmaking service
Mediator Pattern, Composite, Mediator
Memento Pattern, Memento
merging diner menus (Iterator Pattern)
about, Breaking News: Objectville Diner and Objectville Pancake House Merge
adding Iterators, Adding an Iterator to DinerMenu
cleaning up code using java.util.Iterator, Cleaning things up with java.util.Iterator
encapsulating Iterator, Can we encapsulate the iteration?
implementing Iterators for, Meet the Iterator Pattern
implementing of, Lou and Mel’s Menu implementations
method of objects, components of object vs., The Principle of Least Knowledge
method references, passing, Simplifying even more with method references
methods
as hooks, Template Method Pattern defined
overriding from implemented, A few guidelines to help you follow the Principle...
Model 2
about, MVC and the Web
Composite Pattern, Strategy
from cell phone, Model 2: DJ’ing from a cell phone
Observer Pattern, Design Patterns and Model 2
Strategy Pattern, Strategy
Model-View-Controller (MVC)
about, If Elvis were a compound pattern, his name would be Model-View-Controller, and he’d be singing a little song like this..., Meet the Model-View-Controller
Adapter Pattern, Adapting the Model
Beat model, Meet the Java DJ View, Exercise Solutions
Composite Pattern, Looking at MVC through patterns-colored glasses, Composite
controllers per view, Composite
Heart controller, Now we’re ready for a HeartController, Exercise Solutions
Heart model, Exploring Strategy
implementing controller, Now for the Controller, Exercise Solutions
implementing DJ View, Using MVC to control the beat..., Exercise Solutions
Mediator Pattern, Composite
model in, Composite
Observer Pattern, Looking at MVC through patterns-colored glasses, Building the pieces
song, If Elvis were a compound pattern, his name would be Model-View-Controller, and he’d be singing a little song like this...
state of model, Composite
Strategy Pattern, Looking at MVC through patterns-colored glasses, Now for the Controller, Exploring Strategy, Exercise Solutions
testing, Putting it all together...
views accessing model state methods, Composite
web and, MVC and the Web
modeling state, State machines 101
Motivation section, in pattern catalog, Looking more closely at the Design Pattern definition
multiple patterns, using
about, Compound Patterns: Patterns of Patterns
in duck simulator
about rebuilding, Duck reunion
adding Abstract Factory Pattern, Duck reunion, Exercise Solutions
adding Adapter Pattern, Duck reunion
adding Composite Pattern, Duck reunion
adding Decorator Pattern, Duck reunion
adding Iterator Pattern, Duck reunion
adding Observer Pattern, Duck reunion
class diagram, A duck’s eye view: the class diagram
multithreading
dealing with, Tools for your Design Toolbox
improving, Can we improve multithreading?

N

Name section, in pattern catalog, Looking more closely at the Design Pattern definition
new operator, replacing with concrete method, Reworking the PizzaStore class
next() method
in java.util.Iterator, Iterator Pattern defined
with Iterator, arrays, Adding an Iterator to DinerMenu
NoCommand, in remote control code, Now, let’s check out the execution of our remote control test..., Test the remote control with lambda expressions
nodes, in Composite Pattern tree structure, The Composite Pattern defined, Getting ready for a test drive...
Null Iterator, Flashback to Iterator, The Null Iterator
Null Objects, Now, let’s check out the execution of our remote control test...

O

object access, using Proxy Pattern for controlling
about, The Proxy Pattern: Controlling Object Access
Caching Proxy, What did we do?, The Proxy Zoo
Complexity Hiding Proxy, The Proxy Zoo
Copy-On-Write Proxy, The Proxy Zoo
Firewall Proxy, The Proxy Zoo
Protection Proxy
about, Using the Java API’s Proxy to create a protection proxy
creating dynamic proxy, Big Picture: creating a Dynamic Proxy for the PersonBean
implementing matchmaking service, The PersonBean implementation
protecting subjects, Five-minute drama: protecting subjects
testing matchmaking service, Testing the matchmaking service
using dynamic proxy, Using the Java API’s Proxy to create a protection proxy
Remote Proxy
about, Testing the Monitor
adding to monitoring code, Adding a remote proxy to the Gumball Machine monitoring code
preparing for remote service, Getting the GumballMachine ready to be a remote service
registering with RMI registry, Registering with the RMI registry...
reusing client for, Now for the GumballMonitor client...
reviewing process, And now let’s put the monitor in the hands of the CEO. Hopefully, this time he’ll love it
role of, The role of the ‘remote proxy’
testing, Writing the Monitor test drive
wrapping objects and, What did we do?
Smart Reference Proxy, The Proxy Zoo
Synchronization Proxy, The Proxy Zoo
Virtual Proxy
about, Get ready for Virtual Proxy
designing Virtual Proxy, Designing the CD cover Virtual Proxy
reviewing process, What did we do?
testing, Testing the CD Cover Viewer
writing Image Proxy, Writing the Image Proxy
object adapters vs. class adapters, Object and class adapters
object construction, encapsulating, Builder
object creation, encapsulating, Encapsulating object creation, Factory Method Pattern defined
object patterns, Design Patterns, Pattern Categories
Object-Oriented (OO) design., The Dependency Inversion Principle
(see also design principles)
adapters
about, Adapters all around us
creating Two Way Adapters, Here’s how the Client uses the Adapter
in action, If it walks like a duck and quacks like a duck, then it must might be a duck turkey wrapped with a duck adapter..., Test drive the adapter
object and class object and class, Object and class adapters
design patterns vs., How do I use Design Patterns?
extensibility and modification of code in, The Open-Closed Principle
guidelines for avoiding violation of Dependency Inversion Principle, A few guidelines to help you follow the Principle...
loosely coupled designs and, The power of Loose Coupling
Object-Oriented Systems, Languages and Applications (OOPSLA) conference, Your journey has just begun...
objects
components of, The Principle of Least Knowledge
creating, Factory Method Pattern defined
loosely coupled designs between, The power of Loose Coupling
sharing state, The State Pattern defined
Singleton, A small Socratic exercise in the style of The Little Lisper, Dissecting the classic Singleton Pattern implementation
wrapping, Meet the Decorator Pattern, Here’s how the Client uses the Adapter, Writing the EnumerationIterator adapter, Lights, Camera, Facade!, Duck reunion
Observer Pattern
about, The Observer Pattern: Keeping your Objects in the know, Meet the Observer Pattern
class design of, The Observer Pattern defined
class patterns category, So you wanna be a Design Patterns writer
combining patterns, Duck reunion
definition of, The Observer Pattern defined
dependence in, The Observer Pattern defined: the class diagram
exercise matching description of, The magic of Iterator & Composite together..., Tools for your Design Toolbox, Boy, it’s been great having you in Objectville.
in Five Minute Drama, Five-minute drama: a subject for observation
in Model 2, Design Patterns and Model 2
in Model-View-Controller, Looking at MVC through patterns-colored glasses, Building the pieces
lambada expressions and, And the code...
loose coupling in, The power of Loose Coupling
Observer object in, Publishers + Subscribers = Observer Pattern
one-to-many relationships, The Observer Pattern defined
process, A day in the life of the Observer Pattern
Publish-Subscribe as, Publishers + Subscribers = Observer Pattern
Subject object in, Publishers + Subscribers = Observer Pattern
Swing and, Other places you’ll find the Observer Pattern in the JDK
using built-in java.util, Using Java’s built-in Observer Pattern
weather station using
building display elements, Now, let’s build those display elements
designing, Designing the Weather Station
implementing, Implementing the Weather Station
powering up, Power up the Weather Station
SWAG, Taking a first, misguided SWAG at the Weather Station
unpacking classes, Unpacking the WeatherData class
using built-in Java Observer Pattern, Reworking the Weather Station with the built-in support
observers
in class diagram, The Observer Pattern defined: the class diagram
in Five Minute Drama, Five-minute drama: a subject for observation
in Observer Pattern, Publishers + Subscribers = Observer Pattern
One Class, One Responsibility Principle, Congratulations!, Single Responsibility, Getting ready for a test drive...
one in ten contest in gumball machine, using State Pattern
about, You knew it was coming... a change request!
annotating state diagram, Defining the State interfaces and classes, Tools for your Design Toolbox
changing code, The messy STATE of things...
drawing state diagram, You knew it was coming... a change request!, Tools for your Design Toolbox
implementing state classes, Implementing our State classes, Implementing more states, We still need to finish the Gumball 1 in 10 game
new design, The new design
reworking state classes, Reworking the Gumball Machine
one-to-many relationships, Observer Pattern defining, The Observer Pattern defined
OO (Object-Oriented) design., The Dependency Inversion Principle
(see also design principles)
adapters
about, Adapters all around us
creating Two Way Adapters, Here’s how the Client uses the Adapter
in action, If it walks like a duck and quacks like a duck, then it must might be a duck turkey wrapped with a duck adapter...
object and class object and class, Object and class adapters
test driving, Test drive the adapter
design patterns vs., How do I use Design Patterns?
extensibility and modification os code in, The Open-Closed Principle
guidelines for avoiding violation of Dependency Inversion Principle, A few guidelines to help you follow the Principle...
loosely coupled designs and, The power of Loose Coupling
OOPSLA (Object-Oriented Systems, Languages and Applications) conference, Your journey has just begun...
Open-Closed Principle
code violating, Is the Waitress ready for prime time?, The messy STATE of things...
effect on maintaining code, The Open-Closed Principle
Organizational Patterns, The Patterns Zoo
overusing Design Patterns, Your Mind on Patterns

P

package and import statements, Our PizzaStore isn’t going to be very popular without some pizzas, so let’s implement them
parallel class hierarchies, Another perspective: parallel class hierarchies
part-whole hierarchy, The Composite Pattern defined
Participants section, in pattern catalog, Looking more closely at the Design Pattern definition
pattern catalogs, Looking more closely at the Design Pattern definition, Looking more closely at the Design Pattern definition
Pattern Death Match pages, Compound Patterns: Patterns of Patterns
Pattern Languages of Programs (PLoP) conference, Your journey has just begun...
pattern templates, uses of, So you wanna be a Design Patterns writer
A Pattern Language (Alexander), Your journey has just begun...
patterns, using compound, Compound Patterns: Patterns of Patterns
patterns, using multiple
about, Compound Patterns: Patterns of Patterns
in duck simulator
about rebuilding, Duck reunion
adding Abstract Factory Pattern, Duck reunion, Exercise Solutions
adding Adapter Pattern, Duck reunion
adding Composite Pattern, Duck reunion
adding Decorator Pattern, Duck reunion
adding Iterator Pattern, Duck reunion
adding Observer Pattern, Duck reunion
class diagram, A duck’s eye view: the class diagram
Pizza Store project, using Factory Pattern
Abstract Factory in, What have we done?, Abstract Factory Pattern defined
behind the scenes, More pizza for Ethan and Joel...
building factory, Building a simple pizza factory
concrete subclasses in, Allowing the subclasses to decide
drawing parallel set of classes, Another perspective: parallel class hierarchies, Tools for your Design Toolbox
encapsulating object creation, Encapsulating object creation
ensuring consistency in ingredients, Meanwhile, back at the PizzaStore..., A very dependent PizzaStore
framework for, A framework for the pizza store
franchising store, Franchising the pizza store
identifying aspects in, Identifying the aspects that vary
implementing, Inverting your thinking...
making pizza store in, Let’s make a PizzaStore
ordering pizza, Our PizzaStore isn’t going to be very popular without some pizzas, so let’s implement them
referencing local ingredient factories, Revisiting our pizza stores
reworking pizzas, Reworking the pizzas...
PLoP (Pattern Languages of Programs) conference, Your journey has just begun...
polymorphic code, using on iterator, Iterator Pattern defined, Iterator Pattern defined
polymorphism, Designing the Duck Behaviors
prepareRecipe(), abstracting, Abstracting prepareRecipe()
Principle of Least Knowledge, The Principle of Least Knowledge
print() method, in dessert submenu using Composite Pattern, Implementing the Menu Component, The Composite Iterator
program to an interface, not an implementation, Designing the Duck Behaviors, The dark side of java.util.Observable, Tools for your Design Toolbox, Tools for your Design Toolbox, What does this get us?
program to interface vs. program to supertype, Designing the Duck Behaviors
Protection Proxy
about, Using the Java API’s Proxy to create a protection proxy
creating dynamic proxy, Big Picture: creating a Dynamic Proxy for the PersonBean
implementing matchmaking service, The PersonBean implementation
protecting subjects, Five-minute drama: protecting subjects
Proxy Pattern and, What did we do?
testing matchmaking service, Testing the matchmaking service
using dynamic proxy, Using the Java API’s Proxy to create a protection proxy
Prototype Pattern, Prototype
proxies, The Proxy Pattern: Controlling Object Access
Proxy class, identifying class as, Running the code...
Proxy Pattern
Adapter Pattern vs., What did we do?
Complexity Hiding Proxy, The Proxy Zoo
Copy-On-Write Proxy, The Proxy Zoo
Decorator Pattern vs., What did we do?
definition of, The Proxy Pattern defined
dynamic aspect of dynamic proxies, Running the code...
exercise matching description of, Running the code..., So you wanna be a Design Patterns writer, Boy, it’s been great having you in Objectville.
Firewall Proxy, The Proxy Zoo
implementation of Remote Proxy
about, Testing the Monitor
adding to monitoring code, Adding a remote proxy to the Gumball Machine monitoring code
preparing for remote service, Getting the GumballMachine ready to be a remote service
registering with RMI registry, Registering with the RMI registry...
reusing client for, Now for the GumballMonitor client...
reviewing process, And now let’s put the monitor in the hands of the CEO. Hopefully, this time he’ll love it
role of, The role of the ‘remote proxy’
testing, Writing the Monitor test drive
wrapping objects and, What did we do?
java.lang.reflect package, Java RMI, the Big Picture, Using the Java API’s Proxy to create a protection proxy, Creating Invocation Handlers continued...
Protection Proxy and
about, Using the Java API’s Proxy to create a protection proxy
Adapters and, What did we do?
creating dynamic proxy, Big Picture: creating a Dynamic Proxy for the PersonBean
implementing matchmaking service, The PersonBean implementation
protecting subjects, Five-minute drama: protecting subjects
testing matchmaking service, Testing the matchmaking service
using dynamic proxy, Using the Java API’s Proxy to create a protection proxy
Real Subject
as surrogate of, What did we do?
invoking method on, Step one: creating Invocation Handlers
making client use Proxy instead of, What did we do?
passing in constructor, Creating Invocation Handlers continued...
returning proxy for, Step two: creating the Proxy class and instantiating the Proxy object
restrictions on passing types of interfaces, Running the code...
Smart Reference Proxy, The Proxy Zoo
Synchronization Proxy, The Proxy Zoo
variations, What did we do?, The Proxy Zoo
Virtual Proxy
about, Get ready for Virtual Proxy
Caching Proxy as form of, What did we do?, The Proxy Zoo
designing Virtual Proxy, Designing the CD cover Virtual Proxy
reviewing process, What did we do?
testing, Testing the CD Cover Viewer
writing Image Proxy, Writing the Image Proxy
Publish-Subscribe, as Observer Pattern, Publishers + Subscribers = Observer Pattern

Q

queuing requests, using Command Pattern, More uses of the Command Pattern: queuing requests

R

Real Subject
as surrogate of Proxy Pattern, What did we do?
invoking method on, Step one: creating Invocation Handlers
making client use proxy instead of, What did we do?
passing in constructor, Creating Invocation Handlers continued...
returning proxy for, Step two: creating the Proxy class and instantiating the Proxy object
refactoring, What do we need?, You know you need a pattern when...
Related patterns section, in pattern catalog, Looking more closely at the Design Pattern definition
Remote Method Invocation (RMI)
about, Adding a remote proxy to the Gumball Machine monitoring code, Java RMI, the Big Picture
code up close, How does the client get the stub object?
completing code for server side, Java RMI, the Big Picture
importing java.rmi, Getting the GumballMachine ready to be a remote service
importing packages, Getting the GumballMachine ready to be a remote service, Now for the GumballMonitor client...
making remote service, Java RMI, the Big Picture
method call in, Remote methods 101
registering with RMI registry, Registering with the RMI registry...
things to watch out for in, How does the client get the stub object?
Remote proxy
about, Testing the Monitor
adding to monitoring code, Adding a remote proxy to the Gumball Machine monitoring code
preparing for remote service, Getting the GumballMachine ready to be a remote service
registering with RMI registry, Registering with the RMI registry...
reusing client for, Now for the GumballMonitor client...
reviewing process, And now let’s put the monitor in the hands of the CEO. Hopefully, this time he’ll love it
role of, The role of the ‘remote proxy’
testing, Writing the Monitor test drive
wrapping objects and, What did we do?
remove() method
Enumeration and, Dealing with the remove() method
in collection of objects, Making some improvements...
in java.util.Iterator, Iterator Pattern defined
requests, encapsulating, The Command Pattern defined
resources, Design Patterns, Your journey has just begun...
reuse, But something went horribly wrong..., Welcome to Starbuzz Coffee
RMI (Remote Method Invocation)
about, Adding a remote proxy to the Gumball Machine monitoring code, Java RMI, the Big Picture
code up close, How does the client get the stub object?
completing code for server side, Java RMI, the Big Picture
importing java.rmi, Getting the GumballMachine ready to be a remote service
importing packages, Getting the GumballMachine ready to be a remote service, Now for the GumballMonitor client...
making remote service, Java RMI, the Big Picture
method call in, Remote methods 101
registering with RMI registry, Registering with the RMI registry...
things to watch out for in, How does the client get the stub object?
rule of three, applied to Design Patterns, So you wanna be a Design Patterns writer
runtime errors, causes of, Factory Method Pattern defined

S

Sample code section, in pattern catalog, Looking more closely at the Design Pattern definition
server heap, Remote methods 101
service helper (skeletons), in RMI, Java RMI, the Big Picture, Java RMI, the Big Picture, How does the client get the stub object?, And now let’s put the monitor in the hands of the CEO. Hopefully, this time he’ll love it
servlet environment, setting up, Model 2: DJ’ing from a cell phone
shared vocabulary
importance of, Overheard at the local diner...
power of, The power of a shared pattern vocabulary, Don’t forget the power of the shared vocabulary
Sharpen Your Pencil
altering decorator classes, Serving some coffees, Tools for your Design Toolbox
annotating Gumball Machine States, Let’s take a look at what we’ve done so far..., Tools for your Design Toolbox
annotating state diagram, Defining the State interfaces and classes, Tools for your Design Toolbox
building ingredient factory, Building the New York ingredient factory, A very dependent PizzaStore
changing classes for Decorator Pattern, Duck reunion, Exercise Solutions
changing code to fit framework in Iterator Pattern, Taking a look at the Café Menu, Tools for your Design Toolbox
choosing descriptions of state of implementation, The messy STATE of things..., Tools for your Design Toolbox
class diagram for implementation of prepareRecipe(), Abstracting prepareRecipe(), Tools for your Design Toolbox
code not using factories, A very dependent PizzaStore, A very dependent PizzaStore
creating commands for off buttons, Using a macro command, Tools for your Design Toolbox
creating heat index, Power up the Weather Station
determining classes violating Principle of Least Knowledge, Keeping your method calls in bounds..., Tools for your Design Toolbox
drawing beverage order process, Tools for your Design Toolbox
fixing Chocolate Boiler code, Meanwhile, back at the Chocolate Factory..., Tools for your Design Toolbox
identifying factors influencing design, Welcome to Starbuzz Coffee
implementing garage door command, Creating a simple test to use the Remote Control, Tools for your Design Toolbox
implementing state classes, Implementing more states, Tools for your Design Toolbox
making pizza store, Let’s make a PizzaStore, Tools for your Design Toolbox
matching patterns with categories, Organizing Design Patterns, Organizing Design Patterns
method for refilling gumball machine, We almost forgot!, Tools for your Design Toolbox
on adding behaviors, Implementing the Duck Behaviors
on implementation of printmenu(), The Java-Enabled Waitress Specification, Tools for your Design Toolbox
on inheritance, Joe thinks about inheritance..., Tools for your Design Toolbox
sketching out classes, The power of Loose Coupling
things driving change, The one constant in software development, Tools for your Design Toolbox
turning class into Singleton, The Chocolate Factory, Tools for your Design Toolbox
weather station SWAG, Taking a first, misguided SWAG at the Weather Station, Tools for your Design Toolbox
writing Abstract Factory Pattern, Duck reunion, Exercise Solutions
writing classes for adapters, Here’s how the Client uses the Adapter, Tools for your Design Toolbox
writing dynamic proxy, Step two: creating the Proxy class and instantiating the Proxy object, Tools for your Design Toolbox
writing Flock observer code, Duck reunion, Exercise Solutions
writing methods for classes, Welcome to Starbuzz Coffee, Tools for your Design Toolbox
Simple Factory Pattern
about factory objects, Encapsulating object creation
building factory, Building a simple pizza factory
definition of, The Simple Factory defined
Factory Method Pattern and, Factory Method Pattern defined
pattern honorable mention, The Simple Factory defined
using new operator for instantiating concrete classes, The Factory Pattern: Baking with OO Goodness
Single Responsibility Principle, Single Responsibility
Singleton objects, A small Socratic exercise in the style of The Little Lisper, Dissecting the classic Singleton Pattern implementation
Singleton Pattern
about, The Singleton Pattern: One of a Kind Objects
advantages of, The Singleton Pattern: One of a Kind Objects
Chocolate Factory
about, The Chocolate Factory
fixing Chocolate Boiler code, Meanwhile, back at the Chocolate Factory...
class diagram, Singleton Pattern defined
code up close, Dissecting the classic Singleton Pattern implementation
dealing with multithreading, Houston, Hershey, PA we have a problem..., Tools for your Design Toolbox
definition of, Singleton Pattern defined
disadvantages of, Congratulations!
double-checked locking, 3. Use “double-checked locking” to reduce the use of synchronization in getInstance().
exercise matching description of, So you wanna be a Design Patterns writer
global variables vs., Congratulations!
implementing, Dissecting the classic Singleton Pattern implementation
One Class, One Responsibility Principle and, Congratulations!
subclasses in, Congratulations!
using, Congratulations!
skeletons (service helper), in RMI, Java RMI, the Big Picture, Java RMI, the Big Picture, How does the client get the stub object?, And now let’s put the monitor in the hands of the CEO. Hopefully, this time he’ll love it
smart command objects, Using a macro command
Smart Reference Proxy, The Proxy Zoo
sorting methods, in Template Method Pattern, Sorting with Template Method
Starbuzz Coffee Barista training manual project
about, It’s time for some more caffeine
abstracting prepareRecipe(), Abstracting prepareRecipe()
using Template Method Pattern
about, Meet the Template Method
code up close, Template Method Pattern defined
definition of, Template Method Pattern defined
hooks in, Template Method Pattern defined
testing code, Let’s run the Test Drive
The Hollywood Principle and, The Hollywood Principle
Starbuzz Coffee project, using Decorator Pattern
about, Welcome to Starbuzz Coffee
adding sizes to code, Serving some coffees
constructing drink orders, Constructing a drink order with Decorators
decorating beverages in, Decorating our Beverages
drawing beverage order process, New barista training, Tools for your Design Toolbox
testing order code, Serving some coffees
using Java decorators, Real World Decorators: Java I/O
writing code, Writing the Starbuzz code
state machines, State machines 101
State Pattern
definition of, The State Pattern defined
exercise matching description of, We almost forgot!, Tools for your Design Toolbox, So you wanna be a Design Patterns writer, Boy, it’s been great having you in Objectville.
gumball machine controller implementation
about, Jawva Breakers
cleaning up code, Sanity check...
demonstration of, Demo for the CEO of Mighty Gumball, Inc.
diagram to code, State machines 101
finishing, Finishing the game
refilling gumball machine, We almost forgot!
SoldState and WinnerState in, Demo for the CEO of Mighty Gumball, Inc.
testing code, In-house testing
writing code, Writing the code
increasing number of classes in design, The State Pattern defined
modeling state, State machines 101
one in ten contest in gumball machine
about, You knew it was coming... a change request!
annotating state diagram, Defining the State interfaces and classes, Tools for your Design Toolbox
changing code, The messy STATE of things...
drawing state diagram, You knew it was coming... a change request!, Tools for your Design Toolbox
implementing state classes, Implementing our State classes, Implementing more states, We still need to finish the Gumball 1 in 10 game
new design, The new design
reworking state classes, Reworking the Gumball Machine
sharing state objects, The State Pattern defined
state transitions in state classes, The State Pattern defined
Strategy Pattern vs., The State Pattern defined, Sanity check...
state transitions, in state classes, The State Pattern defined
state, using to implement undo commands, Using state to implement Undo
static classes, using instead of Singletons, Congratulations!
static method vs. create method, Building a simple pizza factory
Strategy Pattern
definition of, Speaking of Design Patterns...
exercise matching description of, The Hollywood Principle and Template Method, Tools for your Design Toolbox, The magic of Iterator & Composite together..., Tools for your Design Toolbox, We almost forgot!, Tools for your Design Toolbox, So you wanna be a Design Patterns writer, Boy, it’s been great having you in Objectville.
in Model 2, Strategy
in Model-View-Controller, Looking at MVC through patterns-colored glasses, Now for the Controller, Exploring Strategy
State Pattern vs., The State Pattern defined, Sanity check...
Template Method Pattern and, The making of the sorting duck machine, Applets
structural patterns category, Design Patterns, Pattern Categories, Pattern Categories
Structure section, in pattern catalog, Looking more closely at the Design Pattern definition
stubs (client helper), in RMI, Java RMI, the Big Picture, Java RMI, the Big Picture, How does the client get the stub object?, And now let’s put the monitor in the hands of the CEO. Hopefully, this time he’ll love it
subclasses
class explosion and, Welcome to Starbuzz Coffee
concrete commands and, The Command Pattern defined: the class diagram
concrete states and, The State Pattern defined
Factory Method and, letting subclasses decide which class to instantiate, Factory Method Pattern defined
in Singletons, Congratulations!
inheritance gone wrong and, But something went horribly wrong...
Pizza Store concrete, Allowing the subclasses to decide
Template Method, Meet the Template Method
Subject
in class diagram, The Observer Pattern defined: the class diagram
in Five Minute Drama, Five-minute drama: a subject for observation
in Observer Pattern, Publishers + Subscribers = Observer Pattern
subsystems, Facades and, Lights, Camera, Facade!
superclasses
abstract, Designing the Duck Behaviors
using, But something went horribly wrong...
supertype (programming to interface), vs. programming to interface, Designing the Duck Behaviors
SWAG, Taking a first, misguided SWAG at the Weather Station
Swing
Composite Pattern and, Composite
Observer Pattern in, Other places you’ll find the Observer Pattern in the JDK
Template Method Pattern and, Swingin’ with Frames
Synchronization Proxy, The Proxy Zoo
synchronization, as overhead, Dealing with multithreading

T

Template Method Pattern
about, Meet the Template Method
abstract class in
definition of, Template Method Pattern defined
hooks vs., Let’s run the Test Drive
methods in, Template Method Pattern defined
Applet and, Applets
class diagram, Template Method Pattern defined
code up close, Template Method Pattern defined
definition of, Template Method Pattern defined
exercise matching description of, The Hollywood Principle and Template Method, Tools for your Design Toolbox, We almost forgot!, Tools for your Design Toolbox, So you wanna be a Design Patterns writer, Boy, it’s been great having you in Objectville.
hooks in, Template Method Pattern defined, Let’s run the Test Drive
in real world, Template Methods in the Wild
sorting with, Sorting with Template Method
Strategy Pattern and, The making of the sorting duck machine, Applets
Swing and, Swingin’ with Frames
testing code, Let’s run the Test Drive
The Hollywood Principle and, The Hollywood Principle
The Timeless Way of Building (Alexander), Your journey has just begun...
thinking in patterns, Thinking in Patterns
tightly coupled, The power of Loose Coupling
transparency, in Composite Pattern, Getting ready for a test drive...
tree structure, Composite Pattern, The Composite Pattern defined, Getting ready for a test drive...
try/catch, not supporting method, The magic of Iterator & Composite together...
Two Way Adapters, creating, Here’s how the Client uses the Adapter
type safe parameters, Factory Method Pattern defined

U

undo commands
creating, Time to write that documentation...
creating multiple, Using a macro command
implementing for macro command, Using a macro command
support of, Time to write that documentation...
testing, Time to QA that Undo button!, Get ready to test the ceiling fan
using state to implement, Using state to implement Undo
User Interface Design Patterns, The Patterns Zoo

V

variables
declaring behavior, Integrating the Duck Behavior
holding reference to concrete class, A few guidelines to help you follow the Principle...
Vector, Iterators and Collections
vegetarian menu, using Composite Pattern, Give me the vegetarian menu
Virtual Proxy
about, Get ready for Virtual Proxy
Caching Proxy as form of, What did we do?, The Proxy Zoo
designing Virtual Proxy, Designing the CD cover Virtual Proxy
reviewing process, What did we do?
testing, Testing the CD Cover Viewer
writing Image Proxy, Writing the Image Proxy
Visitor Pattern, Visitor
Vlissides, John, Cruisin’ Objectville with the Gang of Four
volatile keyword, 3. Use “double-checked locking” to reduce the use of synchronization in getInstance().

W

weather station
building display elements, Now, let’s build those display elements
designing, Designing the Weather Station
implementing, Implementing the Weather Station
powering up, Power up the Weather Station
SWAG, Taking a first, misguided SWAG at the Weather Station
unpacking classes, Unpacking the WeatherData class
using built-in Java Observer Pattern, Reworking the Weather Station with the built-in support
web, Model-View-Controller and, MVC and the Web
Who Does What exercises
matching objects and methods to Command Pattern, From the Diner to the Command Pattern, Tools for your Design Toolbox
matching pattern with description, The Hollywood Principle and Template Method, Tools for your Design Toolbox, The magic of Iterator & Composite together..., Tools for your Design Toolbox, We almost forgot!, Tools for your Design Toolbox, Running the code..., Tools for your Design Toolbox, So you wanna be a Design Patterns writer, Boy, it’s been great having you in Objectville.
matching patterns with its intent, Tools for your Design Toolbox
whole-part relationships, collection of objects using, The magic of Iterator & Composite together...
wickedlysmart web site, Read Me
wrapping objects, Meet the Decorator Pattern, Here’s how the Client uses the Adapter, Writing the EnumerationIterator adapter, Lights, Camera, Facade!, What did we do?, Duck reunion

Y

your mind on patterns, Your Mind on Patterns
..................Content has been hidden....................

You can't read the all page of ebook, please click here login for view all page.
Reset
18.118.227.69