Buy new:
-42% $40.30$40.30
Delivery Monday, October 14
Ships from: Amazon.com Sold by: Amazon.com
Save with Used - Good
$11.00$11.00
Delivery Monday, October 14
Ships from: Amazon Sold by: Shop Simpler
Download the free Kindle app and start reading Kindle books instantly on your smartphone, tablet, or computer - no Kindle device required.
Read instantly on your browser with Kindle for Web.
Using your mobile phone camera - scan the code below and download the Kindle app.
Head First Object-Oriented Analysis and Design 1st Edition
Purchase options and add-ons
--Ivar Jacobson, Ivar Jacobson Consulting
"I just finished reading HF OOA&D and I loved it! The thing I liked most about this book was its focus on why we do OOA&D-to write great software!"
--Kyle Brown, Distinguished Engineer, IBM
"Hidden behind the funny pictures and crazy fonts is a serious, intelligent, extremely well-crafted presentation of OO Analysis and Design. As I read the book, I felt like I was looking over the shoulder of an expert designer who was explaining to me what issues were important at each step, and why."
--Edward Sciore, Associate Professor, Computer Science Department, Boston College
Head First Object-Oriented Analysis & Design shows you how to analyze, design, and write serious object-oriented software: software that's easy to reuse, maintain, and extend; software that doesn't hurt your head; software that lets you add new features without breaking the old ones. Inside you will learn how to:
- Use OO principles like encapsulation and delegation to build applications that are flexible
- Apply the Open-Closed Principle (OCP) and the Single Responsibility Principle (SRP) to promote reuse of your code
- Leverage the power of design patterns to solve your problems more efficiently
- Use UML, use cases, and diagrams to ensure that all stakeholders are communicating clearly to help you deliver the right software that meets everyone's needs.
By exploiting how your brain works, Head First Object-Oriented Analysis & Design compresses the time it takes to learn and retain complex information. Expect to have fun, expect to learn, expect to be writing great software consistently by the time you're finished reading this!
- ISBN-100596008678
- ISBN-13978-0596008673
- Edition1st
- PublisherO'Reilly Media
- Publication dateJanuary 2, 2007
- LanguageEnglish
- Dimensions8 x 1.38 x 9.25 inches
- Print length634 pages
Customers who bought this item also bought

Head First Software Development: A Learner's Companion to Software DevelopmentPaperback$15.66 shippingOnly 4 left in stock (more on the way).
Customer reviews
Customer Reviews, including Product Star Ratings help customers to learn more about the product and decide whether it is the right product for them.
To calculate the overall star rating and percentage breakdown by star, we don’t use a simple average. Instead, our system considers things like how recent a review is and if the reviewer bought the item on Amazon. It also analyzed reviews to verify trustworthiness.
Learn more how customers reviews work on AmazonCustomers say
Customers find the book amazing and useful. They say it makes concepts easier to understand and is an excellent resource for beginners to advanced Java developers. However, some readers feel the book is worthless and not thought-provoking. Opinions are mixed on the information density, with some finding it detailed and others saying it's low.
AI-generated from the text of customer reviews
Customers find the book amazing, useful, and easy to read from cover to cover. They say it teaches important concepts and is one of the best series they have ever come across for any language.
"This is an amazing book! Great for beginners" Read more
"...if you have the basic idea under your belt, this is one great book to work through. I plan to have this book really dog-eared when I'm done." Read more
"...This book is useful for programmers with a bit of Java (or C#) knowledge who want to get a good overview of OOA&D. This book is useful because it..." Read more
"...For what it is this is a very good book. If you are brand new to OOP then I would hold off on this one for a bit until OOP is understood...." Read more
Customers find the book easy to learn. They say it's an excellent resource for beginners to advanced Java developers, and it allows them for a fun yet comprehensive learning of the subject. Readers also appreciate the teaching style and good tips. They mention it helps them remember some concepts they have forgotten. The book is useful because it teaches important OOP vernacular and a simple holistic approach to iterative development.
"The book is "easy to read" compared to the ones' on the same topic...." Read more
"This is an amazing book! Great for beginners" Read more
"...though a bit outdated with java 1.5 or whatever, does get a lot of good points across as far as how to consider design of classes, program layout,..." Read more
"...Every step in this process is well explained and helped a lot in my daily routine as a programmer...." Read more
Customers have mixed opinions about the information density of the book. Some mention it's a good read with detailed examples, while others say it's extremely low and hard to find between all the inaccuracies and misleading information.
"...The examples were really good at helping me reach that eureka moment which is critical when learning." Read more
"...Many inaccuracies and misleading information make this book useless. Regardless of your level I would not recommend this book for anyone...." Read more
"Excellent explanation, and clear examples" Read more
"Best book on object oriented analysis EVER! And I'm old enough to know! You will be entertained and educated too." Read more
Customers find the book worthless, awful, and a terrible attempt. They also mention it's not quite as thought-provoking as some of the other Head First books.
"...this is another winner in the Head First series but it's not quite as thought provoking as some of the other Head First books...." Read more
"...Then there's all the random, worthless comments that have nothing to do with the subject...." Read more
"...of book because the idea is great in theory, but this is a terrible attempt at it." Read more
"Simply put the book has no valuable content at all. Once you get pass the Head First presentation format, which I liked before...." Read more
Reviews with images
Goofy book
-
Top reviews
Top reviews from the United States
There was a problem filtering reviews right now. Please try again later.
Head First OOA&D is a good first step for those of us that have OOP knowledge but are just beginning to learn how to architect OO software correctly. The book does sort of sit in an akward position for the target audience. On one hand this book assumes that you have OOP knowledge so it's not really for the OO beginner (the appendix covering OOP is quite shallow). On the other hand the examples in the book are extremely simplistic so those of us that do have OOP knowledge may desire a bit more out of the book. Don't let this shy you away though because like most Head First books - you will learn a good deal if your experience in OOA&D is very minimal.
I understand where this book is trying to aim. People looking into OOA&D should already have basic OOP concepts mastered. Some people tend to blur the line between OOA&D and OOP. OOA&D is Object Oriented Analysis and Design. This means you take the concepts you know from OOP and learn how to architect software by using certain techniques such as UML modeling, patterns, requirements gathering and what-not. OOP should already be understood if you are trying to create an OO architecture. In other words - You have to learn how buildings work before you learn how to draw the blue-prints and design your own building.
For what it is this is a very good book. If you are brand new to OOP then I would hold off on this one for a bit until OOP is understood. If you understand how OOP works but you don't feel confident architecting software then this is a great start even though the book may seem a bit overly simplistic at times.
One of the most fundamental things in software development is to learn how to collect requirements from clients (or your employer) and transform these into small, re-usable chunks of code.
Learning design principles presented in this book, like DRY (Don't Repeat Your Self), SRU (Single Responsibility Unit) or KISS (Keep it Simple Stupid) can help any developer program faster and more efficient.
A must read for all new developers!
You can tell that the first chapter was rushed. There are several spelling and programming mistakes. The most egregious is where they ask you to look through some code to find what "FIRST" you change and then they answer that question with a much smaller problem (the main problem was they forgot to add a return statement (pg.5) and they write about the inconsistency of using String based searching). It has also been mentioned by several reviewers of the use of the method name "matches" which only makes sense for regex not for an equals operation. I also did not like the search example (how can you not think of price in a search?). The best part of this chapter is the mantra that should be practiced by many engineers: "Make sure your software does what the customer wants it to do."
The next few chapters are definitely better (though still some spelling mistakes). They are a good read for beginners and intermediate programmers on gathering requirements, change of these requirements and analysis. The ideas are a bit simplistic though it is good to get many programmers used to the idea of UML and use cases and using them to drive requirement gathering and textual analysis. Intermediate and advanced readers familiar with use cases will gain more from reading Alistair Cockburn's "Writing Effective Use Cases" (or will already have read it) and for further UML reading should go with "UML Distilled" by Martin Fowler.
When the book gets back to design I see some problems with the coding. The designer has this bizarre idea of abstracting all properties (under the guise of "encapsulate what varies") into a Map attribute to lessen the amount of subclasses for instruments. While initially this may seem a good idea it gets rid of all type-safe coding (you can now safely assign an instrument type to a backwood for the instrument), you cannot have behavior from the instruments (this is mentioned in the book) and if you put a property with one letter misspelled or capitalized out-of-place you now have a bug, one that you might have trouble finding thereby increasing maintenance costs. Too much flexibility makes the code ambiguous.
After design, the studies get to solving really big problems, architecture, design principles, and iterating and testing. These chapters I enjoyed much more especially the chapter on design principles with the beginning mantra that "Originality is Overrated." This chapter goes over basic principles such as OCP (open-closed principle), DRY (don't repeat yourself), SRP (single responsibility principle) and LSP (Liskov Substitution Principle).
Then the book last chapter (the ooa&d lifecycle) sums the lessons in the book in one large (somewhat contrived but these type of examples always are) program for the Objectville Subway. Then two terse appendixes dealing with ten additional OOA&D topics and OO concepts should make the reader realize that this book is just an introductory sliver of what needs to be learned for a sagacious software acumen.
This book is useful for programmers with a bit of Java (or C#) knowledge who want to get a good overview of OOA&D. This book is useful because it teaches important OO vernacular and a simple holistic approach to iterative development. If the book did not have a "quickly done" feeling, better design and fewer mistakes I would have liked this book more. This book is a good candidate for a second edition. If you want a more thorough explanation of these topics I recommend "The Object Primer" by Scott Ambler as one of my favorite books for a good introduction to OOA&D.





