Home > Store

Design Patterns in Java, 2nd Edition

Register your product to gain access to bonus material or receive a coupon.

Design Patterns in Java, 2nd Edition


  • Sorry, this book is no longer in print.
Not for Sale

eBook (Watermarked)

  • Your Price: $41.59
  • List Price: $51.99
  • Includes EPUB, MOBI, and PDF
  • About eBook Formats
  • This eBook includes the following formats, accessible from your Account page after purchase:

    ePub EPUB The open industry format known for its reflowable content and usability on supported mobile devices.

    MOBI MOBI The eBook format compatible with the Amazon Kindle and Amazon Kindle applications.

    Adobe Reader PDF The popular standard, used most often with the free Adobe® Reader® software.

    This eBook requires no passwords or activation to read. We customize your eBook by discreetly watermarking it with your name, making it uniquely yours.


  • Copyright 2006
  • Dimensions: 7" x 9-1/4"
  • Edition: 2nd
  • Book
  • ISBN-10: 0-321-33302-0
  • ISBN-13: 978-0-321-33302-5

Design Patterns in Java™ gives you the hands-on practice and deep insight you need to fully leverage the significant power of design patterns in any Java software project. The perfect complement to the classic Design Patterns, this learn-by-doing workbook applies the latest Java features and best practices to all of the original 23 patterns identified in that groundbreaking text.

Drawing on their extensive experience as Java instructors and programmers, Steve Metsker and Bill Wake illuminate each pattern with real Java programs, clear UML diagrams, and compelling exercises. You'll move quickly from theory to application—learning how to improve new code and refactor existing code for simplicity, manageability, and performance.

Coverage includes

  • Using Adapter to provide consistent interfaces to clients
  • Using Facade to simplify the use of reusable toolkits
  • Understanding the role of Bridge in Java database connectivity
  • The Observer pattern, Model-View-Controller, and GUI behavior
  • Java Remote Method Invocation (RMI) and the Proxy pattern
  • Streamlining designs using the Chain of Responsibility pattern
  • Using patterns to go beyond Java's built-in constructor features
  • Implementing Undo capabilities with Memento
  • Using the State pattern to manage state more cleanly and simply
  • Optimizing existing codebases with extension patterns
  • Providing thread-safe iteration with the Iterator pattern
  • Using Visitor to define new operations without changing hierarchy classes

If you're a Java programmer wanting to save time while writing better code, this book's techniques, tips, and clear explanations and examples will help you harness the power of patterns to improve every program you write, design, or maintain.

All source code is available for download at http://www.oozinoz.com.

Sample Content

Online Sample Chapters

Design Patterns in Java: Adapter

Design Patterns in Java: Memento

Design Patterns in Java: Proxy

Downloadable Sample Chapter

Download the Sample Chapter related to this title.

Table of Contents

Preface xiii

Chapter 1 Introduction 1

Why Patterns? 1

Why Design Patterns? 2

Why Java? 3


Challenges 4

The Organization of This Book 5

Welcome to Oozinoz! 6

Summary 7

Part I Interface Patterns 9

Chapter 2 Introducing Interfaces 11

Interfaces and Abstract Classes 11

Interfaces and Obligations 13

Summary 15

Beyond Ordinary Interfaces 16

Chapter 3 Adapter 17

Adapting to an Interface 17

Class and Object Adapters 21

Adapting Data for a JTable 25

Identifying Adapters 30

Summary 31

Chapter 4 Facade 33

Facades, Utilities, and Demos 33

Refactoring to Facade 35

Summary 46

Chapter 5 Composite 47

An Ordinary Composite 47

Recursive Behavior in Composites 48

Composites, Trees, and Cycles 50

Composites with Cycles 56

Consequences of Cycles 60

Summary 60

Chapter 6 Bridge 63

An Ordinary Abstraction: On the Way to Bridge 63

From Abstraction to Bridge 66

Drivers as Bridges 68

Database Drivers 69

Summary 71

Part II Responsibility Patterns 73

Chapter 7 Introducing Responsibility 75

Ordinary Responsibility 75

Controlling Responsibility with Visibility 77

Summary 79

Beyond Ordinary Responsibility 79

Chapter 8 Singleton 81

Singleton Mechanics 81

Singletons and Thread 83

Recognizing Singleton 84

Summary 86

Chapter 9 Observer 87

A Classic Example: Observer in GUIs 87

Model/View/Controller 92

Maintaining an Observable Object 99

Summary 101

Chapter 10 Mediator 103

A Classic Example: GUI Mediators 103

Mediators of Relational Integrity 108

Summary 116

Chapter 11 Proxy 117

A Classic Example: Image Proxies 117

Image Proxies Reconsidered 122

Remote Proxies 125

Dynamic Proxies 131

Summary 136

Chapter 12 Chain of Responsibility 137

An Ordinary Chain of Responsibility 137

Refactoring to Chain of Responsibility 139

Anchoring a Chain 142

Chain of Responsibility without Composite 144

Summary 144

Chapter 13 Flyweight 145

Immutability 145

Extracting the Immutable Part of a Flyweight 146

Sharing Flyweights 148

Summary 152

Part III Construction Patterns 153

Chapter 14 Introducing Construction 155

A Few Construction Challenges 155

Summary 157

Beyond Ordinary Construction 157

Chapter 15 Builder 159

An Ordinary Builder 159

Building under Constraints 162

A Forgiving Builder 164

Summary 165

Chapter 16 Factory Method 167

A Classic Example: Iterators 167

Recognizing Factory Method 168

Taking Control of Which Class to Instantiate 169

Factory Method in Parallel Hierarchies 171

Summary 173

Chapter 17 Abstract Factory 175

A Classic Example: GUI Kits 175

Abstract Factories and Factory Method 180

Packages and Abstract Factories 184

Summary 185

Chapter 18 Prototype 187

Prototypes as Factories 187

Prototyping with Clones 189

Summary 192

Chapter 19 Memento 193

A Classic Example: Using Memento for Undo 193

Memento Durability 201

Persisting Mementos Across Sessions 201

Summary 205

Part IV Operation Patterns 207

Chapter 20 Introducing Operations 209

Operations and Methods 209

Signatures 211

Exceptions 212

Algorithms and Polymorphism 213

Summary 214

Beyond Ordinary Operations 215

Chapter 21 Template Method 217

A Classic Example: Sorting 217

Completing an Algorithm 221

Template Method Hooks 224

Refactoring to Template Method 225

Summary 228

Chapter 22 State 229

Modeling States 229

Refactoring to State 233

Making States Constant 238

Summary 240

Chapter 23 Strategy 241

Modeling Strategies 241

Refactoring to Strategy 244

Comparing Strategy and State 248

Comparing Strategy and Template Method 249

Summary 250

Chapter 24 Command 251

A Classic Example: Menu Commands 251

Using Command to Supply a Service 254

Command Hooks 255

Command in Relation to Other Patterns 257

Summary 259

Chapter 25 Interpreter 261

An Interpreter Example 261

Interpreters, Languages, and Parsers 274

Summary 275

Part V Extension Patterns 277

Chapter 26 Introducing Extensions 279

Principles of Object-Oriented Design 279

The Liskov Substitution Principle 280

The Law of Demeter 281

Removing Code Smells 283

Beyond Ordinary Extensions 283

Summary 285

Chapter 27 Decorator 287

A Classic Example: Streams and Writers 287

Function Wrappers 295

Decorator in Relation to Other Patterns 303

Summary 303

Chapter 28 Iterator 305

Ordinary Iteration 305

Thread-Safe Iteration 307

Iterating over a Composite 313

Summary 324

Chapter 29 Visitor 325

Visitor Mechanics 325

An Ordinary Visitor 327

Visitor Cycles 333

Visitor Risks 338

Summary 340

Part VI Appendixes 341

Appendix A Directions 343

Get the Most from This Book 343

Understand the Classics 344

Weave Patterns into Your Code 344

Keep Learning 345

Appendix B Solutions 347

Appendix C Oozinoz Source 427

Acquiring and Using the Source 427

Building the Oozinoz Code 427

Testing the Code with JUnit 428

Finding Files Yourself 428

Summary 429

Appendix D UML at a Glance 431

Classes 432

Class Relationships 433

Interfaces 435

Objects 436

States 437

Glossary 439

Bibliography 447

Index 449


Design patterns are class- and method-level solutions to common problems in object-oriented design. If you're an intermediate-level Java programmer who wants to become advanced or an advanced-level Java programmer who hasn't yet studied design patterns, this book is for you. Design Patterns in Java™ takes a workbook approach. Each chapter focuses on a particular pattern. In addition to explaining the pattern, the chapter includes a number of challenges, each asking you to explain something or to develop code that solves a problem.

We strongly urge you to stop and work through the challenges rather than try to read this book straight through. You'll learn more by putting in the work to do the challenges, even if it's only a chapter or two a week. An Update

This book merges and updates two previous books: Design Patterns Java Workbook and Design Patterns in C#. This book combines the Java orientation of the former with the more stand-alone approach of the latter. If you've already worked through the previous books, you won't need this one.


Download the Index file related to this title.


Submit Errata

More Information

Unlimited one-month access with your purchase
Free Safari Membership