Design Patterns in JavaTM (2nd Edition)
and over one million other books are available for Amazon Kindle .
Learn more
| |||||||||||||||
 Trade In this Item for up to £8.10
Get an extra £5 when you trade in books worth £10 or more until June 30, 2012. Trade in Design Patterns in Java (Software Patterns) for an Amazon.co.uk gift card of up to £8.10, which you can then spend on millions of items across the site. Trade-in values may vary (terms apply). Find more products eligible for trade-in.
|
Frequently Bought Together
Product details
|
More About the Authors
Discover books, learn about writers, and more.
Product Description
Product Description
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.
From the Back Cover
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.
Suggested Tags from Similar Products(What's this?)Be the first one to add a relevant tag (keyword that's strongly related to this product)
|
What Other Items Do Customers Buy After Viewing This Item?
Customer Reviews
Most Helpful Customer Reviews
6 of 6 people found the following review helpful
Format:Hardcover
The authors state in the preface that this is effectively a second edition of Steve Metsker's Design Patterns Java Workbook, and it covers the same material as his Design Patterns in C# book, so if you have either of these, you probably don't want this book.
Unlike many other design patterns books in Java, it covers all 23 GoF patterns, which is a major plus. The only other Java-specific book I've read that covers all the patterns is Holub On Patterns, which, while entertaining and an excellent resource for examples of the application of patterns, is not the best place to learn them. Before tackling this, you will need to be comfortable with Java, Swing and the usual OOP jargon and concepts. A brief appendix on UML is provided.
The explanations of the patterns in this book are for the most part very clear and concise. They are discussed within the context of object oriented design and Java language features, similarly to the approach taken by Design Patterns Explained. This provides plenty of implementation-level insight that helps clarify the intent of the patterns. That said, there are a few places where a reader new to design patterns could get confused.
A firework factory is used as a common example through the text, which feels a bit forced and artificial in many places. The most egregious example is in the Facade chapter, where it is applied to a small Swing application showing the trajectory of a firework. This necessitates a three page digression on parametric equations, a questionable authorial decision.
More annoyingly, 'challenges' are interspersed regularly through the book, in the form of code to be completed, or questions. While the intention is admirable, I quickly became irritated by having to constantly flick back and forth to the answers. Also, many of the UML diagrams in the main text are unfinished, as filling them in is part of the challenge. They're given in full at the back of the book, but not near the text, where you need them. As this format has survived from the first edition, clearly the authors are convinced this is a good idea, but it isn't. For an example of how quizzes and questions work well to support the material, consult Head First Design Patterns.
A minor disappointment is that Java 5 is only referred to in a few places, and generics and autoboxing are not used in the examples. With Java 6 looming on the horizon, it is a pity that the new language features are treated as special cases rather than the default.
I would not recommend this as the only book on design patterns in Java that you'll ever need, but it would make an excellent second book for covering the less well-covered design patterns (e.g. Prototype, Memento, Mediator), and for reinforcing your knowledge of the basics. A previously-prepared reader will then be able to see the wood for the trees in some of the less successful chapters, e.g. the unfortunate Facade example.
The premier book on design patterns in Java is still Head First Design Patterns, but as that doesn't cover everything in the GoF book, this is currently the book I would recommend to fill the gap.
Unlike many other design patterns books in Java, it covers all 23 GoF patterns, which is a major plus. The only other Java-specific book I've read that covers all the patterns is Holub On Patterns, which, while entertaining and an excellent resource for examples of the application of patterns, is not the best place to learn them. Before tackling this, you will need to be comfortable with Java, Swing and the usual OOP jargon and concepts. A brief appendix on UML is provided.
The explanations of the patterns in this book are for the most part very clear and concise. They are discussed within the context of object oriented design and Java language features, similarly to the approach taken by Design Patterns Explained. This provides plenty of implementation-level insight that helps clarify the intent of the patterns. That said, there are a few places where a reader new to design patterns could get confused.
A firework factory is used as a common example through the text, which feels a bit forced and artificial in many places. The most egregious example is in the Facade chapter, where it is applied to a small Swing application showing the trajectory of a firework. This necessitates a three page digression on parametric equations, a questionable authorial decision.
More annoyingly, 'challenges' are interspersed regularly through the book, in the form of code to be completed, or questions. While the intention is admirable, I quickly became irritated by having to constantly flick back and forth to the answers. Also, many of the UML diagrams in the main text are unfinished, as filling them in is part of the challenge. They're given in full at the back of the book, but not near the text, where you need them. As this format has survived from the first edition, clearly the authors are convinced this is a good idea, but it isn't. For an example of how quizzes and questions work well to support the material, consult Head First Design Patterns.
A minor disappointment is that Java 5 is only referred to in a few places, and generics and autoboxing are not used in the examples. With Java 6 looming on the horizon, it is a pity that the new language features are treated as special cases rather than the default.
I would not recommend this as the only book on design patterns in Java that you'll ever need, but it would make an excellent second book for covering the less well-covered design patterns (e.g. Prototype, Memento, Mediator), and for reinforcing your knowledge of the basics. A previously-prepared reader will then be able to see the wood for the trees in some of the less successful chapters, e.g. the unfortunate Facade example.
The premier book on design patterns in Java is still Head First Design Patterns, but as that doesn't cover everything in the GoF book, this is currently the book I would recommend to fill the gap.
Most Helpful Customer Reviews on Amazon.com (beta)
Amazon.com:
10 reviews
24 of 27 people found the following review helpful
Bridging pattern theory to coding reality...
22 July 2006
Format:Hardcover
If you're a Java programmer and want to approach the subject of design patterns from that perspective, this book is very well done... Design Patterns In Java by Steven John Metsker and William C. Wake.
Contents: Introduction
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...
Contents: Introduction
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...
17 of 19 people found the following review helpful
for new and intermediate Java programmers
9 May 2006
Format:Hardcover
Metsker, in collaboration with Wake, has released a counterpart to his earlier book, "Design Patterns in C#". Essentially, it covers the same design patterns, but now implemented in Java code. The authors readily point out that the book is directed at a new or intermediate Java programmer. Experienced Java coders probably [or should] already have written such patterns, based on their prior knowledge.
The book takes you beyond the elementary syntactical issues of Java. The pedagogy also includes frequent problems interwoven into the text. These have answers! [At the back of the book.] One reason given by the authors for including the problems is simply that you can get good experience with patterning, if you tackle them. A cheaper and safer alternative than trying out patterns for the first time on actual workplace problems.
None of the problems are very intricate. But they expose enough of the essence of the patterns for your understanding.
Of course, aside from actual coding, patterns are now forming part of the standard vocabulary of professional programmers. If you are not a programmer, but have to interact with them, then the text can be good background.
The book takes you beyond the elementary syntactical issues of Java. The pedagogy also includes frequent problems interwoven into the text. These have answers! [At the back of the book.] One reason given by the authors for including the problems is simply that you can get good experience with patterning, if you tackle them. A cheaper and safer alternative than trying out patterns for the first time on actual workplace problems.
None of the problems are very intricate. But they expose enough of the essence of the patterns for your understanding.
Of course, aside from actual coding, patterns are now forming part of the standard vocabulary of professional programmers. If you are not a programmer, but have to interact with them, then the text can be good background.
15 of 17 people found the following review helpful
A great read for Java developers looking to improve their design skills
9 Sep 2006
Format:Hardcover
I've heard a lot about the classic "Gang of Four" Design Patterns book. However, while I've read many papers based on it, I've never actually read The Book. So, when I had a chance to read the new Design Patterns in Java(TM) (2nd Edition) it seemed like a perfect chance to load up on some must-know information as it is applied to my programming language of choice. Excellent!
This book merges and updates the Design Patterns Java Workbook and Design Patterns C#. Design Patterns in Java is targeted at developers who know Java and want to improve their skills as designers. It covers the same 23 patterns discussed in the Gang of Four Design Patterns book.
Patterns are powerful things. As the Metsker and Wake put it, "Patterns are distillations of accumulated wisdom that provide a standard jargon, naming the concepts that experienced practitioners apply." Exactly! They authors have a way with words. I really appreciated the one sentence descriptions of each pattern at the beginning of each chapter. These helped me to immediately grasp the intention of each pattern before digging in to the details. The periodic "challenges" throughout the text are thought provoking and worth the effort to work through.
The advantage of this Java-centered book over a general patterns book is that it helps you understand how Java's unique features can be used to implement the patterns. For example, sorting can be implemented using polymorphism and the template method pattern. The original GoF book is a classic. Design Patterns in Java is, for the Java developer, the perfect combination of the GoF book's concepts with concrete Java implementations to make it all easier use. Not only are there Java examples but the book also includes information to help you refactor your existing code to use patterns. Very helpful.
The appendices include solutions to the various code challenges, information to access the sample site's source code, and a crash-course in UML.
I love the suggestion at the end of Appendix A: "Decide how many hours a week you want to spend on your career. Take five hours off the top and pay yourself first. Spend that time away from the office, reading books and magazines or writing software related to any topic that interests you." Great concept!
If you're a Java developer looking to invest some time to improve your design skills, this would a great place to start.
This book merges and updates the Design Patterns Java Workbook and Design Patterns C#. Design Patterns in Java is targeted at developers who know Java and want to improve their skills as designers. It covers the same 23 patterns discussed in the Gang of Four Design Patterns book.
Patterns are powerful things. As the Metsker and Wake put it, "Patterns are distillations of accumulated wisdom that provide a standard jargon, naming the concepts that experienced practitioners apply." Exactly! They authors have a way with words. I really appreciated the one sentence descriptions of each pattern at the beginning of each chapter. These helped me to immediately grasp the intention of each pattern before digging in to the details. The periodic "challenges" throughout the text are thought provoking and worth the effort to work through.
The advantage of this Java-centered book over a general patterns book is that it helps you understand how Java's unique features can be used to implement the patterns. For example, sorting can be implemented using polymorphism and the template method pattern. The original GoF book is a classic. Design Patterns in Java is, for the Java developer, the perfect combination of the GoF book's concepts with concrete Java implementations to make it all easier use. Not only are there Java examples but the book also includes information to help you refactor your existing code to use patterns. Very helpful.
The appendices include solutions to the various code challenges, information to access the sample site's source code, and a crash-course in UML.
I love the suggestion at the end of Appendix A: "Decide how many hours a week you want to spend on your career. Take five hours off the top and pay yourself first. Spend that time away from the office, reading books and magazines or writing software related to any topic that interests you." Great concept!
If you're a Java developer looking to invest some time to improve your design skills, this would a great place to start.
Were these reviews helpful?
Let us know
Listmania!
|
|
Look for similar items by category
Look for similar items by subject
Feedback
- Would you like to update product info or give feedback on images?
- I am the Author, and I want to comment on my book.
- I am the Publisher, and I want to comment on this book.
|
