Java Design: Building Better Apps and Applets [With *]

by Peter Coad and Peter Coad

This guide offers advice on how to design Java client/server apps for maximum efficiency and reliability. The authors review object models, scenario views, multithreading, concurrency and exceptions.... This description may be from another edition of this product.

• Format: Paperback
• Language: English
• ISBN: 0139111816
• ISBN13: 9780139111815
• Release Date: January 1998
• Publisher: Prentice Hall PTR
• Length: 352 Pages
• Weight: 1.54 lbs.
• Dimensions: 0.9" x 7.0" x 9.2"

Customer Reviews

Don't miss the point!

Ok, there seems to be some serious inconsistensies between one reviewer and the next. Some say this book is one-star trash, others say it's a five star gem. Weird, eh? I needed some serious design guidance at my first real work (not in school-class anymore with a teacher nearby). At first I decided not to buy this book because of some of the bad reviews. I bought couple of other books and got nowhere. Now I read this book too and wham was I surprised! This book is excellent. I find it very obvious now that the persons who gave this book bad reviews were either not good/experienced programmers at all, thus they didn't notice the actual points the authors were trying to convey at times, or the readers just plain read this book too fast with too little thought. It is easy to read this book without actually thinking, because the book does not look very dry or academic. It lacks the "aura of seriousness" just like the author's other book on Color UML, which some people mistakenly dismiss as somewhat of a childrens' book. This book is NOT about inheritance. It is NOT about interfaces. It is NOT about notification. Nor about threads. Many people thought it was and, of course they already knew those aspects from any basic Java book. This book is about DESIGNING a program using those features. Every chapter cuts the aspects you have to consider about the topic, into a handful of clear guidelines. Every chapter summarizes listing those guidelines at the end of the chapter. If you make the mistake of just reading through, "Aha, yeah, of course... nice, seems smart..." you don't really learn to use them. When you have read this book, go back to design your software. Now, at every step go through all the chapter summaries an APPLY all the guidelines to every design step you make. Then you'll slowly begin to learn. It will feel as if a lightbulb was lit inside your head. "Oh, THIS is how it's done!" After some experience, you only need this book occasionally, after making the guideline design steps into routine habits. Your code will reflect this by being clear and very professional quality. Also, someone complained that only some of the UML notation was used. This is again NOT a book on UML. It is a book on the design process/steps that Coad & Co feel are important. Nobody uses every aspect of UML. It is just too huge a notation language. You need to learn a subset that fits YOUR purposes. Some prefer the "Use Case Driven" approach, some "Feature Driven", and so on.

A Must Have Book on OO Design

Java Design: Building Better Apps and Applets is much improved when compared to its first edition. The topics discussed do indeed allow you to build better applications and applets. While Java-centric, these design issues are relevant no matter what language you use.Each section provides invaluable strategies and guidelines for evaluating your designs and more importantly - it provides suggestions to evaluate which areas in your design are worth spending that additional design time on. The guidelines and strategies alone make this book a must have for any programmer.I criticized the first edition because the book didn't flow as well and was a little hard to read. In its second edition the book is a very easy read and the information is nicely presented. All diagrams now use UML.Buy this.

Extend'ing laid to rest

The OO Programmers obsession with "extending" every class is finally laid to rest with this excellent book, and the case for "composition" strongly presented. Whilst the C++ jury may be out, Java programmers can get on with it. Easy to read and full of real-world examples this is the best design, object-orientated book I have come across. Anyone can learn the syntax and structure of a language but it's how the code is put together that determines the quality of the finished product. Just like you wouldn't let a builder start constructing your new home without a plan and design, you shouldn't do the same with your Java development. When you purchase Peter Coad book you also get added value. Visit his web site and you can subscribe to a twice weekly newsletter, get addendum's and new chapters to the book, a free Java Design Tool. Yes of course he wants you purchase courses, software and his next book but it does feel that he really wants you to be "Building Better Apps & Applets".

Excellent for "legacy gray beard" learning Java/OO Design

First things first. I originally read this book many months ago, and I have revisited it many times since. The book remains prominant on my book shelf. At that time, what were my expectations for this book ? I was not an OO application programmer/developer who viewed the world through OO design patterns. I was a "gray beard" systems integrator who was developing an in-depth understanding of "distributed object application server" integration issues with legacy systems. Java was/remains my context in which to master OOA/OOD and coding without the hassles of the C++ environment, but with the benefits of "free" Java IDEs downloadable from the WEB (I especially like the VisualAge Java IDE).Along with many other books (for example Design Patterns from the 'Gang of Four'), hours of studying and practical coding, I found this book very, very helpful. Since all the other design books were C++/Smalltalk oriented, a Java design book was readily appreciated. Of course, with experience, interpreting C++ code snipets to Java is not very difficult, but at the time I read this book the Java examples were very helpful. Some of the (now in retrospect very basic concepts) clear explanations of "what I know, who I know, etc.", were invaluable.The book's style is different; somewhat refreshing actually.I would prefer the book to be entirely on the CD so I could travel with it and use it for reference on occasion. Before I got Rose, the included software for working with designs was also very helpful.I look forward to follow on work .... but more advanced this time .... this book has made its contribution.Thanks again for a very helpful text.

How to USE Java for good design

To be a good Java programmer, you need to be a good object oriented programmer. And you need to understand the way the building materials of a language like Java shape application design. Peter Coad does. He's an object-oriented programming guru, whose firm, Object International (www.oi.com), has been engaged in many o-o projects in many industries. He brings a wealth of experience to an analysis of Java from a software designer's standpoint. He knows how messy, brittle, and ugly design starts, and he shows us how to use Java to nip it in the bud. He identifies some basic patterns that maximize clean, flexible, reusable design. He stresses the use of composition over inheritance. Coad is not big on inheritance: he's seen it misused a lot, and he sets forth clear and limiting criteria for its use. He shows good Java-based ways to compose objects with other objects, preserving encapsulation and expanding flexibility. He also shows intelligent strategies for using interfaces. In my own current Java projects, Coad's book made a lot of design issues clearer. It's sent me back to the drawing board, but with a much more well-rounded design sensibility. This is an excellent book for a beginning object-oriented programmer, starting out with Java. It makes clear the appropriate use of interfaces, and points out the pitfalls of multiple inheritance and a number of other practices. His book comes with a CD-ROM of Playground, Coad's general o-o design tool. His Strategies and Patterns Handbook is also on the CD-ROM, with 177 strategies and 31 object model patterns in .hlp format. This book is based on JDK 1.0.2. I'm curious about what his take will be on JDK 1.1, especially Java Beans. I think the observations in this book apply to 1.1, but might bear extension in that environment. I strongly recommend this book. Anyone who has learned Java's basics, but wants to know how to put them together to do good design, should buy it.