Rating: 
Summary: Could have been better
Review: The new two book series tries to have more patterns and tie them all to Java. One advantage to this approach is that some patterns make sense in Java that do not make sense in other OO language. Apparently from reading Volume 2, it appears that a Volume 3 is planned.<p.An odd thing about this series is that the first three chapters are the same in both books. I wish they were in Volume 1 only to save me some money, shelf space and to save trees. It is true that the books gives you a large library of patterns. However, it has been discussed between myself and others that some of the patterns are not really patterns at all. For example, the so-called "Testing Patterns" have been around forever and are methodologies not Patterns. Also, they are not related to Java in any way. The explanations in this book in no way compare to the explanations found in GoF. The descriptions of patterns in GoF were pretty consistent in understandability. "Patterns in Java" was a real mixed bag. Some patterns had wonderful explanations. Others did not make sense to me even after repeated readings. Most were just okay though. Many of the code examples seem overly complex to me. Instead of just showing the patterns in isolation, the examples tend try to do something else which masks the patterns itself. Also, I saw some bugs in some of the code and others have told me the same. For example, the singleton code examples claims "If you play all audio clips through the AudioClipManager object, there will never be more than one audio clip playing at the same time." However, from looking at the code, I see a race condition that is not handled. In summary, if the book was executed properly, it would be incredibly useful to all Java programmers. However, the implementation is very flawed. It is still marginally useful in that it documents a lot of patterns that GoF does not. A second edition, which focused on improving explanations and code examples, is needed to make these books really good.
Rating: 
Summary: Trash
Review: This book epitomises so much of what is wrong in the software industry that I wonder if, in a sick kind of ironic way, that this is its only value? It cashes in on buzzwords in the title but is full of errors and demonstrates a complete lack of understanding of the material by the author. There is nothing to redeem this book. It is an embarassment.
Rating: 
Summary: A different kind of pattern book
Review: Volume 2 of Patterns in Java contains coding patterns, GUI patterns, testing patterns and even patterns to help bridge analysis and design. Volume 1 is a book that contains patterns that are all related to object oriented design. After writing Volume 1, I thought it would be good to write about patterns related to other parts of the software development process. The patterns in Volume 2 are not design patterns. For some reason, a number of people seem to have bought Volume 2 without reading the description of the book and have then written bad reviews complaining that that patterns in Volume 2 are not design patterns. If you are interested in patterns related to the areas that Volume 2 talks about, please do buy it. If you are only interested in patterns related to the design phase of software development, then this volume is not for you.
Rating:
Summary: 90% obvious to a half-decent programmer
Review: While I liked Volume 1 of this series, this book is just not worth the money. Most of its "patterns" are obvious strategies which anyone who has taken more than a couple CS classes will know already. For example, there are about ten "User Interface" patterns. These consist of things like "If the user needs to enter many pieces of discrete information, use the Form pattern." Many of the other patterns are similarly obvious. However, there were a few ideas about efficiency and testing which I found useful, so the book is not a total loss. I'd suggest flipping through it at a local bookstore, but that's it.
Rating:
Summary: Does the reader more harm than good
Review: Yes, it is high time to apply design patterns to Java. Java presents opportunities and challenges that were not present in C++. In this series, Mark Grand converts well-established design patterns into Java. Unfortunately, he fails to demonstrate even a rudimentary understanding of his material. These books read like hopelessly flawed research papers, not the fruit of experience. I finished both books wondering whether the author had ever actually implemented any of these patterns in a real-world design. He misinterprets some key points while missing others altogether. Some well-established patterns use inheritance for mixins. That's fine for C++, but Java provides only single inheritance. Wasting inheritance as he does, the author's implementations make it impossible to use inheritance for normal (more important) purposes. Interfaces solve many of the problems that the author creates. In some cases, the implementations contain hard code that flatly contradicts the intended generality of the patterns. Volume 2 also demonstrates that the author does not know the difference between a coding technique and a design pattern. Some of his so-called "design patterns" (under his own name, of course) are mere coding techniques that have been around practically forever. Assertions provide a typical example. This book may fool less experienced readers. Too bad they will eventually have to unlearn the garbage they pick up here. This book gets one star only because it is the lowest rating I can give. Mr. Grand, please stop writing! You're only embarrassing yourself. Please do not release your intended third volume while your first two are in such desperate need of rewrites by a knowledgeable professional.
| 
