Register your product to gain access to bonus material or receive a coupon.
This eBook includes the following formats, accessible from your Account page after purchase:
EPUB The open industry format known for its reflowable content and usability on supported mobile devices.
PDF The popular standard, used most often with the free Acrobat® 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.
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
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.
Design Pattern Variations: A Better Visitor
Design Patterns in Java: The Observer
Java Patterns for MPLS Network Management, Part 1
Java Patterns for MPLS Network Management, Part 2
Visit the Author's Web Site
Design Patterns in Java: Adapter
Design Patterns in Java: Memento
Design Patterns in Java: Proxy
Download the Sample Chapter related to this title.
Why Patterns? 1
Why Design Patterns? 2
Why Java? 3
UML 4
Challenges 4
The Organization of This Book 5
Welcome to Oozinoz! 6
Summary 7
Interfaces and Abstract Classes 11
Interfaces and Obligations 13
Summary 15
Beyond Ordinary Interfaces 16
Adapting to an Interface 17
Class and Object Adapters 21
Adapting Data for a JTable 25
Identifying Adapters 30
Summary 31
Facades, Utilities, and Demos 33
Refactoring to Facade 35
Summary 46
An Ordinary Composite 47
Recursive Behavior in Composites 48
Composites, Trees, and Cycles 50
Composites with Cycles 56
Consequences of Cycles 60
Summary 60
An Ordinary Abstraction: On the Way to Bridge 63
From Abstraction to Bridge 66
Drivers as Bridges 68
Database Drivers 69
Summary 71
Ordinary Responsibility 75
Controlling Responsibility with Visibility 77
Summary 79
Beyond Ordinary Responsibility 79
Singleton Mechanics 81
Singletons and Thread 83
Recognizing Singleton 84
Summary 86
A Classic Example: Observer in GUIs 87
Model/View/Controller 92
Maintaining an Observable Object 99
Summary 101
A Classic Example: GUI Mediators 103
Mediators of Relational Integrity 108
Summary 116
A Classic Example: Image Proxies 117
Image Proxies Reconsidered 122
Remote Proxies 125
Dynamic Proxies 131
Summary 136
An Ordinary Chain of Responsibility 137
Refactoring to Chain of Responsibility 139
Anchoring a Chain 142
Chain of Responsibility without Composite 144
Summary 144
Immutability 145
Extracting the Immutable Part of a Flyweight 146
Sharing Flyweights 148
Summary 152
A Few Construction Challenges 155
Summary 157
Beyond Ordinary Construction 157
An Ordinary Builder 159
Building under Constraints 162
A Forgiving Builder 164
Summary 165
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
A Classic Example: GUI Kits 175
Abstract Factories and Factory Method 180
Packages and Abstract Factories 184
Summary 185
Prototypes as Factories 187
Prototyping with Clones 189
Summary 192
A Classic Example: Using Memento for Undo 193
Memento Durability 201
Persisting Mementos Across Sessions 201
Summary 205
Operations and Methods 209
Signatures 211
Exceptions 212
Algorithms and Polymorphism 213
Summary 214
Beyond Ordinary Operations 215
A Classic Example: Sorting 217
Completing an Algorithm 221
Template Method Hooks 224
Refactoring to Template Method 225
Summary 228
Modeling States 229
Refactoring to State 233
Making States Constant 238
Summary 240
Modeling Strategies 241
Refactoring to Strategy 244
Comparing Strategy and State 248
Comparing Strategy and Template Method 249
Summary 250
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
An Interpreter Example 261
Interpreters, Languages, and Parsers 274
Summary 275
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
A Classic Example: Streams and Writers 287
Function Wrappers 295
Decorator in Relation to Other Patterns 303
Summary 303
Ordinary Iteration 305
Thread-Safe Iteration 307
Iterating over a Composite 313
Summary 324
Visitor Mechanics 325
An Ordinary Visitor 327
Visitor Cycles 333
Visitor Risks 338
Summary 340
Get the Most from This Book 343
Understand the Classics 344
Weave Patterns into Your Code 344
Keep Learning 345
Acquiring and Using the Source 427
Building the Oozinoz Code 427
Testing the Code with JUnit 428
Finding Files Yourself 428
Summary 429
Classes 432
Class Relationships 433
Interfaces 435
Objects 436
States 437
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.