Customer Reviews

Java™ Design Patterns: A Tutorial

5 star:		(6)
4 star:		(7)
3 star:		(12)
2 star:		(8)
1 star:		(22)

 

 

I needed a book that could quickly get me through the concepts of the Gang of Four's Design Patterns book using Java and that's what I got. The book covers 23 patterns concisely and with practical examples illustrated in Java code and UML diagrams. The preface of the book states that it is not a companion to the Design Patterns text so I didn't expect elaborate explanations and extensive code examples, I didn't want them either.

As "A Tutorial" the text quickly explains what Design Patterns are, introduces UML and gets on with teaching the patterns. Each pattern has at least one example with its Java code described. Some of the examples, like those involving swimmers, seemed a bit esoteric, but they all illustrated their patterns sufficiently. The text only shows the Java code that illustrates the design, other code required to run the example is thankfully hidden away on the CD-ROM.

The best thing about this book and about design patterns in general is that it takes your OO understanding up another level. If you are familiar with the basic OO principles of inheritance, polymorphism, etc., then you know how to build objects to meet your needs. The design patterns illustrated here takes you to the next step to show you what you should build to solve particular problems. It doesn't do your thinking for you, you still have to implement your own solutions, but now you're not lost in the woods as at least you have a place to start.

What would have been even nicer if the book hadn't been loaded with so may typos. Most of them are very minor, but their sheer abundance is annoying at times. Specifically, the code examples are fraught with inconsistent indenting and bracketing that can make them very difficult to read. Also, the inclusion of the JVISION tool on the CD-ROM would have been welcome (or even a URL where it could be found) as the text makes frequent use JVISION produced UML diagrams. A demo version of JVISION can be downloaded from www.object-insight.com.

To clarify an issue raised by a previous reviewer, an Appendix A, mentioned in the preface, does not exist, but its content, a JFC tutorial, is covered in Section 5 of the text -- another minor, but avoidable, mistake.

If you are waiting for the perfect design patterns book then Java Design Patterns will disappoint, but you are probably in for a very long wait. This book gets you over the hurdle of initial understanding and for that it should be praised.

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.

The idea is great - provide an explanation of design patterns using visual java components as examples. The author's explanations were usually clear. But there are so many typos that I quickly lost confidence in the code samples and the book itself. It also looks like the coverage Swing was an after-thought. The last few chapters are a superficial tutorial on Swing that provide very little insight into Swing or design patterns.

Looks to me like the author did his job, but the publisher (editors, proofreaders, etc.) let him down.

There is a tremendous need for a good, readable book that teaches design patterns in a way that the average reader can understand and follow and which uses Java for code examples. Unfortunately, this is not that book.

In a session at JavaOne 2000, the author stated that he wrote this book as part of his process of learning about patterns, and it's clear throughout the book that he didn't have a full grasp of the patterns he was writing about. For example, on page 80 he mistakenly identifies Java's AWT adapter classes (such as MouseAdapter) as being examples of the Adapter pattern. They are not.

In addition, as other reviewers have pointed out, the book is riddled with typos and also suffers from poorly chosen code examples. Given all these problems, I cannot recommend this book at all for anyone interested in learning more about patterns. As hard as it is to read and understand at times, the Gang of Four book is still your best bet.

First let's deal with the typos. There are many of them and some are serious. Looks like there was a rush to market here. Hopefully these will be corrected in the next printing. If it weren't for all the typos, I would have given this book 5 stars.

Now to the book itself. I love the organization: all the GoF patterns, each with a clear and concise description. Plus each pattern is accompanied by at least one working example. Each example has a Swing interface so you can run and modify the code to get a better acquaintance with the pattern. Each example is accompanied by a UML diagram which shows how the objects in the pattern relate to each other. The UML diagrams do not show the Swing interface. This is good, it puts the focus on the pattern itself, not on the GUI wrapper.

After reading this book, I feel that I have a very good basic understanding of the GoF patterns -- well worth the price of the book.

I agree with many of the other reviews, that while there is a great need for a good book of this type, this is not it. You might as well read a book about design patterns in VB, it will probably do you less harm.

Apart from the obvious typos and esoteric examples, this book falls way short of both understanding the issues, and communicating workable solutions to the reader. In some cases the author is not just advocating impractical solutions, he actually shows a fundamental lack of understanding of both the design patterns themselves and Object Orientation in general.

I think that the biggest problem with the book is that unless the reader knows something about design patterns, and more specifically, implementing them in Java, then the examples provided will seem reasonable. Many of them are not. This I think explains why the book has a couple of good reviews, and an awful lot of bad ones.

Take for instance the singleton, the simplest design pattern. The author’s implementations are far from the 'standard' or even common java implementations, and are not particularly practical. None of them are thread safe, in fact the author never even mentions thread safety, which is rather important if you want to ensure one instance in a multi-threaded language like Java.

In addition the author also seems to have missed the OO boat completely, I am not sure how he came to the conclusion that a final class with static methods is the same as a single instance (remember that the singleton patterns intent is to “Ensure a class only has one instance, and provide a global point of access to it”)....or advocating implementations that create as many problems as the solve i.e. having to 'find' instances in large programs!!, or having to catch exceptions from constructors!

In fact, as far as I can see none of his implementations fully satisfy the intent of the pattern as none of them fulfill the second part of the intent and provide a global point of access to the single instance. In addition a true singleton needs to be thread safe to completely fulfill the first part of the intent.

I could go on and on…

What scares me is that there are people with little experience or knowledge reading this book and taking it for gospel, and what is even more frightening is that I will at some point probably have to work with some of them, or maintain code that they have written.....

If you have not read this book yet, please save time and money by not reading it.

It is a pity that Addison Wesley should have come out with the best OO book (the GoF book) and this one. I teach object orientation for a living and would strongly advise you against trying to learn patterns or OO from this book. The author does not understand the subject at all.

The examples are very contrived; more importantly, they are needlessly complex and often miss the spirit of the pattern under discussion. There are numerous mistakes, and I am not talking about typos. In place after place the author mixes up classes and objects.

To me it is very clear that this book (even the proposal) was not reviewed by competent people. Also, it is plain that the author just read the GoF book and without understanding it fully jumped in to try and fill the definite market need for a Java Patterns book.

When publishers do this kind of thing I think it borders on the unethical. One trusts some publishers and relies on them for quality. I learnt my lesson so far as Addison Wesley goes.

i think this book was written with good intentions, to function as a tutorial or a help-guide to the densely written "Design Patterns" , or to provide java examples in a more readable way. so far, i like the way book is organized and the way he explains the concepts that i couldn't understand just by reading the original book. however, the examples are from hell!! why in the world would the author think that the general readers would be familiar with 'seeding', and 'heating' in swimming competition? and different types of gardens? i understand you are a swimmer and a home-owner but that's not a proper reason to make readers confused.

The other two sources on design patterns that I have seen have been the two volume Java patterns book by Mark Grand and, of course, the Gang of Four's "Design Patterns". The Grand books have gotten nothing but flamingly terrible reviews and the GoF's book tends to be a bit theoretical and abstract.

What I was hoping to get out of this book was a less formal treatment of the topic of design patterns using Java, a language I am more familiar with. The book partially delivers on this but it is absolutely loaded with typos and errors in the book text and source code. Additionally, I was surprised that the CD did not come with the JDK or any trial software, such as the UML Modeling tool JVISION which is used extensively throughout the book.

All in all though, I think this book is a decent introduction to design patterns using the Java language but you will need the GoF's book also if you want the the complete story.

First, the laurels: I'm only about 1/3 into the book, but I've already learned more from this book in three days than from the GoF book since I bought it over a year ago. No academic hand-waving here. Targeted for those of us who actually need to get something accomplished. Great idea to exactly parallel the GoF book. The source code are minimalist, unlike the rambling examples I've too often come across. Now the Darts: 1) the author tends to pick problem domains that are foreign to some of us (I'm not a competitive swimmer, and I'm not interested in knowing how seeding is done) 2) The first code sample I dove into (Prototype) would not compile. The offending class was missing an 'abstract' keyword. I spent fifteen minutes debugging before realizing that the class was extraneous and could be deleted -- the rest of the example did not depend it! 3) in an effort to keep the chapters short, the author's explanations tended to be jumpy and fragmented, often spending too little time on key concepts, and too much time on obvious ones. The result is that you really should print out and walk through the code *before* trying to read the chapter.