- Hardcover: 480 pages
- Publisher: Addison-Wesley Professional; 2 edition (April 28, 2006)
- Language: English
- ISBN-10: 0321333020
- ISBN-13: 978-0321333025
- Product Dimensions: 7.2 x 1.1 x 9.3 inches
- Shipping Weight: 2.1 pounds (View shipping rates and policies)
- Average Customer Review: 14 customer reviews
- Amazon Best Sellers Rank: #1,250,601 in Books (See Top 100 in Books)
Enter your mobile number or email address below and we'll send you a link to download the free Kindle App. Then you can start reading Kindle books on your smartphone, tablet, or computer - no Kindle device required.
To get the free app, enter your mobile phone number.
Design Patterns in Java(TM) (Software Patterns Series) 2nd Edition
Use the Amazon App to scan ISBNs and compare prices.
Fulfillment by Amazon (FBA) is a service we offer sellers that lets them store their products in Amazon's fulfillment centers, and we directly pack, ship, and provide customer service for these products. Something we hope you'll especially enjoy: FBA items qualify for FREE Shipping and Amazon Prime.
If you're a seller, Fulfillment by Amazon can help you increase your sales. We invite you to learn more about Fulfillment by Amazon .
"Enlightenment Now: The Case for Reason, Science, Humanism, and Progress"
Is the world really falling apart? Is the ideal of progress obsolete? Cognitive scientist and public intellectual Steven Pinker urges us to step back from the gory headlines and prophecies of doom, and instead, follow the data: In seventy-five jaw-dropping graphs, Pinker shows that life, health, prosperity, safety, peace, knowledge, and happiness are on the rise. Learn more
Frequently bought together
Customers who bought this item also bought
Customers who viewed this item also viewed
From the Back Cover
"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 includesUsing Adapter to provide consistent interfaces to clients Using Facade to simplify the use of reusable toolkits Understanding the role of Bridge in Java database connectivityThe Observer pattern, Model-View-Controller, and GUI behaviorJava Remote Method Invocation (RMI) and the Proxy patternStreamlining designs using the Chain of Responsibility patternUsing 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 simplyOptimizing existing codebases with extension patternsProviding thread-safe iteration with the Iterator patternUsing 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.
About the Author
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).
Top customer reviews
There was a problem filtering reviews right now. Please try again later.
I would not recommend this.
An earlier reviewer commented that the format/structure is a problem - I also found it annoying. I dislike authors that play pantomime with complex topics like this. Further, when my mind is in computer mode the often used sentences in this book like "if you want to ..." confuse my subconscious learning brain. This is because I may not "want" but may "need" - and I need to figure out why/if/when I may want this thing. I feel that this indicates that the authors are not confident in concisely explicating a complex topic.
Some things grate, for example the Singleton Pattern is classified differently (Responsibility Pattern) here to the GoF book (Creational Pattern). I don't see the communicational point in messing with the acknowledged but the perhaps disputed GoF masters (Design Patterns) and their accepted wisdom.
Technically this book does not appear complete. In discussing thread safety for the Singleton the book provides a synchronized example but not a "double-checked locking" example as does Head First Design Patterns (Head First). The double-check reduces the use of synchronization in a frequently accessed singleton and speeds things up dramatically. Omissions like this don't inspire confidence.
The book feels light in Java code examples. It is not a clear Java focussed exposition on patterns. It does not provided comprehensive Java examples on common patterns to insert in production (where I am personally at now). It seems a missed opportunity because I wished so much.
I was hoping to outgrow my Head First(HF) experience, but this book does not do that. I would recommend the HF book over this one - even if you are annoyed by the HF style. HF seems to have been more thought out.
This book added little to the GoF and HF books I have read.
This book maybe useful for Java programmers who have not been exposed to patterns or for undergraduate classes.
And most of all, the book is a collection of "CHALLENGES". They are not questions meant to challenge the understanding of what has been read but ask the reader fundamental questions and concepts, without any attempt to offer any basic explanation first! It's infuriating and frustrating. You must constantly turn the pages to the solution chapters! It's, at best, distracting.
I don't understand why authors would follow such formats. When I buy a study book I don't want to be challenged I want to be taught! Challenges already exist and are the reason why I buy study books - to get answers! This book doesn't offer any.
Part 1 - Interface Patterns: Introducing Interfaces; Adapter; Facade; Composite; Bridge
Part 2 - Responsibility Patterns: Introducing Responsibility; Singleton; Observer; Mediator; Proxy; Chain of Responsibility; Flyweight
Part 3 - Construction Patterns: Introducing Construction; Builder; Factory Method; Abstract Factory; Prototype; Memento
Part 4 - Operation Patterns: Introducing Operations; Template Method; State; Strategy; Command; Interpreter
Part 5 - Extension Patterns: Introducing Extensions; Decorator; Iterator; Visitor
Part 6 - Appendixes: Directions; Solutions; Oozinoz Source; UML At A Glance; Glossary; Bibliography; Index
Wake and Metsker use the same standard patterns that have been popularized in the Gang Of Four patterns book. But the main difference between that book and this one is in the application of the material. After you get a very clear understanding of the goals of a certain pattern set, they explore the implementation of that pattern using Java coding examples. That's the value that sticks out for me. Rather than dealing with general abstract coding philosophy, you end up with concrete examples, real business scenarios, and working code that illustrates the concept. Granted, the "real business scenarios" are most applicable to running a fireworks factory, but it's better than "dog is a object of class mammal" fluff that doesn't bridge well to where we live on a daily basis...
This book can definitely stand alone when it comes to learning all about design patterns. But if you've read the classic and still don't "get it", this book will tie it all together for you... From the Java perspective, it'd be hard to go wrong here...
Most recent customer reviews
The authors use examples from rocket science to explain the concepts in the book.Read more
1. Good descriptions of the patterns.
2. Good explanation of how to use the patterns to solve a particular problem.Read more