OOP Demystified (Paperback)

~ James Keogh (Author), Mario Giannini (Author) "How do you see the world?..." (more)
Key Phrases: tudent class, access specifier section, public void modify, String First, String Last, String Lname (more...)

Editorial Reviews

Product Description

Learn object-oriented programming in no time with help from this easy-to-understand guide, ideal for novice and expert programmers alike. Discover why objects are so successful as the model for this type of programming and how objects are classified. Distinguish between how people see the world and how computers “see” it. Learn about attributes and methods, inheritance, polymorphism, real-world and case modeling, object-oriented programming languages, and much more. Each chapter ends with a quiz, culminating in a final exam at the end of the book so you can test your knowledge.

From the Back Cover

The fast and easy way to understanding the fundamentals of OOP

Want to learn about object-oriented programming quickly and easily? Looking to brush up on modeling, classes, and attributes? Then OOP Demystified is the easy-to-understand, step-by-step guidebook that will help you figure out the ins-and-outs of object-oriented programming (OOP).

Written for anyone without formal training in the subject, OOP Demystified teaches complex OOP topics in clear, plain language—from the reasons why objects are successful as models for programming to case modeling, class diagrams, interfaces, and much more. The authors leave out unnecessary, time-consuming information to deliver the essentials you need to begin and maintain all your OOP projects.

Simple enough for a beginner, but challenging enough for an advanced student, OOP Demystified is your shortcut to mastering object-oriented programming.

This one-of-a-kind self-teaching text offers:

• An easy way to understand OOP
• A quiz at the end of each chapter
• A final exam at the end of the book
• No unnecessary technical jargon
• A time-saving approach

See all Editorial Reviews

Product Details

• Paperback: 288 pages
• Publisher: McGraw-Hill Osborne Media; 1 edition (March 8, 2004)
• Language: English
• ISBN-10: 0072253630
• ISBN-13: 978-0072253634
• Product Dimensions: 9 x 7.3 x 0.7 inches
• Shipping Weight: 1 pounds (View shipping rates and policies)
• Average Customer Review: 4.3 out of 5 stars  See all reviews (10 customer reviews)
• Amazon.com Sales Rank: #94,097 in Books (See Bestsellers in Books)

Customer Reviews

Most Helpful Customer Reviews

84 of 84 people found the following review helpful:

5.0 out of 5 stars Very good tutorial and review book on OOP..., March 28, 2004

By	Thomas Duff "Duffbert" (Portland, OR United States) - See all my reviews (TOP 50 REVIEWER)    (REAL NAME)

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.

14 of 15 people found the following review helpful:

5.0 out of 5 stars Very good OOP book - concise, clear, and brief, November 14, 2004

By	L. Raymond (Hong Kong) - See all my reviews (REAL NAME)

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.

11 of 12 people found the following review helpful:

4.0 out of 5 stars Good for beginners with some experience, April 2, 2006

By	D. Granja - See all my reviews (REAL NAME)

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.