UML for Java Programmers

by Robert C. Martin

The Unified Modeling Language has become the industry standard for the expression of software designs. The Java programming language continues to grow in popularity as the language of choice for the... This description may be from another edition of this product.

• Format: Paperback
• Language: English
• ISBN: 0131428489
• ISBN13: 9780131428485
• Release Date: May 2003
• Publisher: Prentice Hall
• Length: 288 Pages
• Weight: 1.25 lbs.
• Dimensions: 0.7" x 7.0" x 9.1"

Customer Reviews

A breath of fresh air

Years ago I was working on a very complex project. One of the team members convinced the management that we needed CASE tools. After spending $$$ on them and countless hours learning them, we began to use them. I soon became convinced that they provided little to help the process and in the end, they nearly sunk the project. It was yet another pseudo code that did little to aid in the process of generating real code. So when UML came on the scene, knowing it's roots I was very suspicious. After looking more into it, I was pleasantly surprised by UML. I believe that most of my objections to CASE were addressed, but not all. I found that too many had simply replaced one dead weight with another. Again countless hours were spent generating documents that no one ever read or cared about. Yet UML was a valuable tool, why was this so? I shared this with my grown son who directed me to Martin's book, and it became clear that a valuable tool was simply being misused. It is obvious that Martin has been in the real world and knows when to use a tool like UML, how much to use it, and what it is best suited for. Rather than throwing the baby out with the bath water as I was tempted to do, Martin points out that UML is a good communication tool best used at a white board with a small team. Once everyone is on the same page, the team can proceed as a team. Martin doesn't over burden you with a lot of useless diagrams. He poses a problem, shows how UML addresses a design issue, and shows you the resultant design change. I subscribe to many of the XP techniques because I have used them and found them useful with the exception of pair programming which I did for a while and found it to reduce the productivity to the lowest common denominator between the pair. I highly recommend this book.

An excellent teaching tool!

Unlike a number of other UML books, this one is not only well-written, but interesting to read and it will make you a better programmer in addition to teaching you basic UML. The book doesn't cover UML in a void, as most do, but rather explains how, when, and why to use modeling, and probably better, when NOT to use it. The author understands that the models are simply descriptions of the code to make the code more understandable, and that models that do not do this are useless.The topic of UML is not covered completely, but the level of coverage is appropriate to the subject matter. I particularly liked how the author showed that models can be used to identify bad code, and discussed some basic OOAD principles. The author also advocates a modified XP approach to design, and while my shop is not XP-based, there is a lot of good information that is not dependent on an XP approach.This book will never be far from my desk so I can refer to it again and again.

The Only UML Book You'll Ever Need

Before you start rolling your eyes over yet another UML book, buy this gem and give it a serious read. It's like no other UML book I've read. It's also the only UML book I'll ever need. For starters, it's far too enjoyable a read to be lumped in with other crusty UML books. More importantly, it's Uncle Bob's no-nonsense, practical approach that sets this book apart. He's not afraid to tell you when some UML diagram or adornment is more trouble than it's worth. Indeed, throughout the book he puts the use of UML in its rightful place. Indeed, I wish this book had been around about 10 years ago, before we somehow got it into our heads that the models were the software.After putting UML in its place, Bob teaches you how to wield it as a tool to assess the quality of a design using sound object-oriented design principles. Bob is a programmer's programmer, so everything he does is backed up with code. It's all great stuff you can start applying immediately.We don't need yet another UML book, but we do need a book that teaches us how to use models to our advantage. This book definitely hits that mark!

Best introduction to UML, especially if you use Java

This is a great book for learning or improving with UML. Topics are introduced at a level appropriate for beginners but each topic progresses at a nice pace into intermediate territory. There's even advice in here suitable for the best programmers I know. I love the liberal use of source code throughout this book. We model in order to write code and Bob Martin clearly presents that perspective in this book. If code is the goal then it is worthwhile understanding the relationship between our models and our code. While all of the example code is in Java I'd still recommend this book to anyone who wants to learn more about modeling and who has even a passing familiarity with Java. C++ or other programmers should have no problem reading it, for example.I like that the author goes beyond just describing each of the UML diagrams and takes the opportunity to teach good design while he's at it. As just one example, the "Single Responsibility Principle (SRP)" is discussed. This principle tells us that "a class should have only one reason to change." In other words, don't put everything into one class. That's pretty obvious but it's still a common mistake. The book shows a brief snippet of Java code that violates this principle and then shows the UML for how to design it better. More importantly, we're told how to recognize this problem in UML diagrams we create or inherit.This book addresses one of the big problems I've had with many other UML books--it tells the reader right upfront that not all diagrams are equally important. I love that the author tells us things like that "in the last decade I think I have drawn less than a dozen object diagrams of this kind." That's great to know! Because many other books try to cover every diagram and modeling technique they all end up appearing equally important. In this book Bob Martin tells us that he's only going to cover what we really need to know to be better Java programmers. He achieves that goal with flying colors.

Outstanding UML and OO Design Essentials Primer

This book is a gold mine of insights into what is essential about OO design, UML notation, and their relationship to writing sound code. The book's focus is on how to create and understand essential UML design artifacts and fundamental OO design concepts to help you write better code. As the book proceeds, excellent examples are provided to ensure that the reader understands the crucial aspects of transforming code to UML and vice versa. UML's role in the development process is put in proper perspective as a tool rather than an end in itself. All the standard UML artifacts are covered: Class Collaboration, Sequence, and Object Diagrams, as well as Finite State Machines (the author isn't a big fan of Use Cases but they're briefly covered too). Moreover, the book includes excellent chapters on sound OO design principles for not only class hierarchies but also package and component building as well. A terrific synopsis of the author's take on an agile development methodology is presented and there are some meaty case studies against which one can try out his/her newly gained knowledge of the topics covered. If you want to learn solid OO design concepts and how to reliably and accurately represent them in UML then this book is for you. I'd also recommend the author's other recent book, Agile Software Development Principles, Patterns, and Practices which won a Software Development Magazine Jolt award.