Customer Reviews

Applied Java Patterns

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

 

 

I purchased this book with the intent of broadening my knowledge of patterns after reading the GOF book (about 3 times), the Mark Grand series and Java Design Patterns [Cooper].

In one of his first examples Abstract Factory, a structure diagram is presented in canonical form; i.e. class a, class b, class c.... This didn't bother me except that his example code was a bit trivial and was not presented in terms of the structure diagrams. OK, I can read and figure things out, but if you are going to present the diagram and working examples, at least put the example code into the presented structure diagram, fair enough?

The next pattern that really bothered me was his implementation of Factory Method. He once again presents a generic structure diagram and does not present his own code in the same format.
The reason is that his sample code does not fit into the diagrams presented. This to me is a red flag! He does however provide explanations behind his implementation of the pattern. In the case of Factory Method his Contact class is both a concrete creator and concrete product. This I initially found confusing! I had to turn to the back of the book to figure out what he was trying to accomplish.

So in short several pattern start with a structure diagram and example code that doesn't fit into the presented diagram. I would remove the generic structure diagrams and provide ones in context of the examples. Make my job, as a reader, simple! Unless you have a way of reverse engineering the code, you're stuck with pen and paper.

I believe I have griped enough, here are some reasons to buy the book. He does present some nice explanations of the patterns, they are implemented in Java and it will help broaden your knowledge of design patterns.

Would this book be my first choice if I were shopping a design patterns book for Java? Answer: NO! There is a new book coming out "Design Patterns Java Workbook" by Steve Metsker that I have previewed. In my very humble opinion, the author has a much better understanding of design patterns and the examples are in the context of an entire application; which is actually very amusing to follow. In contrast, all of the examples are presented with precise UML diagrams in terms of the code snippets provided.

A number of my instructor colleagues have commented for years that someone should write a Java patterns book. None of us took up that challenge, obviously. Stephen and Olav did; their book finally brings to new and intermediate programmers a gentle but stimulating introduction to the subject. If your programs compile and run, but you have a feeling there are better, more sophisticated ways to compose Java, you're right: read this book and find out about them.

The patterns catalog in this book walks through the feature development of a Personal Information Management (PIM) program. Patterns are used to impose a general problem domain to each feature described (e.g., conference scheduling). The authors then show how the classic pattern might be modelled and implemented in Java. If you've never gone from a problem statement to a language-neutral design solution to code-writing before, this process can be slow going the first few times. The authors address this by separating features so you don't have to read the catalog in order.

There's no CD-ROM, so the source code is printed in full in the back of the book. Bad publisher, no biscuit. Just give me the CD, alright? Yes you can download the code by ftp, but my network life is controlled by firewall [people]. I need an HTTP tunnel, please.

I take the complaints that professional methodologists will have with this book with a grain of salt. This book was not written for their review and consensus; it's written for people who want to learn this subject and who allow the view that methodology is an art, not science and certainly not rooted in absolutes. That said, you may some day disagree with a design interpretation or two in this book, but you'll see them nonetheless applied thoughtfully to practical examples.

Another nice touch: the authors point out several examples in the JDK where these patterns have been applied, so if you want pointers to real-world examples using 'production' source code, there's no better place to look than the JDK. It's some of the most intensely scrutinized code ever.

Though this book covers all relevant patterns, it also includes lots of typos and mistakes which makes it hard and annyoing to read: The full code examples at the end of the book are incomplete; source code of some examples is missing there, but instead others is printed twice. The UML diagrams are incomplete or even wrong. The code presented to each pattern does party not fit to the UML diagrams. So if this would be the first book about patterns I would suggest NOT to buy it!

I got the book before I had read the GOF book and found it quite useful. After reading the GOF book I found it even more so - I like the simpler examples and the fact that they are done in Java. Some people will not like the code reprint at the end of the book (about the last half of the book) - however I do, as it is quite convenient for referencing. Found the UML diagrams that were downloadable from the web reference site quite helpful.

The major problem with the book are the errors! The first pattern I looked at (Visitor) had an extraordinary number of errors. In the text it gave the methods one name and used another name in the code listing. Two of the classes for this pattern the code was simply duplicated from a third class. The downloaded examples did have the correct code. Be nice if there was a CD - but this is no major issue.

I would give it a 2 star at best, due to the errors, but if you can sift through the errors I think you will find it a nice supplement to the GOF book hence 3.5 stars (if I could).

I have waited for a good pattern book in jave for years. This is the best on the market so far. Because the big picture has been explained very well in GoF book (new book authors, please don't repeat it in other books;-), I was looking for the low-level implementation oriented book. There are several "middle-level" books (copied big picture and no solid/complete code - please do not show me some snipets, I am not that smart ;-)

Up
1) this book contains a complete java implementation for each pattern
2) it also contains some patterns used in java itself, which is a great plus!
Down,
1) I cannot find a website to download the samples, I may be wrong, but I don't think the book points to a working website either by today 1/15/2002.
2) Some typo need to be correct but they are obvious. Readers should have no problems with them.

Just shortly: Book contains all patterns from GoF book. Patterns are explained in more appropriate way and more closer to Java. Also examples are pretty simple and easy to understand. So the simplicity would be the best about this book.

I also like that the the second part of the book: "Patterns in the Java Programming Language" where the author covers extra patterns used in J2EE which I find very usefull !

I would like to see a CD or FD attached on the end of the book, although full code samples are also good (you don't need PC while reading the book). There is a web site to download examples and images and all fits on one single cheap floppy.

Anyway the best pattern book for Java I saw. I have many Pattern eBooks, but all of them are either too simple (can't really learn how to use the pattern), or too complicated (e.g. GoF is complicated for me). So this remains the best for me.

I've been waiting a long time for a Java equivalent to the GOF book on patterns. At last my wait is over. It has very good explanations of the 23 patterns found in GOF but also there are chapters on system patterns and patterns found within the JDK which I've found very useful.

....

Well at least it's a lot easier to understand. Maybe because the examples were in Java. Not only that, the examples are simple yet close to real-life situations.

In discussing technical matters, examples are the key to better understanding. Even a simple design diagram is difficult to understand, but if you supplement it with working examples, you don't need much explanation.

The structure of the book is organized in simple manner. I'm reading it for preparation to JEE Architecture certification exam and it's a perfect reference. Short and easy to read, I don't waste much time on non-sense stuffs.

I totally recommend it to all Java programmers and designers/architects. You don't need to read the original GOF book, the examples there don't make much sense. You'll just get unnecessary headache, unless you're a C++ programmer (only few of them exists nowadays)

In the Head First Design Patterns book, they don't give equal treatment to all the other patterns. And the authors exaggerate too much on sample scenarios, the book is too comical. They only give ample explanation on 5-8 patterns. The rest of the patterns were crammed into an appendix with very little explanation.

But this book treats each pattern equally and complete with all the sections/attributes to fully understand the pattern.

And it also includes chapters on how patterns were applied in Java/JEE specifications, that's a big bonus! You'll see the applications of patterns in real-life.

To say that a LayoutManager is a Flyweight is to say that any
Composite is a Flyweight to. (since it is a basic part which
may contain other parts, according to this book).
Actually a LayoutManager is a good example of the Strategy design pattern.
The book lookes good. Sun Microsystems and all ...

If you want a clear book on design patterns in Java I would not recommend this. Mark Grand's books are not perfect but still
much better.

-)|(-

For the developer LEARNING Patterns, the Heads First book seems the most popular. But this is essential as a reference book. Premier examples, plus it reads more like a book and less like a math book (as most coding books are).

I open this up from time to time to keep those patterns not used often fresh in my mind to ensure I will realize when one is needed.

This is the first book that I go to for anything patterns, and I have a copy at work because my coworkers also come to this book when they need a refresher or reference.