9780321333025

Design Patterns in Java#x2122; 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#x2014;learning how to improve new code and refactor existing code for simplicity, manageability, and performance. Coverage includes bull; bull;Using Adapter to provide consistent interfaces to clients bull; bull;Using Facade to simplify the use of reusable toolkits bull; bull;Understanding the role of Bridge in Java database connectivity bull; bull;The Observer pattern, Model-View-Controller, and GUI behavior bull; bull;Java Remote Method Invocation (RMI) and the Proxy pattern bull; bull;Streamlining designs using the Chain of Responsibility pattern bull; bull;Using patterns to go beyond Java's built-in constructor features bull; bull;Implementing Undo capabilities with Memento bull; bull;Using the State pattern to manage state more cleanly and simply bull; bull;Optimizing existing codebases with extension patterns bull; bull;Providing thread-safe iteration with the Iterator pattern bull; bull;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 .

Steven John Metsker is a Managing Consultant with Dominion Digital, an information technology and business process reengineering company. Steve specializes in object-oriented techniques for creating clean, powerful software, and he is the author of Building Parsers with Java™, Design Patterns Java™ Workbook, and Design Patterns in C# (all from Addison-Wesley).

William C. Wake, http://www.xp123.com , is an independent software consultant, coach, and trainer with more than twenty years of programming experience. Bill previously held positions with Capital One Financial, DMR Trecom, and VTLS, Inc. He is the author of the Refactoring Workbook and Extreme Programming Explored (both from Addison-Wesley).

Preface

xiii

Introduction

1

(8)

Why Patterns?

1

(1)

Why Design Patterns?

2

(1)

Why Java?

3

(1)

UML

4

(1)

Challenges

4

(1)

The Organization of This Book

5

(1)

Welcome to Oozinoz!

6

(1)

Summary

7

(2)

PART I INTERFACE PATTERNS

9

(64)

Introducing Interfaces

11

(6)

Interfaces and Abstract Classes

11

(2)

Interfaces and Obligations

13

(2)

Summary

15

(1)

Beyond Ordinary Interfaces

16

(1)

Adapter

17

(16)

Adapting to an Interface

17

(4)

Class and Object Adapters

21

(4)

Adapting Data for a JTable

25

(5)

Identifying Adapters

30

(1)

Summary

31

(2)

Facade

33

(14)

Facades, Utilities, and Demos

33

(2)

Refactoring to Facade

35

(11)

Summary

46

(1)

Composite

47

(16)

An Ordinary Composite

47

(1)

Recursive Behavior in Composites

48

(2)

Composites, Trees, and Cycles

50

(6)

Composites with Cycles

56

(4)

Consequences of Cycles

60

(1)

Summary

60

(3)

Bridge

63

(10)

An Ordinary Abstraction: On the Way to Bridge

63

(3)

From Abstraction to Bridge

66

(2)

Drivers as Bridges

68

(1)

Database Drivers

69

(2)

Summary

71

(2)

PART II RESPONSIBILITY PATTERNS

73

(80)

Introducing Responsibility

75

(6)

Ordinary Responsibility

75

(2)

Controlling Responsibility with Visibility

77

(2)

Summary

79

(1)

Beyond Ordinary Responsibility

79

(2)

Singleton

81

(6)

Singleton Mechanics

81

(2)

Singletons and Threads

83

(1)

Recognizing Singleton

84

(2)

Summary

86

(1)

Observer

87

(16)

A Classic Example: Observer in GUIs

87

(5)

Model/View/Controller

92

(7)

Maintaining an Observable Object

99

(2)

Summary

101

(2)

Mediator

103

(14)

A Classic Example: GUI Mediators

103

(5)

Mediators of Relational Integrity

108

(8)

Summary

116

(1)

Proxy

117

(20)

A Classic Example: Image Proxies

117

(5)

Image Proxies Reconsidered

122

(3)

Remote Proxies

125

(6)

Dynamic Proxies

131

(5)

Summary

136

(1)

Chain of Responsibility

137

(8)

An Ordinary Chain of Responsibility

137

(2)

Refactoring to Chain of Responsibility

139

(3)

Anchoring a Chain

142

(2)

Chain of Responsibility without Composite

144

(1)

Summary

144

(1)

Flyweight

145

(8)

Immutability

145

(1)

Extracting the Immutable Part of a Flyweight

146

(2)

Sharing Flyweights

148

(4)

Summary

152

(1)

PART III CONSTRUCTION PATTERNS

153

(54)

Introducing Construction

155

(4)

A Few Construction Challenges

155

(2)

Summary

157

(1)

Beyond Ordinary Construction

157

(2)

Builder

159

(8)

An Ordinary Builder

159

(3)

Building under Constraints

162

(2)

A Forgiving Builder

164

(1)

Summary

165

(2)

Factory Method

167

(8)

A Classic Example: Iterators

167

(1)

Recognizing Factory Method

168

(1)

Taking Control of Which Class to Instantiate

169

(2)

Factory Method in Parallel Hierarchies

171

(2)

Summary

173

(2)

Abstract Factory

175

(12)

A Classic Example: GUI Kits

175

(5)

Abstract Factories and Factory Method

180

(4)

Packages and Abstract Factories

184

(1)

Summary

185

(2)

Prototype

187

(6)

Prototypes as Factories

187

(2)

Prototyping with Clones

189

(3)

Summary

192

(1)

Memento

193

(14)

A Classic Example: Using Memento for Undo

193

(8)

Memento Durability

201

(1)

Persisting Mementos Across Sessions

201

(4)

Summary

205

(2)

PART IV OPERATION PATTERNS

207

(70)

Introducing Operations

209

(8)

Operations and Methods

209

(2)

Signatures

211

(1)

Exceptions

212

(1)

Algorithms and Polymorphism

213

(1)

Summary

214

(1)

Beyond Ordinary Operations

215

(2)

Template Method

217

(12)

A Classic Example: Sorting

217

(4)

Completing an Algorithm

221

(3)

Template Method Hooks

224

(1)

Refactoring to Template Method

225

(3)

Summary

228

(1)

State

229

(12)

Modeling States

229

(4)

Refactoring to State

233

(5)

Making States Constant

238

(2)

Summary

240

(1)

Strategy

241

(10)

Modeling Strategies

241

(3)

Refactoring to Strategy

244

(4)

Comparing Strategy and State

248

(1)

Comparing Strategy and Template Method

249

(1)

Summary

250

(1)

Command

251

(10)

A Classic Example: Menu Commands

251

(3)

Using Command to Supply a Service

254

(1)

Command Hooks

255

(2)

Command in Relation to Other Patterns

257

(2)

Summary

259

(2)

Interpreter

261

(16)

An Interpreter Example

261

(13)

Interpreters, Languages, and Parsers

274

(1)

Summary

275

(2)

PART V EXTENSION PATTERNS

277

(64)

Introducing Extensions

279

(8)

Principles of Object-Oriented Design

279

(1)

The Liskov Substitution Principle

280

(1)

The Law of Demeter

281

(2)

Removing Code Smells

283

(1)

Beyond Ordinary Extensions

283

(2)

Summary

285

(2)

Decorator

287

(18)

A Classic Example: Streams and Writers

287

(8)

Function Wrappers

295

(8)

Decorator in Relation to Other Patterns

303

(1)

Summary

303

(2)

Iterator

305

(20)

Ordinary Iteration

305

(2)

Thread-Safe Iteration

307

(6)

Iterating over a Composite

313

(11)

Summary

324

(1)

Visitor

325

(16)

Visitor Mechanics

325

(2)

An Ordinary Visitor

327

(6)

Visitor Cycles

333

(5)

Visitor Risks

338

(2)

Summary

340

(1)

PART VI APPENDIXES

341

(98)

Appendix A Directions

343

(4)

Get the Most from This Book

343

(1)

Understand the Classics

344

(1)

Weave Patterns into Your Code

344

(1)

Keep Learning

345

(2)

Appendix B Solutions

347

(80)

Appendix C Oozinoz Source

427

(4)

Acquiring and Using the Source

427

(1)

Building the Oozinoz Code

427

(1)

Testing the Code with JUnit

428

(1)

Finding Files Yourself

428

(1)

Summary

429

(2)

Appendix D UML at a Glance

431

(8)

Classes

432

(1)

Class Relationships

433

(2)

Interfaces

435

(1)

Objects

436

(1)

States

437

(2)

Glossary

439

(8)

Bibliography

447

(2)

Index

449

What is included with this book?

The New copy of this book will include any supplemental materials advertised. Please check the title of the book to determine if it should include any access cards, study guides, lab manuals, CDs, etc.

The Used, Rental and eBook copies of this book are not guaranteed to include any supplemental materials. Typically, only the book itself is included. This is true even if the title states it includes any access cards, study guides, lab manuals, CDs, etc.

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#x2122;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 UpdateThis book merges and updates two previous books:Design Patterns Java Workbook#x2122; andDesign 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.

Amazon no longer offers textbook rentals. We do!

Design Patterns in Java¿

Design Patterns in Java¿

0321333020

Summary

Author Biography

Table of Contents

Supplemental Materials

Excerpts