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

~ (Author) "The Unified Modeling Language (UML) is a notation that can use for object-oriented analysis and design..." (more)
Key Phrases: timekeeping terminal, nonterminal tokens, ectoutputstream object, Null Object, Guarded Suspension, Henry's Food Market (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

Product Description

A goldmine of timesaving Java Patterns--and how to make them work for you. The godsend for which programmers and developers have been waiting is here: a comprehensive guide to using Java and Design Patterns together. Featuring complete coverage of the patterns that can occur in any project's development, Java guru Mark Grand looks at all of the re-usable patterns already circulating in the community, introduces several new patterns, and clearly demonstrates how to write your own Java patterns in UML. Patterns in Java is a timely response to the growing emphasis on design in object-oriented projects, smoothly guiding programmers through the early, error-prone stages of development. The book also features invaluable case studies readers can follow and learn from as they do their own work and, best of all, includes over 50 different Java Patterns with examples and complete code. CD-ROM contains over 50 Design Patterns in Java.

See all Editorial Reviews

Product Details

• Paperback: 480 pages
• Publisher: John Wiley & Sons (September 28, 1998)
• Language: English
• ISBN-10: 0471258393
• ISBN-13: 978-0471258391
• Product Dimensions: 9.2 x 7.5 x 1 inches
• Shipping Weight: 1.8 pounds
• Average Customer Review: 3.0 out of 5 stars  See all reviews (63 customer reviews)
• Amazon.com Sales Rank: #1,464,753 in Books (See Bestsellers in Books)

  Popular in this category: (What's this?)

  #23 in

  Books > Computers & Internet > Programming > Software Design, Testing & Engineering > Software Reuse

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

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

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

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.