Rating: 
Summary: i dont think this book worth my time to read
Review: well, i have Pattern in Java at home, and this book at my working place, compare 2 books, i like previous one much better. Always, the pattern is not fully described, and you have to go through details in code to get what is the pattern realy about. Even worse, i dont know how is source code on CD get compiled, i have tested it with JDK1.1.8, 1.2.1, 1.2.2, some method like, stack.top(), stack.nextTop(), i cannt find it anywhere. Some part of the book like the deep copy logic, i think it is wrong.well, anyway, i didnt pay this book from my own pocket.
Rating: 
Summary: Good but could easily have been much better
Review: Despite its disclaimer, this book is a close companion to the popular book Design Patterns by Gamma, Helm, Johnson and Vlissides. I read that book some years ago and, like many people, often toyed with the idea of translating all the examples from Smalltalk to Java. I did it with some and then got distracted by other work. Cooper though has stuck with it and gone the distance. Java Design Patterns is the result. It is a fairly comprehensive book and all the most important patterns can be found in it. Starting with creative patterns (such as factories) and working through to more complex structural and behavioural patterns. There are plenty of examples included but they are spoiled (in my opinion) by only being partly included and explained in the book. Often a class will be presented but no example of its implementation. For compete examples you have to load up the companion CD and work through them yourself. Acceptable but not efficient. Some of the examples themselves are too esoteric. For instance, with the Factory pattern, it is neccessary to sit down with a pen and paper to work out how swimming tournaments and their heats and seeding methods are organised before tackling the code. It is one of several instances where the example is more complex than the pattern being illustrated. Explanations of the principles behind the patterns is no more than adequate and lacks the cutting edge that fires the enthusiam to make you go and try things out for yourself. I suspect that the author, though up to speed on Java, does not have sufficient field experience of the language to have absorbed the insights necessary to lift the book from useful to essential reading. Finally, typos: There are far too many. A puplisher of the quality and experience of Addison-Wesley really ought to be ashamed. Flicking through the book right now I've just found another (a sub-heading heading 'ggable Adapters' where it should be 'Pluggable Adapters'). Would I recommend the book? Perhaps if it was cheaper and someone tidied up. As it stands, almost but not quite. Some of the examples are spot on but there are not enough of them to carry many others that aren't.
Rating: 
Summary: Great way to understand patterns on the first reading
Review: The authors of the landmark book "Design Patterns" book by Erich Gamma...[et al.] aka the Gang of Four (GOF) book state in their preface: "Don't worry if you don't understand this book completely on the first reading. We didn't understand it all on the first writing!" Cooper's "Java Design Patterns A Tutorial" is so clearly written that the reader can quickly understand the main idea of a pattern and how to implement it on the first reading. Cooper recommends in his introduction that you also read the Gof Design Patterns book. This really makes a powerful combination. First read about a pattern in Cooper's book so that you know what the key parts to it are and what you need to do to code it. Then study the gof book and ponder the insights of the masters. I have another book on Patterns in Java but I find that book harder to understand than the Gof book. Only after reading about a pattern in Cooper's book could I go back to the other book and understand the presentation of the pattern. Basically, you are left thinking "nice code but how do I apply this to my own work? what do I really need to do to implement this pattern?" Cooper's book clears all that up. Cooper is like the good friend in college who could explain something to you in 10 minutes that you couldn't understand after an hour lecture or hours of studying. Java Design Patterns a Tutorial by James Cooper is one of the best books I have.
Rating:
Summary: A disappointing attempt at a worthy goal
Review: Like other reviewers here, I had hoped that this book would offer a more approachable look at the GoF design patterns. Instead I found it to be confusing in places, wildly inaccurate in others (Cooper mistakenly identifies the WindowAdapter class as an example of the Adapter pattern, for example), and filled with bad examples and poorly written code. I ended up putting this book aside and investing the extra time in rereading GoF and I would strongly recommend that others do the same.
Rating:
Summary: Shakily 2 stars
Review: I can barely give this book 2 stars. There is a ludicrous amount of typos. I can't believe Addison-Wesley allowed this out of their press. The typos aren't simply misspellings, but rather references to methods that don't exist, incorrect references to return values, etc. The code snippets will pull variables and custom classes out of thin air without any introduction. The only saving grace (and the thing which has kept me from burning it) is that it is a _decent_ refresher on design patterns if you already know them. However, you'd be better off rereading the canonical "Design Patterns" book. Maybe this should be one star...
Rating: 
Summary: DISGUISED!
Review: The authre does not know the basics of OOP. The author does not know THE JAVA LANGUAGE SPECIFICATION. The example programs are typical codes written by a VB programmer, and full of garbages.
Rating:
Summary: Disgusting
Review: Drop it. The moment you pick up that catchy title - drop it. Don't want to know who's fault is it, author's or editor's, but it's a collection of typos upon typos upon typos, where code doesn't match text and neither match pics. Can go on and on and on ( as typos do). But rather not. This point of view is purely subjective.
Rating: 
Summary: Design patterns explained with gui examples in java
Review: I started reading the GOf design patterns book before i read this book. The Gof book is a great book but i was having a hard time grasping some of the patterns. So i went ahead and bought this book. This is an excellent book on design patterns. The author does a good job of explaining patterns through simple examples in java.
Rating:
Summary: Buy the other one.
Review: This book is just the Java implementation of the patterns described in Design Patterns. If you've already read Design Patterns, this book has very little to offer. If you haven't read it, you probably should.
Rating:
Summary: Not a good one on design patterns
Review: I agree with one of the reviewer that book examples doesn't match with IT field. The book might have some value for interviews(lot of interviewers ask about patterns during job interview) but at times is very confusing. The author goes back and forth on explaining things. Since book doesn't contain whole code examples on paper(they should be on CD), it is hard to follow author's thoughts(if he is trying to convey some!). I guess publisher has tried to take advantage of design pattern buzz word.
| 
