Customer Reviews

Design Patterns in Java(TM) (Software Patterns Series)

5 star:		(3)
4 star:		(4)
3 star:		(0)
2 star:		(1)
1 star:		(2)

 

 

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...

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.

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.

First off, the content/material in this book is great and very helpful for starting to bridge the gap between being just a Java programmer to becoming a system designer.

My biggest problem with this book is its format/structure. You cannot read it straight through (linearly). There are questions and challenges scattered throughout each chapter that force you to flip to the back of the book to see the answer because there are not enough supporting examples in-line. IMO, sometimes there is not enough information before the question/challenge to answer it (especially if you're not very familiar with Design Patterns); this forces you to check the back of the book every few pages, which can be very annoying. I was hoping for a book that I could read straight through, not a workbook.

I am a beginner in OO programming and Java. I have had to read a lot recently and this is not one of my better purchases.

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.

I am going through this book now. It is horrible.

The authors use examples from rocket science to explain the concepts in the book. They could have picked simple day-to-day examples like a library or a movie store. But instead decided to use rocket science. Then there is something called Oozinoz. I don't get exactly what that is or how it is relevant to Design Patterns. But the authors use that a lot. If what I have written sounds vague, well that is because it is.

Secondly, the organization is very bad. The meat-and-potato of the learning is hidden away in "challenges." Let me explain. At the beginning of every chapter, the authors briefly explain the problem to you. Then instead of providing a solution, they throw a challenge to you to solve the problem. To view the solution one has to flip to the back of the book where it is provided in vague esoteric diagrams. This is not the way to write books.

There are 23 patterns allegedly described in this book. I haven't understood any of them. The few I knew from before like Singleton and MVC, I am now more confused about them. I wish I could get a refund for this trash.

pros:
1. Good descriptions of the patterns.
2. Good explanation of how to use the patterns to solve a particular problem.

Cons:
I wished the examples were better. Most people are not familiar with CAD systems, so a more common software problem would have been more helpful.

I found the book quite useful. I especially liked that the book is Java based as that is the language i primarily use and that code examples are provided. I learn by doing and the book is excellent at giving the reader the opportunity to implement patterns. This book is more than just theory. It's practical.

This is really a good book on the design patterns which I reckon being better than the original one, in the sense it provides a higher clarity degree. Each pattern is explained in depth along with some good code and UML diagrams.

I have read the classic Design Patterns book (from the GoF) and wanted the same book but with Java examples. This book isn't even close. The explanations are so shallow and/or convoluted that even with previous knowledge of design patterns I struggled to understand what the author tried to explain. The Java examples are incomplete, boring and completely fail to illustrate the topic.

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.

I threw that book in to the recycling bin the day after I received it.