Java(TM) Design Patterns: A Tutorial (Paperback)

~ (Author)

Editorial Reviews

Product Description

Design patterns have become a staple of object-oriented design and programming by providing elegant, easy-to-reuse, and maintainable solutions to commonly encountered programming challenges. However, many busy Java programmers have yet to learn about design patterns and incorporate this powerful technology into their work.

Java(tm) Design Patterns is exactly the tutorial resource you need. Gentle and clearly written, it helps you understand the nature and purpose of design patterns. It also serves as a practical guide to using design patterns to create sophisticated, robust Java programs.

This book presents the 23 patterns cataloged in the flagship book Design Patterns by Gamma, Helm, Johnson, and Vlissides. In Java(tm) Design Patterns, each of these patterns is illustrated by at least one complete visual Java program. This practical approach makes design pattern concepts more concrete and easier to grasp, brings Java programmers up to speed quickly, and enables you to take practical advantage of the power of design patterns.

Key features include:

* Introductory overviews of design patterns, the Java Foundation Classes (JFC), and the Unified Modeling Language (UML) * Screen shots of each of the programs * UML diagrams illustrating interactions between the classes, along with the original JVISION diagram files * An explanation of the Java Foundation Classes that illustrates numerous design patterns * Case studies demonstrating the usefulness of design patterns in solving Java programming problems * A CD containing all of the examples in the book, so you can run, edit, and modify the complete working programs

After reading this tutorial, you will be comfortable with the basics of design patterns and will be able to start using them effectively in your day-to-day Java programming work.

From the Inside Flap

This is a practical book that tells you how to write Java programs using some of the most common design patterns. It is structured as a series of short chapters, each describing a design pattern and giving one or more complete, working, visual example programs that use that pattern. Each chapter also includes Unified Modeling Language (UML) diagrams illustrating how the classes interact.

This book is not a "companion" book to the well-known Design Patterns text Gamma, 1995 by the "Gang of Four." Rather, it is a tutorial for people who want to learn what design patterns are about and how to use them in their work. You need not have read Design Patterns to gain from reading this book, but when you are done here you might want to read or reread that book to gain additional insights.

In this book, you will learn that design patterns are a common way to organize objects in your programs to make those programs easier to write and modify. You'll also see that by familiarizing yourself with these design patterns, you will gain a valuable vocabulary for discussing how your programs are constructed.

People come to appreciate design patterns in different ways--from the highly theoretical to the intensely practical--and when they finally see the great power of these patterns, they experience an "Aha!" moment. Usually this moment means that you suddenly had an internal picture of how that pattern can help you in your work.

In this book, we try to help you form that conceptual idea, or gestalt, by describing the pattern in as many ways as possible. The book is organized into six main sections:

An introductory description A description of patterns grouped into three sections: Creational, Structural, and Behavioral A description of the Java Foundation Classes (JFC) showing the patterns they illustrate A set of case studies where patterns have been helpful

For each pattern, we start with a brief verbal description and then build simple example programs. Each example is a visual program that you can run and examine so as to make the pattern as concrete as possible. All of the example programs and their variations are on the CD-ROM that accompanies this book. In that way, you can run them, change them, and see how the variations that you create work.

All of the programs are based on Java 1.2, and most use the JFC. If you haven't taken the time to learn how to use these classes, there is a tutorial covering the basics in Appendix A where we also discuss some of the patterns that they illustrate.

Since each of the examples consists of a number of Java files for each of the classes we use in that example, we also provide a Visual SlickEdit project file for each example and place each example in a separate subdirectory to prevent any confusion.

As you leaf through the book, you'll see screen shots of the programs we developed to illustrate the design patterns; these provide yet another way to reinforce your learning of these patterns. You'll also see UML diagrams of these programs that illustrate the interactions between classes in yet another way. UML diagrams are just simple box and arrow illustrations of classes and their inheritance structure, with the arrows pointing to parent classes and dotted arrows pointing to interfaces. If you are unfamiliar with UML, we provide a simple introduction in the first chapter.

Finally, since we used JVISION to create the UML diagrams in each chapter, we provide the original JVISION diagram files for each pattern as well, so you can use your own copy of JVISION to play with them.

When you finish this book, you'll be comfortable with the basics of design patterns and will be able to start using them in your day to day Java programming work. James W. Cooper
Wilton, CT
Nantucket, MA
November, 1999

0201485397P04062001

See all Editorial Reviews

Product Details

• Paperback: 352 pages
• Publisher: Addison-Wesley Professional (February 13, 2000)
• Language: English
• ISBN-10: 0201485397
• ISBN-13: 978-0201485394
• Product Dimensions: 9.2 x 7.3 x 0.7 inches
• Shipping Weight: 1.3 pounds
• Average Customer Review: 2.4 out of 5 stars  See all reviews (54 customer reviews)
• Amazon.com Sales Rank: #726,393 in Books (See Bestsellers in Books)

Customer Reviews

Most Helpful Customer Reviews

110 of 114 people found the following review helpful:

4.0 out of 5 stars Meets but does not exceed expectations, February 17, 2000

By	Peter L. Lutz (Oak Park, Illinois) - See all my reviews (REAL NAME)

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.

32 of 32 people found the following review helpful:

3.0 out of 5 stars Good but could easily have been much better, August 15, 2000

By	Vincent O'Sullivan (London, England.) - See all my reviews (REAL NAME)

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.

26 of 27 people found the following review helpful:

3.0 out of 5 stars Good idea, sloppy execution, April 20, 2000

By	Paul Farwell (USA) - See all my reviews (REAL NAME)

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.