Design Patterns in Java™ - Steven John Metsker, William C. Wake

Design Patterns in Java™

Buch | Hardcover
480 Seiten
2006 | 2nd edition
Addison-Wesley Educational Publishers Inc (Verlag)
978-0-321-33302-5 (ISBN)
51,25 inkl. MwSt
  • Titel ist leider vergriffen;
    keine Neuauflage
  • Artikel merken
Gives you the hands-on practice and insight you need to leverage the significant power of design patterns in any Java software project. Drawing on their extensive experience as Java instructors and programmers, the authors illuminate each pattern with Java programs, UML diagrams, and exercises.
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.

Steven John Metsker, passed away in 2008 and was a Managing Consultant with Dominion Digital, an information technology and business process reengineering company. Steve specialized 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 xiiiChapter 1 Introduction 1Why 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

Part I Interface Patterns 9Chapter 2 Introducing Interfaces 11Interfaces and Abstract Classes 11

Interfaces and Obligations 13

Summary 15

Beyond Ordinary Interfaces 16

Chapter 3 Adapter 17Adapting to an Interface 17

Class and Object Adapters 21

Adapting Data for a JTable 25

Identifying Adapters 30

Summary 31

Chapter 4 Facade 33Facades, Utilities, and Demos 33

Refactoring to Facade 35

Summary 46

Chapter 5 Composite 47An 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 63An 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 73Chapter 7 Introducing Responsibility 75Ordinary Responsibility 75

Controlling Responsibility with Visibility 77

Summary 79

Beyond Ordinary Responsibility 79

Chapter 8 Singleton 81Singleton Mechanics 81

Singletons and Thread 83

Recognizing Singleton 84

Summary 86

Chapter 9 Observer 87A Classic Example: Observer in GUIs 87

Model/View/Controller 92

Maintaining an Observable Object 99

Summary 101

Chapter 10 Mediator 103A Classic Example: GUI Mediators 103

Mediators of Relational Integrity 108

Summary 116

Chapter 11 Proxy 117A Classic Example: Image Proxies 117

Image Proxies Reconsidered 122

Remote Proxies 125

Dynamic Proxies 131

Summary 136

Chapter 12 Chain of Responsibility 137An 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 145Immutability 145

Extracting the Immutable Part of a Flyweight 146

Sharing Flyweights 148

Summary 152

Part III Construction Patterns 153Chapter 14 Introducing Construction 155A Few Construction Challenges 155

Summary 157

Beyond Ordinary Construction 157

Chapter 15 Builder 159An Ordinary Builder 159

Building under Constraints 162

A Forgiving Builder 164

Summary 165

Chapter 16 Factory Method 167A 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 175A Classic Example: GUI Kits 175

Abstract Factories and Factory Method 180

Packages and Abstract Factories 184

Summary 185

Chapter 18 Prototype 187Prototypes as Factories 187

Prototyping with Clones 189

Summary 192

Chapter 19 Memento 193A Classic Example: Using Memento for Undo 193

Memento Durability 201

Persisting Mementos Across Sessions 201

Summary 205

Part IV Operation Patterns 207Chapter 20 Introducing Operations 209Operations and Methods 209

Signatures 211

Exceptions 212

Algorithms and Polymorphism 213

Summary 214

Beyond Ordinary Operations 215

Chapter 21 Template Method 217A Classic Example: Sorting 217

Completing an Algorithm 221

Template Method Hooks 224

Refactoring to Template Method 225

Summary 228

Chapter 22 State 229Modeling States 229

Refactoring to State 233

Making States Constant 238

Summary 240

Chapter 23 Strategy 241Modeling Strategies 241

Refactoring to Strategy 244

Comparing Strategy and State 248

Comparing Strategy and Template Method 249

Summary 250

Chapter 24 Command 251A 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 261An Interpreter Example 261

Interpreters, Languages, and Parsers 274

Summary 275

Part V Extension Patterns 277Chapter 26 Introducing Extensions 279Principles 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 287A Classic Example: Streams and Writers 287

Function Wrappers 295

Decorator in Relation to Other Patterns 303

Summary 303

Chapter 28 Iterator 305Ordinary Iteration 305

Thread-Safe Iteration 307

Iterating over a Composite 313

Summary 324

Chapter 29 Visitor 325Visitor Mechanics 325

An Ordinary Visitor 327

Visitor Cycles 333

Visitor Risks 338

Summary 340

Part VI Appendixes 341Appendix A Directions 343Get the Most from This Book 343

Understand the Classics 344

Weave Patterns into Your Code 344

Keep Learning 345

Appendix B Solutions 347Appendix C Oozinoz Source 427Acquiring 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 431Classes 432

Class Relationships 433

Interfaces 435

Objects 436

States 437

Glossary 439Bibliography 447Index 449

Erscheint lt. Verlag 27.4.2006
Reihe/Serie Software Patterns Series
Verlagsort New Jersey
Sprache englisch
Maße 239 x 190 mm
Gewicht 884 g
Themenwelt Informatik Programmiersprachen / -werkzeuge Java
Mathematik / Informatik Informatik Web / Internet
ISBN-10 0-321-33302-0 / 0321333020
ISBN-13 978-0-321-33302-5 / 9780321333025
Zustand Neuware
Haben Sie eine Frage zum Produkt?
Mehr entdecken
aus dem Bereich
mit über 150 Workouts in Java und Python

von Luigi Lo Iacono; Stephan Wiefling; Michael Schneider

Buch (2023)
Carl Hanser (Verlag)
29,99
Einführung, Ausbildung, Praxis

von Christian Ullenboom

Buch | Hardcover (2023)
Rheinwerk (Verlag)
49,90