Customer Reviews

OOP Demystified

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

 

 

Target Audience
Developers who need an introduction to or a review of object-oriented programming.

Contents
This is an easily digestible tutorial on object-oriented programming (OOP) that can be used as an introductory or review text.

The book is divided into the following chapters:

A Look At How We See The World; What Is a Class?; Encapsulation; Methods and Polymorphism; Inheritance; Abstraction; Identifying and Describing Objects; Real-World Modeling; Collaboration; Case Modeling; Interfaces; Object-Oriented Programming Languages; Final Exam; Answers to Quizzes and Final Exam; Classes In Java; Classes In C++; Class Definitions In C#; Index

Review
My career as a programmer started in the world of Cobol. Because of that experience, I tend to think of programming in terms of procedural coding. When I got ready to make the jump to Java and object-oriented programming (OOP), I had a difficult time getting my mind wrapped around OOP concepts. The explanations of "an object is like an airplane" didn't cut it for me, because an airplane wasn't code. I needed something that explained the concepts from a coding perspective without trying to teach you a language at the same time. I would have done much better had OOP Demystified been around back then.

OOP Demystified is an approachable tutorial on OOP concepts for someone who doesn't come from that type of programming background. Each chapter explains a concept, shows examples from a Java and C-style coding viewpoint, and then ends with a test so that you can see if you've absorbed the material. If you've never seen Java or C code, the examples might be a little confusing, but not so much that you'd lose track of what's being discussed. The tone is conversational, so the barriers to learning are lowered.

An additional benefit to this book over earlier attempts is that the authors include Unified Modeling Language (UML) concepts as the book progresses. UML is the standard way of diagramming OOP systems, and programmers need to understand the basic methodology. While not a "teach yourself UML" course, the reader will pick up enough information to be able to work in that environment. The material will also allow you to move on to a more focused UML tutorial with little effort.

Even if you're not a complete novice to OOP, you will still benefit from having this book on your shelf. If you're like me and still have to think through the concepts on a regular basis, this volume will provide you with a quick refresher on the basic concepts that you can quickly review as needed. That's where my copy of this book will get most of its use.

Conclusion
If you're getting ready to dive into the world of Java or C#/C++ and you don't have a background in OOP, this will give you a good foundation of the concepts you'll need. And if OOP isn't your primary background, you'll appreciate it as a refresher guide in order to cement specific concepts.

I especially like reading Ch 8 -- Real-World Modeling. Not like all OOP books I read so far that the author will 'hard-sell' OOP as the best approach and by far better than procedural languages by simply demonistrating a small function and small application as to convince the readers.

The author in this book is so honest to point out the SKILLS needed to apply the OOP theory into a [workable and useful] BUSINESS application, and the difficulties the developers will surely encounter in REALITY when using OOP. This is helpful if business organization are thinking of using OOP as their solution rather than the 'already proven sounding' procedural languages and relational database in the business environment.

Although not perfect, this book will meet the needs of its audience, which is beginning programmers who are unclear about what object oriented programming (OOP) terminology means. He does a darn good job of explaining why everything fits together.

The book is a casual, mostly narrative overview of core OOP concepts: objects, encapsulation, polymorphism, inheritance, abstraction, interfaces, etc. It keeps the programming samples brief. I liked this - many other books require you to buy into an extended application developed over multiple chapters, which I as a reader usually have no interest in. The code samples are almost entirely in C++ and Java, although there is some discussion and examples in C# toward the end of the book (some of that info is outdated, but that is irrelevant to the goals of the book).

Each chapter is relatively self-contained, there is very little requirement to go back to previous chapters. This is a good intention but in practice the amount of repetition was truly annoying. Perhaps if you were to come back to this in the future as a reference it would be helpful, but on first reading it was tough to wade through it over and over again.

The code samples are to-the-point and free of distracting shows of prowess. The only problem I have with them is that there is no errata on the net that I could find (with so little code there are few mistakes, but even a small one can throw a beginner), and he sometimes throws in little unexplained extras which are not really discussed. There is pretty much an unwritten rule that you don't do that in teaching books, especially one targeted at beginners. Also, although you can understand his explanations (assuming you've already been introduced to OOP elsewhere), there can be ambiguity at times, which is frustrating. It's one of those things where if you already know what he's talking about then it makes sense, which again highlights that you do need at least a little OOP exposure before using this book.

The author definitely deserves kudos for adding a number of chapters discussing the art and practice of OOP, and about designing from an OOP perspective. It is a quick surface overview, but will be very much appreciated by beginners. Also, he does well in answering some common questions his audience may have (e.g., Is main() a class?). With a little work, this could have been a definitive introductory book for beginners, but even as is it will be appreciated and is worth reading if you're in its target audience.

Finally, here's my test for whether a book gives a good explanation of OOP: When explaining interfaces, if the author says, "An interface is a contract", then the author fails. However, this author avoids clichés and actually does explain interfaces, and passes with flying colors.

OOP demystified along with The object-oriented thought process are mandatory to start with oop. Not boring, with clear examples. The final part comparing java, c++, c# is really nice so you can get a basic idea on the main diffences between these famous languages.

As a beginning programmer, I've been devouring books on programming geared toward people that are just starting out. I bought this book because I thought it would be wise to have a solid understanding of Object Oriented Programming in general before trying to dive into other programming things. While I was able to get what i needed form the book, I do have several complaints.

The first is that one the front cover of the book it clearly states "No formal training in OOP needed!" This is blatantly misleading, and the authors of the books FREQUENTLY say things like "you should recall from your programming course" or "you'll remember this from your C++ programming course" etc. This is annoying, because someone who had taken multiple programming courses probably wouldn't need to be reading this book; I'd assume someone who had taken multiple programming courses would already understand OOP. I believe a lot of people who bought this book and gave it 5 stars were already programmers who bought this book just to read for the heck of it (I've noticed that programmers have a habit of reading as many programming books as they can whether they already know the subject or not). That's fine, but a lot of people who buy this book are beginners and although the book is still understandable and doesn't really require any prior knowledge in programming, it's annoying to buy a book that literally says "no formal training needed" and then tells you that you should remember things from programming classes. One thing that is a problem with this, however, is that occasionally the author includes a lengthy code example without really explaining it since we as the readers are supposed to "recall from our programming courses."

The second big annoyance that I had with this book is also fairly minor and doesn't cause any serious problems to someone trying to learn. That is that this books frequently jumps back and forth between C++ and Java terms. At the beginning of the book, it explicitly states that when referring to a method/function it will use the term "method" (the Java way to say it) instead of the term "function" (the C++ way to say it). This is untrue, and the author(s) repeatedly and totally randomly jump back and forth between terms. They're synonymous, but it's still confusing for a beginner that the authors are simultaneously presenting two programming languages and then mixing the terms even after they claimed that they wouldn't. The mixing gets so bad that at some points Java and C++ terms are mixed even in the same sentence. Again, this is not a huge problem, but it's annoying, confusing for a beginner, and frankly just plain unprofessional. The authors are professional programmers with decades of experience; they should be able to show some consistency and use the proper terms.

The third complaint I have is another claim made on the front cover.. "Concise and thorough with minimal technical jargon." While I admit that it's concise and thorough, it makes no attempt whatsoever to spare the reader from technical jargon. While I understand this, as it's impossible to teach programming without introducing programming 'jargon,' it shouldn't have been claimed on the front cover that technical jargon is kept to a minimal when it's just not. I'd also like to point out that the author occasionally tries to use metaphors to explain something and they're bad. Just bad. I'd rather have taken it straight and just skipped the metaphor. Also frustrating is that throughout the entire book, the only example used in any code is demonstrating the process of a student registering. Not a big deal, but I was sick of it by the end of the book.

To conclude this lengthy review which I sit here and write in the middle of the night due to insomnia, I'll say that I gave this book three stars, BECAUSE:

Pros:

* Unlike my review, this book is short yet thorough. Only about 300, but lays the foundation of what you'll need to know to jump into OOP in real life.
* The quizzes/final exam are a nice touch and do help the reader to remember. The final is troublingly long (100 questions), but if you can answer them all, you're set to dive into OOP head first.

Cons:
* "No formal training in OOP" claim made on cover, yet statements like "you should remember from your programming course" are frequently used. Prior knowledge in programming is not required, but it is assumed.
* Severe lack of consistency in terms used throughout the entire book. Author(s) constantly switch back and forth between Java and C++ terms.
* Does not have "minimal technical jargon" as claimed.
* Boring and uses the same example throughout the entire book to illustrate all concepts.

If you don't even know what OOP stands for then get this book! By the end of this book you will have a pretty good grasp on objects and inheritance and polymorphism and encapsulation! If you don't know C++ at all though I'd recommend reading the C++ Demystified book right before you read this one.

For someone leaving the world of procedural programming, and getting into project management of an object oriented project, this was just what I needed. The syntax details are not prevelant -- look for that in another source. This book was mostly concept, including the basics, the differences from procedural programming, and common bugs and how to avoid them. It also advised common-sense, real world solutions in cases where OOP results in unneccessarily complex structure.

Very impressed with this book! It teaches a newbie programmer how to think in terms of objects, but beware, this is not for experts, beginner to intermediate will suit this book. The examples are fantastic, the only reason i'm giving this 4 instead of 5 stars is that the examples are written in java and other language, not vb.net. :)

I agree with S.LAMBROU, you should read the object-oriented thought process book together with this book if you are keen on gaining more knowledge with OOP, I'm now reading it and loving it so far!

This book was a great addition to my programming library. I bought the book to learn the concepts of Object-Oriented Programming (OOP) and this book makes it clear and concise. Many other books on OOP try to oversell you on why rather than how to code it. This book is good at `how' and shows many coding examples in C++ and Java. It even has some C# in it.

You'll learn all about polymorphism, interfaces, abstraction and much more. If you're having trouble understanding OOP in your Java or C++ text book, get "OOP DeMYSTiFieD."

This book intends to provide a simple description of object oriented programming, but in my opinion, it fails miserably. The author makes analogies, but doesn't go beyond that in any useful fashion. He spends a lot of unnecessary energy repeating himself along the lines of "objects are like cookies, and object classes are like cookie cutters." Not trying to be harsh, but this book is just terrible. Skip it and go directly to "Object-Oriented Thought Process" by Matt Weisfeld, which explains OOP nicely whether you have programming experience or not.