Customer Reviews

Sams Teach Yourself Object Oriented Programming in 21 Days

5 star:		(3)
4 star:		(0)
3 star:		(0)
2 star:		(0)
1 star:		(1)

 

 

This book is a lifesaver. If you have done non-OOP development and are trying to learn Java and OOP, this book may be for you.

I find other Java books do not do enough to tie-in the big picture. Even after reading Eckel's Thinking in Java (among others), I found I was not really thinking in OO terms. I still had the procedural mindset. I have looked into other OO/Java topics for help in areas such as design patterns, UML, and unit testing, but was having trouble putting it all together. Too many books and instructor-led courses save these topics for later - after bad habits with regards to Java have emerged.

Even though it is a SAMS book, Teach Yourself OOP in 21 Days does an excellent job of bringing it all together early and often. The author wastes no time introducing the UML and patterns in a clear, easy-to-understand format. He even explains and provides code for unit testing (via JUnit).

This book does not teach Java - but it does teach you how you should think about and implement Java applications. I highly recommend it as a companion text to an "Intro to Java" course - espeically for those with previous non-OO development experience.

Sam's "Teach Yourself Object Oriented Programming" is a welcome addition to your Java arsenal. Whenever I've started a new language in the past, I would start with a Sam's book for an overview on the subject, followed by a Wrox series book to get more depth, followed by an "Unleashed" or "Professional" book.
This Sam's book is more than an overview. It teaches the full scope of OOP which is what Java is all about. If you need a solid foundation in Java, Sam's Teach Yourself OOP is the way to go.

One of the most crucial elements that any book on OOP can provide is a baseline grounding so that later in learning about object oriented programming, the reader knows what others are talking about. This book requires attention from page 1 as the author walks the reader through this complex process, not overlooking what many authors may assume to be obvious. For example, encapsulation is clarified by noting that it is synonomous with component, module or bean. Not a big deal unless you're used to using "component" as an object you can load in Flash. Interestingly, most OOP was developed before the Internet, and so often you will see other terms, like "client" used in a wholly different way than you will find in a "client-server" pair.

Being adverse to "gimmick books", I ignore the "...in 21 Days" portion of the title. The author doesn't get caught up in such cleverness by a marketing wonk. Rather, you can read it and later use it as a solid reference book. After having gone on to design patterns (which are nicely introduced in this book as well), I keep coming back to this book and finding more gems. The fact that I understand OOP much better now than when I first read this book--and have still returned to this book after going through several others attests to this book's value.

It's examples are all in Java, and I'm not a Java programmer. However, that doesn't matter, if you're learning OOP for anything from C# to ActionScript 3.0, there's much to be learned in this work.

Though not a professional programmer I have been programming for about 15 years working my way up the Basic ladder to currently Vba. I can see the benefits of OO programming as I deal with complex business problems. This book seemed a good choice and I started the 21 day journey with great optimism. Day 1 was as you would expect, very basic using very simple analogies and situations. Day 2 seemes to start at a higher level like there are some pages missing and Day 3 makes such a giant leap that I had to return to Day 1 and start again. I repeated this loop about 10 times without any success at all. I have all my life been a "Book Learner" but this one has me beat. All-in-all a total waste of money.