Rating: 
Summary: What other alternatives do the disgruntled readers suggest ?
Review: I have bought the book, but have not read it yet. Given that many of the reviews are so poor, I may not read it. But, can one of the disgruntled readers suggest another alternative that addresses pattern designs specific to Java?
Rating: 
Summary: Good material., badly edited
Review: The material is good, interesting and usefull, but very badly printed: you never got the diagrams where you expect them to be, right by the text talking about them. It shouldn't have been a big affort to make the text and the images fitting... The result is a difficult reading and a confusional effect.
Rating:
Summary: Less Than Perfect
Review: Like others, I eagerly anticipated an encyclopedia of design patterns implemented in Java. Alas...I've hosted a bimonthly design pattern discussion group for just over a year. We recently began studying patterns from Grand's book which we had not yet covered. I acknowledge that I hold my opinions more strongly and am more vocal than most, and I would never try to speak on behalf of others. Even so, I think it would be fair to say that our study circle's concensus is "Patterns in Java, Vol 1" is a poor book. I, of course, have a much stronger opinion: I think "Patterns in Java" is actually detrimental to both the design pattern and Java communities. The writing is terrifically bad. The errors are countless. The intepretation, context, and presentation of the patterns are misguided at best. The example implementations are remarkably sophomoric. As one wag put it, "This book is an excellent source of anti-patterns." An item by item critique of "Patterns in Java" would be roughly twice as long as the book itself; certainly not a task I would relish. I've been advised to take the good with the bad. Sure, no book is perfect. For instance, our circle was less than satisfied with the presentation of both Flyweight and Intepreter in "Design Patterns" by Gamma et al. But I think we all agree that "Design Patterns" is an excellent book overall. I also accept that patterns appearing in the PLoP books are sometimes formative. Schucks, I even value most pattern articles and features in the various magazines. Having said all that, I have found NOTHING whatsoever of value in "Patterns in Java". I strongly recommend that you NOT buy this book. All of the patterns presented in "Patterns in Java" are covered better elsewhere. And if you are new to design patterns, "Patterns in Java" will only serve to misguide you.
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 two-volume series, Mark Grand converts well-established design patterns into Java. Unfortunately, he fails to demonstrate even a rudimentary understanding of his material. These books in this series read like hopelessly flawed research papers, not the fruit of experience. I finished them 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 of the GoF patterns use inheritance for mixins. That's fine in 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 totally defeat their patterns. They contain hard code that flatly contradicts the intended generality of the patterns. Volume 2 demonstrates that the author does not know the difference between a coding technique and a design patterns. Some of his so-called "design patterns" (under his own name, of course) are mere coding techniques that have been around for years. Assertions are 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 knowledgeable professionals.
Rating: 
Summary: good book
Review: very good as computer books go. i have read reviews that say it is hard to read. well it can force you to think, if that is a problem. i read the reviews on the second book and am confident that it stinks. but this first one is a good one. It addresses things abstractly, and then gives a nice simple implimentation. in my experience, there are not alot of people who can both think abstractly, and also are practical programmers. but this author is clearly one of those. frank
Rating:
Summary: This book is not worth buying...
Review: I was very excited about this book when I first got it and quickly scanned through it. When I sat down to try and implement some of the patterns, I found flaws in the code that comes with the book, shoddy written examples and poor explanations. This book could have been much more, but has turned out to be a half-assed, rushed implementation.
Rating:
Summary: Do not waste your money
Review: Others have said it all. Flawed; just plain flawed. Pattern implementations that are wrong (some of which undo the value of the pattern itself!) inconsistent explanations of the patterns, poor code examples and more. An attempt to "port" GoF but the author shows that he really doesn't fully understand and appreciate the originals, nor Java and what it offers, to port properly and put it all in the Java context. The value you can get out of this is to look at all those who rate the book highly and put them on your hiring blacklist.
Rating: 
Summary: Could have been much 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. 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: Low standards
Review: The beginner will be challenged by myriad inaccuracies, inconsistencies and typos. The veteran will be surprised by the author's inaccurate treatment of the examples he borrows from Go4 ("Design Patterns" / Gamma et al), and will be annoyed by the book's numerous "forward-dependencies" on Volume 2 (still unpublished!). This book fails to live up to its potential as a new catalog of design patterns, because of the author's lack of mastery both of the essence of those patterns and of their clear presentation. Having said that, the author should be praised for his ground-breaking attempt to present a comprehensive introductory book combining design patterns, java, and uml.
Rating:
Summary: No substitute for GoF
Review: Because I'm a Java programmer and think UML is cool, I chose this book over GoF, and I was disappointed. The writing style is bland, the examples aren't so useful, and it's not always easy to find the pattern you're looking for.
| 
