Patterns in Java: A Catalog of Reusable Design Patterns Illustrated with UML, 2nd Edition, Volume 1 (Paperback)

~ (Author) "Software patterns are reusable solutions to recurring problems that we encounter during software development..." (more)
Key Phrases: scheduler pattern, timekeeping terminal, flyweight objects, Single Threaded Execution, Null Object, Creates Creates (more...)

Editorial Reviews

Amazon.com Review

Software design patterns let developers reuse tried-and-true designs in new projects. For the state of the art in object design, consider Patterns in Java, perhaps the best book that Java developers have at their disposal for getting leading-edge pattern expertise in a convenient and well-organized volume.

The guide opens with background on pattern research, including the groundbreaking Design Patterns. This new title goes further, with 41 software patterns, all illustrated with UML diagrams and sample Java code. Early patterns, such as Delegation and Proxy, show how classes can work together without relying on inheritance. Next come creational patterns, such as the Factory and Builder patterns and the newer Object Pool pattern (which can be used to pool database connections for faster performance).

Subsequent sections move on to partitioning patterns, such as the Layered Initialization, as well as structural patterns, such as the Adapter, Facade, and Flyweight patterns. A section on behavioral patterns mixes older patterns such as the Chain of Responsibility and the Strategy with newer designs such as the Little Language and Snapshot patterns. The book closes with seven newer patterns for designing distributed and multitasked systems. --Richard Dragan --This text refers to an out of print or unavailable edition of this title.

Product Description

This is the best book on patterns since the Gang of Four's Design Patterns.
The book manages to be a resource for three of the most important trends in professional programming: Patterns, Java, and UML.-Larry O'Brien, Founding Editor, Software Development Magazine
Since the release of Design Patterns in 1994, patterns have become one of the most important new technologies contributing to software design and development. In this volume Mark Grand presents 41 design patterns that help you create more elegant and reusable designs. He revisits the 23 "Gang of Four" design patterns from the perspective of a Java programmer and introduces many new patterns specifically for Java. Each pattern comes with the complete Java source code and is diagrammed using UML.

See all Editorial Reviews

Product Details

• Paperback: 544 pages
• Publisher: Wiley; 21 edition (September 17, 2002)
• Language: English
• ISBN-10: 0471227293
• ISBN-13: 978-0471227298
• Product Dimensions: 9.2 x 7.5 x 1.3 inches
• Shipping Weight: 2.2 pounds (View shipping rates and policies)
• Average Customer Review: 3.0 out of 5 stars  See all reviews (63 customer reviews)
• Amazon.com Sales Rank: #660,549 in Books (See Bestsellers in Books)

  Popular in these categories: (What's this?)

  #16 in	Books > Computers & Internet > Programming > Software Design, Testing & Engineering > Software Reuse
  #78 in	Books > Computers & Internet > Programming > Software Design, Testing & Engineering > UML

Customer Reviews

Most Helpful Customer Reviews

52 of 55 people found the following review helpful:

3.0 out of 5 stars A lot of defects, but still a valuable resource, November 5, 1999

By	John Sargeant (Manchester, UK) - See all my reviews

This review is from: Patterns in Java, Volume 1, A Catalog of Reusable Design Patterns Illustrated with UML (Paperback)

There appears to be a flame war in a bookshop about this book, with everybody giving it either 1 star or 5. I believe the truth is somewhere in between.

I'm using the book as a course text for a final year undergraduate course I'm teaching which focusses on patterns. It's far from ideal, but there's nothing out there better as far as I know. There are many typos and thing which could be explained better, but I disagree with those reviewers who claim that the author doesn't understand the subject - in my opinion he clearly does. With one exception (the bizzare characterisation of Marker Interface as a fundamental design pattern) I don't believe there's anything fundamentally wrong.

I'd like to encourage those people who are complaining that it's rubbish to either write a better book, or contribute detailed comments to the author, so he can produce an improved second edition (I'll be doing the latter). It has the potential to be a very good book.

I agree with those who are saying that that volume 2 is very disappointing, but reviews of that shouldn't be contributing to the "score" of volume 1.

24 of 26 people found the following review helpful:

2.0 out of 5 stars Read only at your peril!!, July 22, 1999

By A Customer

This review is from: Patterns in Java, Volume 1, A Catalog of Reusable Design Patterns Illustrated with UML (Paperback)

Having written several Java books myself and being a self confessed design pattern addict, I was looking forward to reading this book. Unfortunately I was immensely disappointed with the content. I agree with most of the negative comments written here about both Vols 1 and 2 and only add my own voice to the crowd to ensure the weight of numbers prevails.

The big problem with this book is that it is _so_ inaccurate, both syntactically and semantically, you cannot _trust_ the content.

Some of the text is accurate: for example the description of the Visitor pattern is semantically fairly accurate although there are numerous typos and diagramming errors. However, the accompanying code is not a Visitor pattern. Since the key benefit of this book over other design pattern books is that the code is in Java, the usefulness of the book is lost.

The net effect is that the beginner will not learn design patterns correctly.

Given that a major benefit of design patterns is the common understanding of certain coding idioms, this is a very damaging book. It is like learning to play the piano the wrong way - once the damage is done to the technique it can take years of hard work to repair. You are much better off learning to play properly from the beginning. In the context of design patterns, this means reading the GoF, Siemens, and Doug Lea books.

18 of 19 people found the following review helpful:

2.0 out of 5 stars Great Idea spoiled by lack of attention to detail, November 22, 2000

By	Brandon Shuey (Olathe, KS United States) - See all my reviews

This review is from: Patterns in Java, Volume 1, A Catalog of Reusable Design Patterns Illustrated with UML (Paperback)

I was really excited for a Java-slanted version of the famous Design Patterns book. This should have been an easy home run but Grand let us down on the details. I went into this book knowing some about Patterns and was eager to learn more. However, after wasting my time hacking my way through incorrect diagrams and inconsistencies between code and text I am about ready to through the book out, learn C and read Gamma's book. I don't know who edited this book but they obviously didn't know much about UML or Code.

You want detail examples: Chapter Eight (Chain of Responsibility GoF95). A pretty simple pattern made difficult because of the incorrect UML diagram in the context (association arrows going the wrong direction), and the incorrect text conflicting with the code. I figured the pattern out by comparing it to Gamma's example, it is really quite simple.

The there are many more examples, especially frustrating on some of the more abstract patterns. Grand should have hired a better editor.

If you buy this book and know little about patterns I suggest you also get Gamma's book and refer to it often.