Preface
Why We Wrote This Book
During the many Java programming language courses we teach, we have found that
only a few programmers know what design patterns are when asked. About one in
ten is able to name a few patterns off the top of his or her head. Of course,
the concepts behind the patterns are familiar to many programmers. When we
demonstrate patterns in the classroom, developers know and recognize
them.
We decided to create a pattern catalog for the Java programming language
developers who understand at a basic level why patterns are a good idea, and are
interested in applying them, but want a practical, hands-on guide to just how
and why to use each individual pattern. We've kept the book casual and
frank in tone, and included full working Java code examples for each.
We will have succeeded when you complete this book having not only learned about
design patterns and the Java programming language, but having had fun reading
it, as well.
What This Book Is About
This book will teach you the essential design patterns and how you can use them
in your Java application. Furthermore, this book will show you where patterns
are used in Java technology APIs and why they were used.
Who Should Read This Book
This book is intended for experienced Java programmers who want to build better
applications. You should be comfortable with the Java programming language and
be familiar with most of the basic Java APIs. Some knowledge of UML is useful,
but not required. We recommend UML Distilled by Martin Fowler as a UML
reference.
How This Book Is Organized
This book is divided into two parts. Part I,"Commonly Used Patterns," is
organized like a pattern catalogue, reference-style.
Chapter 1: "Creational Patterns" on page 3 discusses patterns that create
objects: Abstract Factory, Builder, Factory Method, Prototype, and
Singleton.
Chapter 2: "Behavioral Patterns" on page 39 is focussed on the patterns that can
determine the behavior of your object model: Chain of Responsibility, Command,
Interpreter, Iterator, Mediator, Memento, Observer, State, Strategy, Template
Method, and Visitor.
Chapter 3: "Structural Patterns" on page 139 describes patterns that can bring
structure to your application and has the following patterns: Adapter, Bridge,
Composite, Decorator, Facade, Flyweight, HOPP, and Proxy.
Chapter 4: "System Patterns" on page 205 describes the patterns that help you
build better architectures: Callback, Router, MVC, Session, Successive Update,
Transaction, and Worker Thread.
Part II, "Patterns in the Java Programming Language," presents many of the Java
APIs and shows the use of patterns in those API and their benefit.
Chapter 6: "Java Core APIs" on page 279 provides an overview in the familiar
core APIs like Event Handling, JavaBeans[tm], AWT and Swing, Collections,
Input/Output, and Reflection.
Chapter 7: "Distributed Technologies" on page 303 describes selected distributed
APIs and how patterns are used: JNDI, JDBC, RMI, and CORBA.
Chapter 8: "Jini and J2EE Architectures" on page 317 focuses on the two
complementary frameworks Jini and J2EE. J2EE is further divided into Servlets,
JSP and EJB technologies.
How to Use This Book
There are several ways to read this book. You could start at page one and read
from cover to cover. However, we recommend you start with some of the easier
patterns: Factory Method, Singleton, Observer, and Composite. Work your way
through the book using those as starting points for your exploration.
Alternatively, you might want to turn to sections in Part II first. Find an API
you are familiar with and start looking for patterns there.
You can read the patterns in any order you feel most comfortable with. Later,
you can use this book as a reference to refresh your memory when you want to put
your knowledge of patterns into practice.
Companion Web Site
This book has a companion Web site to provide you with updates and other
material: it is located at http://www.phptr.com/appliedjava
patterns
