Product Description

Beginning Object-Oriented Programming with Visual Basic .NET 2.0 is a comprehensive resource of correct coding procedures. Author Dan Clark takes you through all the stages of a programming project, including analysis, modeling, and development, all using object-oriented programming techniques and VB .NET.

Customer Reviews (6)

Highly Recommend this vb.net oop book
If you are not real OOP developer, you have to read this book.
The author explains many oop knowledge clearly and easily to understand.
This is the only book that really combine oop theory and ve.net. The important thing is you can understand it and you can do it.
I try to contact the aurhor to know the next step book what I need to read.

A gem!
I thought the first 4 chapters were boring, but in fact the idea was to build your skill before you code the application! This book was written in a way that readers should already be familiar with OOP terminologies because it does not go into detailed explanation like those for dummies books do.Instead, it shows you how to analyze a problem, draw the diagrams and design the application! This is so far the best book i've read about object-oriented programming using VB, toppling Deb Kurata's or Alistaire Mcmonnies' books on my list. This book will teach you how to do UML/USE CASE so you can design a robust application. This is not a beginner's book on object oriented VB. I've had some knowledge in Java object programming and I know a little of object programming, but reading this book the first time has confused me as the author seemed to have tried to squeeze the discussions in short chapters and programming codes are not explained well, delving right into OOP design and techniques. As the author mentioned in the book, he doesn't know the skill level of a 'beginner', so he added some short intro to programming at the back of the book (Appendix A), so I believe the audience of this book are those 'beginners' to OOP but not to programming. I applaud Dan Clark for the way he laid out the teaching concept of this book, and how I wish he would follow this up with an advanced book with lots of case studies and applications starting from analysis to coding again. Highly recommended!

Book in very good condition
This book is in very good condition.Shipping very fast.Overall I'm very satisfied with my purchase.

I thought I got the shaft, but then discovered the gold.
I performed some programming in Visual Basic 6 a few years ago and then my job was changed so that I was maintaining a Unix program for a few years, which entailed putting fires out each day and very little programming of any type.A few months ago I was fortunate enough to get transferred to a great job programming web sites and some Windows applications. I've been able to write some fairly complex programs, but I knew I was missing some large piece of the puzzle. I'm really a novice programmer.I wasn't creating classes and I wasn't doing a lot of things that were efficient.If my programs needed to do more or scale, they were very difficult to adjust.During these months I've purchased a lot of books, and they had good stuff in them, but I still wasn't able to put things together.I would see things like "WithEvents" and ask what was that for.I had to do some threading and succeeded, but only by trial and error and I didn't understand the "why" of why it worked. For that matter, there was a lot that I didn't understand the "why" about.

I then thought that, even though I was using objects, that I didn't really understand object-orientated programming enough.I looked on some User Group sites and saw this book listed as a good one.

I held high hopes for this book. It's my first book from Apress.I started reading the first 4 chapters, which were on how to design and plan an OOP program.I'm convinced his information is important but ugh!It was horribly boring!I was mostly through the 2nd chapter when I thought I'd committ suicide .I had to quit reading chapters 2-4 and tell myself I'll get back to that later.Yes, it's that boring.It's worse than hearing your girlfriend talk for hours about makeup and dresses!So I skipped to Chapter 5 which gave basic instructions on using Visual Studio.I thought, "Why put this beginner's crap in this book".If you need to know the basics of VS, then get a beginner's book on VS. It shouldn't have been here.
By this time I'm thinking I bought a book of garbage.But I went on to Chapter 6, and I'm glad I did.It finally got to the point and started talking about OOP and classes, constructors, overloading - and I was getting some of the elusive "why" explained!Chapter 7 got into inheritance, derived classes, overriding and overloading, etc with more of the "why".Chapter 8 got into the stuff like "WithEvents" and delegates, and how delegates work with threading.You will need to use threading and you will see "why".In geekspeak, threading is cool!Chapter 9 shows how to work with Collections (arrays, dictionaries, etc).This chapter didn't explain much "why" but when I need Collections there is enough to be able to implement them. Chapter 10 starts explaining some "why" regarding databases, such as connected versus disconnected data access.The examples use SQL Server.Chapter 11 looks at forms in a different light from other books, looking at them as objects instead of just sticking controls on them, and works with using databases more.

Now I feel better about going back to the first 4 boring chapters as I will now have something to build with.

To a complete beginner, I would say to first get a basic VB.NET beginner's book and get familair with VB and Visual Studio. If this is your very first book you will be very lost.The book is made for a novice.

This book is one of the most important I have read.I am making progress very quickly over the last week or two, while previously I sputtered for several months.I've tried to convey how I felt, and if you feel similar, you must get this book.

Not exactly Like the title says
I have to admit, has some interesting stuff and information on how to make the theory of Classes to Programs, but I can not agree that is novice to professional, in my opinion I would say just novice.

Leaves many un-answered questions.

But can work as a reference. ... Read more

Product Description
B> In An Introduction to Object-Oriented Programming, Timothy Budd provides a language-independent presentation of object-oriented principles, such as objects, methods, inheritance (including multiple inheritance) and polymorphism. Examples are drawn from several different languages, including (among others) C++, C#, Java, CLOS, Delphi, Eiffel, Objective-C and Smalltalk. By examining many languages, the reader is better able to appreciate the general principles that lie beyond the syntax of the individual languages.This new edition presents examples drawn from a wider range of languages, including Eiffel, CLOS, and Python in addition to the mainstream languages, as well as extensive comparisons between C++, C# and Java. Case studies explore the application of polymorphism in the STL in C++ and the AWT in Java. UML notation and diagrams are integrated and utilized throughout. The book also features advanced sections on design patterns, reflection and introspection, network programming, and the implementation of object-oriented languages.This book is appropriate for programmers looking to read about the theory behind and functionality of a variety of object-oriented programming languages. It is also useful as a reference./*@ISBN = 0-201-76031-2@MAINCAT = Object Technologies@DATALINE1 = 2002, 450 pges, 6 3/8 x 9 1/4 @DATALINE2 = Cloth, $45.00k*/Amazon.com Review
This slender volume provides a great first taste of object-oriented concepts such as encapsulation and inheritance. AnIntroduction to Object-Oriented Programming explains all the keytechnical concepts and goes on to explore the "whys" ofprogramming, such as why a program that one programmer could write intwo months probably couldn't be written by two programmers in onemonth. The reason? Complexity.

As a textbook, An Introduction toObject-Oriented Programming does what you would expect--itexplains all the key object-orientation concepts clearly andunderstandably. This book then goes beyond the basics to show why theobject concept is strong in terms of design and economics, allowingreaders to grasp more than just the technical aspects of thesubject. Because examples are in C++, SmallTalk, Objective C, andObject Pascal, this book works well if you're trying to learn objectorientation generally, without focusing too much on the mechanics of aparticular language. An added attraction is that this book has beenrecently revised to include some Java information, helping readers tosee how object orientation works on the cutting edge as well as inmore established languages. This book is useful if you have someexperience in programming, but want to expand your knowledge intoobject orientation by way of clear examples and technical butfar-reaching prose. ... Read more

Customer Reviews (15)

Great Introduction to OOP
I've read a number of introductions to object-oriented design and programming. This one is the best all-around introduction that I have seen. It starts in the real world, with a discussion of how one plans and organizes a task (sending flowers to a significant other) that requires more than a single person to get done. That's a pleasant change from texts that begin with Dauntingly Dry Definitions ("encapsulation", "inheritance", and my favorite, "polymorphism").

To the author's credit, he avoids launching into inheritance until Chapter 8, by which time he has laid enough groundwork to reduce the concept to common sense. Other concepts are presented in a similar manner.

Note that this book is a survey book, not an in-depth programming manual. You won't learn C++ or Delphi, or any of the other half-dozen languages used for the book's examples. And the book focuses on concepts, rather than implementation. you won't learn how to implement a Singleton pattern in C#, although you will learn what it is and why it is useful. Finally, the book assumes familiarity with traditional, procedural programming. This is not a Programming 101 text.

I would recommend this book enthusiastically as a starting point for anyone making the transition from traditional programming to OOP. If you are moving to the DotNet platform, I have created a list ("So you'd like to ... Transition to DotNet") with some other recommended texts.

Sets the proper foundation
I've been using classes more as a means of organizing and improving the maintainability, understanding of various applications I've built over the past 3 years (VB). As I am about to develop solutions using the .NET platform (C#, VB.NET), I thought it would do me good to formalize my understanding of OOP/OOD. After reading this text (3rd Edition), I not only formalized my understanding, but was able to see OOP as clearly as I could structured programming (Code Complete). In my opinion, all should use this as the first book before trying to participate/apply J2EE or Microsoft.NET as it will allow you "properly" communicate, design and code systems from abstraction to detail.

Great as a first book on object-oriented programming
I really enjoyed this book. The author covers all the important oo concepts in several languages. This allows you to get an excellent perspective on each concept without being distracted by each language's implemention of that concept. I also appreciated the writing skills of the author. He was always clear and precise. A lot of information is packed into a relatively slim volume. Of several introductory oo books I've recently read, this one easily tops my list.

It's a very good book, but...
I had a great opportunity to know the author of this book in person: I took Dr.Budd's course on Object-oriented programming in Oregon State University in Fall 2000. We used this book in class throughout the term, and thus all of us were compelled to read this book from cover to cover.

The principal point I would like to emphasize is that the book really is about the Object-Oriented Concepts. It is not a "guide how to aply OO-principles in C++", it is not an "Object Pascal OO-programming". No. The book is about general concepts of Object-oriented Programming not bounded to any particular OO-language. Although sometimes it was really difficult to understand some of the ideas, the good point was that the author did not try to make the things simpler. If something was difficult to understand - this only meant that it was that Real Blue Thing whose perception makes you a cool programmer.

However, the illustrations in the book (at least in the edition I obtained) were not very good, but rather poor. Had they been made by a profeccional designer, I would have rated the book with 5 stars. So far, it's only 4.

Not so simple !
This text book is one of the worst text book I have been forced to read. Having to read this text book as part of the University requirement, I found it very confusing, especially when explaining any concept. In short, there is was no simple straight forward explanation of any topic. The book is filled with complicated sentences through out. Some times you would read a bunch of paragraphs under each topic/section and would still be wondering , which part actually talks about the topic.... I would never recommend this to any one who is new in learning OO or to anyone is already buried in Structured Programming and trying to make a transition to OO. ... Read more

Product Description
Designed for those new to programming, Object-Oriented Programming in Java provides step-by-step lessons that cover OOP (object-oriented programming) and the Java language comprehensively with clear examples, code and figures. You'll use Java's built-in-objects to create applets. Design your own classes and assemble them into sophisticated, complete programs that run inside an HTML browser or as stand-alone applications. Create objects using the simple ideas of sequence, selection and iteration. You'll delve into Java's Abstract Window Toolkit (AWT) to create full-color, multimedia Java applets, components and containers. Explore Java's versatile input/output streams and utility classes. ... Read more

Customer Reviews (19)

Stay away from this book
Too much junk and the way this book is organized makes it not easy to understand. I agree with a previous reviewer that this books it too wordy and boring.
For a book on java, I'd recommend "Java in 21 days" and "Thinking in Java".

Wordy and Boring!
I agree with one of the reviewers who wrote that the book is wordy and it does not worth over [money].Only one-third of the book is educational, the rest is junk. The author wants to be funny and all that does is to make me irritated at all the jokes and the pizza and the elephant stories. If I want to learn how to do something, I'll look to the instructions in a manual, not some "comic book want-to-be". I would not recommend this book to anyone.

The BEST Book to Start JAVA
I realized that readers form their personal opinion about a book based on how well it met their expectation. That is quite unfair to the book itself because it may never start out to meet everybody's needs.

OOP in Java certainly did not set out to do that. It claims to be a book for those without any prior programming experience and teaches OOP from the ground up. If we solely rate this book based on what it promises, then it not only lives up to it, but far surpasses its claims. It teaches you Java programming not by dumping a lot of facts, figures and explanation but in using generous amount of examples.

Before you see another keyword or concept, you would have already mastered the necessary ones to get you ahead. Unlike the other programming books, this goes down to your level (occasionally, it goes too low). But the BEST is that it follows the maxim that programmers are first human and second programmers. Thus teaching you programming not in a vacuum, but relating the whole learning experience to a simulated business company wishing to set up a store. Therefore, you'll not only understand how a concept is, but WHY it is being used in this manner.

The only short-coming of this book is that it contains many "real-world" situation that you need to read through before being introduced to the programming, something which I find a little irritating.

But if you are new to programming and want to get stated with Java. THIS IS THE BOOK FOR YOU.

BUY THIS BOOK; TRASH ALL OTHERS.
Let's set the stage: I have read "Java in 21 Days". Results: shouldn't have spent 21 minutes. And: "Java and Object-Orientation, (John Hunt); Results, It's nothing but Jargon, "another worthless Academic. It reminds me of the time that Ben Barber (The Whalt Whitman Chair at Rutgers University in New Jersey) said to me on day after class that he was too busy to talk to me because he had a call from the (Clinton) WhiteHouse. Yea, right Ben You Liar. I Have read Eckels Stuff, too, it's Junk. BUT......This book is the book that will allow you to throw those bloated academics in the trash and get to understanding and writting some great Java code. I suggest that you buy any book that has the namesStephen Gilbert and Bill McCarty in the Author'e credits. Actually, I think I will form a foundation that demands that these two authors write for us--future programmers-- the next instalment of "Advanced Java" by Gilbert and McCarty

A good conceptual start
The book is a good conceptual start for Java 1.1. It is also a good bookon OOD. However, since no revision of the book is being done, it is losingvalue. In fact with passage of time, the usefulness of this book (or anyother programming language book) is bound to depreciate.

The concept ofdesign patterns is not discussed in this book, which simply cannot beavoided in any book dealing with OOD (except such references as 'accessor'or 'mutator').

Reference to a modeling language (preferably, UML) wouldappreciate the usefulness, which is my personal opinion.

I wish a groupof person take this book as an ongoing project and do the necessary thingsthat would bring it to 6*! ... Read more

Product Description

Sams Teach Yourself Object Oriented Programming in 21 Days differs from other OOP books in two main ways. Many classic OOP books are designed for software engineers and teach at an academic level. Sams Teach Yourself Object Oriented Programming in 21 Days presents accessible, user-friendly lessons designed with the beginning programmer in mind. Other OOP books work to present both OOP and to teach a programming language (for example: Object-Oriented Programming in C++). Although Sams Teach Yourself Object Oriented Programming in 21 Days uses Java to present the examples, the book is designed to present concepts that apply to any OOP environment. ... Read more

Customer Reviews (4)

Sams Teach Yourself Object Oriented Programming in 21 Days
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.

One for your library
One of the most crucial elements that any book on OOP canprovide 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.

Great for us programmer-dinosaurs
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.

It's a welcome addition
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. ... Read more

Product Description
An Introduction to Object-Oriented Programming with Java takes a full-immersion approach to object-oriented programming.Proper object-oriented design practices are emphasized throughout the book.Students learn how to use the standard classes first, then learn to design their own classes.

Wu uses a gentler approach to teaching students how to design their own classes, separating the coverage into two chapters.GUI coverage is also located independently in the back of the book and can be covered if desired.

Wu also features a robust set of instructors' materials including PowerPoint slides, code samples, and quiz questions. ... Read more

Product Description

Introduction to Programming with Greenfoot: Object-Oriented Programming in Java with games and Simulations is ideal for introductory courses in Java Programming or Introduction to Computer Science.

The only textbook to teach Java programming using Greenfoot—this is “Serious Fun.”

Programming doesn’t have to be dry and boring. This book teaches Java programming in an interactive and engaging way that is technically relevant, pedagogically sound, and highly motivational for students. Using the Greenfoot environment, and an extensive collection of compelling example projects, students are given a unique, graphical framework in which to learn programming.

Customer Reviews (6)

Excellent introduction to Greenfoot
I discovered this little gem as one of Amazon's "other user's bought" suggestions when browsing through books on Scratch, Alice, and the Lego Mindstorms systems.There is a growing body of published work specifically written towards educators, particularly those focusing on teenagers, and this book is a great addition to anyone interested in the subject.

Introduction to Greenfoot programming is an excellent hands-on tutorial of the Greenfoot system, a Java-based programming environment particularly well-suited to teaching object-oriented programming concepts to teenagers with its focus on gaming and simulation exercises.Having tought my own pre-teen nephew some of these concepts in simpler systems such as Scratch, and visual systems like Alice (while, written in Java requires no knowledge of that language), I find this book to be a great guide for teachers and students alike.The book is not really focused on teaching Java so much as introducing object-oriented concepts through its color illustrated examples and exercises.

A warning: the book introduces a lot of terminology in a way that some teenagers may find difficult to understand.Also, if you have no familiarity at all with programming, this book may be a little challenging.Some of the examples are completely developed but the book leaves it as a challenge to the reader to complete many of the projects.Fortunately the source code is available online to assist any enterprising young programmer.

Overall, I think this book is a great companion for a classroom that is lead by an adult who is thoroughly familiar with Java and other aspects of object-oriented programming.A really motivated student may be able to figure out the more advanced examples on their own, but many students will be well-served to have an experienced guide along to help give further explanation to the concepts provided.

I highly recommend this book, the programming system it describes, and the efforts of the University of Kent to bring this free educational system to the world.

Best game programming book I've read
Unlike some of the other game programming book I've read, which can become a chore to finish, this one was a pleasure to read!
The right mix of pure Java code and WYSIWYG to make one excited to keep learning about and making games. It's a genius of an idea of using a GameMaker like IDE but with Java code behind the scenes.
I just wrote a Space Invader clone using Java and Swing and it was quite a bit of work for someone that just took a single class on Java. I wish I would've found out about this before I started on that. It would've made prototyping the game a lot easier. This is how Java should be taught. You are only introduced to new Java ideas like arrays and variables as needed to finish the game demonstrations. Only the minimum math and physics to do some cool stuff without turning you off. I don't think variables are even introduced until half-ways through the book now that I think about it. There is just so much other cool stuff like emergent behaviour, gaussian distribution, three body problem, etc , I've never seen so expertly explained elsewhere, that you just need to get this book to see for yourself!

Fills a niche in CS education
While I agree with Riccardo that this book could be bigger, I think the book nicely introduces students into using and extending Java objects in a way that is fun and interesting.Greenfoot is a great programming environment for supplementing a high school AP Computer Science class, as students can quickly be exposed to Object-Oriented-Programming principles in Java.Like BlueJ, Greenfoot allows students to examine, alter, and extend object instances in a way that would be very difficult outside of the Gridworld case study.

The price of this book fluctuates wildly.As I write this, the price is far more than I paid for it just two months ago.I'm not rating this book based on the current price, as that price is too high, IMO.Rather, I am rating the book regardless of price.It does a good job at what it sets out to do.

This book works with a wide range of skill levels.Advanced students will be able to take the included "further ideas for scenarios" and, using the Greenfoot API, design their own games and simulations.

I'm glad I have this book.I just wish the price would return to what one would expect: 25 USD would be a deal.I think I paid 40 or so USD and don't regret doing so.

Great guide for a brilliant IDE
First off, let me introduce the Greenfoot IDE for those who may not be familiar with it-- Greenfoot is a Java IDE optimized for game/simulation development.It allows you to construct and test Worlds and the individual "actor" objects within them visually so you will know exactly how you want everything to behave at runtime, and what changes must be made programmatically to make it so.Greenfoot is meant to be a learning environment for programmers relatively new to Java, but its game-optimized API and visual testing make it a great IDE for any level programmer looking to make a game in Java.There have even been [rudimentary] 3D games made.Anyway, now on to the book-- it is everything you would expect it to be and a little bit more; it provides good coverage of the Greenfoot API, it teaches the reader introductory Java as he/she works through the projects, and it provides plenty of links to more information about Greenfoot or Java development in general.My only complaint is that it is a bit short, but that is really only because it centers on Greenfoot and game/simulation-related topics in Java.There are some 'project ideas' towards the end of the book that I wish Kolling had fleshed out a bit, but there is plenty of online documentation on the Greenfoot site to fill in whatever gaps the book leaves.There's still plenty there, and what is there is gold. BlueJ is another Java 'learning IDE' that Kolling was a part of, and the book for that covers much more broad-spectrum Java.If you like Greenfoot and plan to branch out with your Java studies, I would recommend BlueJ and the book "Objects First with BlueJ" as a complementary text.

Fantastic approach to learning programming - fun and thorough
This is the best example of a book that uses a graphical/game/simulation approach to learning to program that I have ever seen. It is very well written, the examples are great (there are some games, some simulations - planets and ants, some music), the explanations are clear, and every serious reader will learn *a lot* about programming.

I have read other books about learning environments (such as scratch or alice), and this is a little different. The programming language is Java, not some custom made toy language. This means that with Greenfoot and this book, you cannot start quite as young - I would say maybe 14 is a good starting age for this. But on the upside: man, this scales! You can really build fantastic real programs with this. This is not only for kids!

The fact that it is Java what drives this makes this usable all the way up to advanced university courses. Projects can be very simple (in the beginning), but they can also do real fascinating stuff. I loved the ant simulation in the book!

The system performs well, the book teaches real object-oriented programming in Java, and readers will learn a lot about OO programming.

It is amazing that a system that can do all that is so easy to learn in the beginning. The first few chapters are really playful, and you hardly notice all the stuff you're learning.

I guess this is a result of a brilliant system - Greenfoot - and a great pedagogy in the book. Easily five stars. ... Read more

Product Description

A valuable handbook/reference for professionals who need to learn C++ and master its latest updates, this exceptionally organized, #1-rated guide teaches the power and flexibility of the C++ programming language through object-oriented programming applications. Examines the most up-to-date C++ features, including new-style headers, new-style casts, type bool, type string, stringstream classes, namespaces, namespace std., exception handling, run-time type identification, operator new , the template input/output classes, and more. Offers complete coverage on STL (standard template library), including containers, iterators, algorithms, and function objects; the standard input/output library IN DETAIL; and the Microsoft Foundation Classes. Contains an extensive number of well-constructed examples, beautifully fashioned sample applications, interesting and practical programming exercises, boxed figures and vibrant illustrations. A companion web site providesthe book's source code, header files, and data files; sample syllabi; transparencies; and an errata list. For professionals in computer science and related fields.

Customer Reviews (3)

Not for the complete beginner in C++
This book covers the important aspects of OO approach as well as the STL for C++. It is definitely not suitable for those who have no programming experience in C, and indeed, I find that one actually even needs to have a little knowledge of C++ to benefit from the book. The first two chapters let the C programmer make a transition to C++, and explain clearly on input and output in C++. The next three chapters then strive to explain the OO features in C++.
Generally, the book goes at lengths to illustrate classes in C++ and their workings, and offers many tips and traps as well as certain programming styles and approaches which would produce robust programs. The worked examples were also quite comprehensive. However I feel that the concepts of OO were not well illustrated, and from my experience, a thorough understanding of OO concepts help very much in being able to manipulate classes and using the methods in C++. The chapter on MFC was not very useful, it really looked as if it was just there to fill in space. It does not teach much about MFC.
All in all, however, I would still consider it a fairly good book to keep as a reference.

Recommended as a first C++ text.
A lucid traversal of basic OOP concepts and the C++ language.Lots ofexercises, at a rather low level of detail. J&K focus on the basics,avoiding the trap that others (e.g. Lippman & La Joie) fall into oftrying to cover too many advanced topics in an introductory text. Ascattering of typos and minor errors should not confuse the perceptivereader.

A good job that can be rewritten for another edition
This book is concise but clear. I think the typesetting in this book could be redone better to give it better readability.More diagrams & few more example would make it perfect.The authors explains many subtle points of C++. This book is good for academic settings if you already knows C & Data Structures. Overall, a good concise book. ... Read more

Product Description
"An Introduction to Object-Oriented Programming with Java" provides an accessible and technically thorough introduction to the basics of programming using Java. The fourth edition continues to take a truly object-oriented approach. Objects are used early so that students think in objects right from the beginning. In the fourth edition, the coverage on defining classes has been made more accessible. The material has been broken down into smaller chunks and spread over two chapters, making it more student-friendly. The hallmark feature of the book, Sample Development Programs, are continued in this edition. These provide students with an opportunity to incrementally, step by step, walk through program design, learning the fundamentals of software engineering. Object diagrams, using a subset of UML, also continue to be an important element of Wu's approach. The consistent, visual approach assists students in understanding concepts. ... Read more

Customer Reviews (24)

Visual Java Teaching Book
A good visual book, teaching by the UML diagrams. Suitable for beginners to intermediate level and a bit more. Nice colorful book. With the help of "Sample Developments" this book will give you some real practical experiments throughout each chapter. My suggestion for those who want to begin Java with no prior programming experience is "Java 60 Minutes a Day" which you can find it in my review list. In my view, as an intermediat programmer, is a bit difficult to understand core java with this book.

Good for beginner
This book is good for java beginner and it is highly recommended for anyone who wants to learn java in a fun and with more graphic. However, there is less topic covered. It is highly expect that more area coverage in later edition.

Better than the best cup of Java
Note: OOP = object oriented princibles OOT = object oriented technology

This was the textbook used for the introduction to computer programming class I just finished taking during 2004. I absolutly loved it!

In my opinion, this is an excellent book for those who know NOTHING about programming. The first few chapters deal with the basics of programming in general. Then the book quickly and gently introduces the object oriented side of programming. Thus, the bulk of the book is developing both your general programming skills along with your OOP java skills.

What I loved about the book was that it was so remarkably easy to read. Important words/concepts are reiterated throughout to reinforce memory. Everything is explained with only the neccesary technical jargon. Terms and concepts are gradually and thoughtfully introduced, and then used appropriatly throughout the following chapters. I'm guessing about 1/3 of every page consists of diagrams, reinforcing what is read in a wonderfully clear visual mannor. Furthermore, the book provides the information in a surprisingly VISUAL mannor (lots of diagrams and pretty color pages); this is fabulous for first time programmers, especially since programming is inheirantly non-visual.

I admit Java isn't the easiest language to learn, like Basic, however it is remarkably sophisticated. Java does not involve either the complex syntax of C++ or the dangerously powerful and yet complicated pointers of C (also C++).

Java is not linked to a specific platform like Visual Basic, which is MS Windows ONLY (do we really need to be more dependant on MS). Although C# is almost identical to Java in terms of object oriented technology and syntax (MS stole the whole thing from Sun!), Java is not eternally latched to the MS beast.

Unlike the oh-so-easy Basic language, Java is extraodinarly versitile and practical with uses from typical desktop application programming to wickedly awsome web-application development arena, which is not practical with the popular C and C++ languages.

Ultimatly the splendar of Java revolves around its wonderful OOP design. For me, developing a Java app. is like createing a piece of architectural artwork. Java's unadulterated use of OO concepts, such as interfaces, the object, abstraction, encapsulation, inheiratance, polymorphism, ect. all allow for truly elegant, robust, and downright...gorgeus pieces of code. OOT isn't the future, it is the present. OOT allows developers to advance through the development proces with a level of robustness, efficiency, and elegance not possible with archaic procedural languages *cough C cough* . If your gonna go OO, go all the way. Dont half-ass it with C++, which is nothing more than a procedural language add-on.

Sorry about the digression into the world of Java...

Back to this book...When I read this book beforehand, the class lectures felt stale, becasue I already had such a strong grasp of the concepts by only reading the book. I truly do not understand what others have said in reviews about how the book is so poor. Yes, this isnt a great reference, but that's because it isn't a reference; its an introduction to programming via the OO paradigm. I guess I'll bend a bit to the idea that it throws a lot at you, but that is simply because this book is all about OOP, which is delightfully sophisiticated. C claim to fame is brute machine language force, in contrast, Java's strength is software architectural sophistication and elegance. You will learn the tools of OOT software architecture and thus you will learn to think in the object-oriented paradigm. Over the summer I was working at an internship doing all programming, unfortuatly in C#. I converted visual basic 6.0 programs into the .NET platform via C#. My programs, those of a simple novice programmer, were far more robust and elegant than those of the veteran visual basic programmers who didn't have as good a hold of OOT's client-server architecture.

I believe this is a great book for FIRST TIME programmers because of its clarity and simplicity. Not only did I find it easy to self-learn with, it actually enjoyed it more that way!

Essentially, my time with Java has been a freakin blast! I've been able to use the software architectural skills imbued by Java's smooth OOT to create remarkably robust, elegant, and efficiant software. I viscously support Java and its OOT architecture. I owe it all to this book.

Note: the new edition of this book just came out. Its been updated for the new 1.5 Java upgrade.The author may have corrected/improved what ever those 'other' people may have not liked.I haven't read the new version, but I bet it's even better than before!

Chock full of errors and typos
This was the assigned textbook for my first graduate-level programming class. I was told that the first edition had tons of errors and that the second edition was vastly improved. Yikes! We used the second edition and it was unbelievable how many errors there were -- in the explanations, in the formulas, in the chapter review questions and "quick checks." In addition, there is an ancillary web site for the text that purports to include error listings and corrections. BUT, the listing does not exist, even though the edition has a 2001 copyright date. We were lucky to have a good professor who helped us identify the errors. Otherwise, I would be one confused, frustrated, novice 'programmer'.

god-awful programming book
This book is insanely bad for academic purposes.It uses a non-standard package (javabook), which, though useful, does not prepare you for actual Java programming.In addition, this book is one of the worst language references I've ever seen.The first-semester computer science course at my university switched to this book starting this semester, and it helps to make an already difficult course significantly harder than it needs to be.The only way this book can be effectively used is in a class taught by a superb instructor.Otherwise, forget it.The book is uninteresting, uninformative, and generally just not useful.To all computer science professors out there: please do not make your students use this book. ... Read more

Product Description

Object-Oriented Programming in C++ begins with the basic principles of the C++ programming language and systematically introduces increasingly advanced topics while illustrating the OOP methodology. While the structure of this book is similar to that of the previous edition, each chapter reflects the latest ANSI C++ standard and the examples have been thoroughly revised to reflect current practices and standards.

Customer Reviews (32)

Excellent book for learinng C++ programming
I bought this book long time ago when I was a student, but had not read it seriously. However, I started to read this book a month ago because of my job duty. Then I found that this book is excellent in helping readears understand essenctial conepts and principles which are required for C++ programming. The reasons why I am thinking like that are as below. This book explains 'why' as well as 'how', describing what's happening inside of system or C++ compiler. Each chapter starts off with some possible real-programming issues that we may face, then moves to fundamental and essential concepts, which make me think about some applications of the contents. Example codes which are shown in this book are very easy and clear, but very helpful for understanding concepts and principles which are very essential.
I strongly recommend you to read this book to be an expert in C++ programming.

sweet
got this book for a steal, though the books condition could be better it still saved me a ton of money from the college book store, thanks!

I hated it
First off, I had to buy this book for a computer science C++ class (it was required). I've also used a few other books to learn c++, my favorite being Bruce Eckel's books. Nothing beats a little wikipedia/cplusplus.com for reference and a good compiler to try things out though.

I'm giving this book a bad review for several reason. 1) The problems at the end of the chapter are explained poorly, don't always compile on GCC (aimed at windows), and are sometimes flat out wrong. I've seen numerous typos not only in the code, but also in the text. Instead of stating the problem clearly the author just randomly narrates made up computer "problems" for you to "solve". Also, the formatting of the code for the solutions is literally horrible. 2) The book goes into way too many long explanations. It may be a good book if you want to learn c++ and have hour upon hour to spend reading mindless drivel. However, it is not the book to get if you actually want to learn c++. 3) Finally, the book doesn't cover nearly enough information to justify it's size. It's great as a monitor stand, but the hundreds of pages only give you a basic understanding of the core language. Going through the entire book is like climbing a mountain to get to a McDonalds - just driving to one is a lot more worth it.

Don't get me wrong though, there are some good aspects to this book. First, the binding is fantastic. It's easy to set it flat on my desk to reference a homework problem. (Using this book as a general reference to the C++ language is a horrible idea, and will waste you a lot of time searching through massive paragraphs of text and example code to locate some syntax you forgot). The other nice thing is that it's heavy. If I wanted a book to throw at someone this would definitely be an option, baring me having any hardcover books on hand.

Prognosis: get this if you want to learn C++, but are a slow minded person and don't get bored reading mindless drivel. Otherwise, stay clear.

Get what you pay for
I would have liked to know before hand that there was a physical defect on the book.The first 10 pages were slightly off center and partially attached at the top of theses pages.This problem was easily fixed and all things considered I will continue to purchase books this way.The price break was around 60% and I will spend most of time not dealing with the first ten pages.This book is written very well.Great examples and wording, I can hardly believe it is a book on programming.Great price + Great book = Great Deal.

Perfect!
Book was in great condition and delivery was very fast.I had the book in less than a week.Thanks! ... Read more

Product Description
C++ is now established as one of the leading industry programming languages for object-oriented software development. Its advantages over other languages include speed and flexibility. It is used as the base for many commercial software products and for performance solutions to complex problems. Not often taught as the primary programming language, students are frequently expected to pick up the language for themselves. This book is an ideal student self-learning guide.

As a step-by-step tutorial, this book teaches all language features and explains their practical usage. Intuitive examples are used that are neither too complex to distract, nor oversimplified. A key concept in C++ is programming with templates, which can help to program generic solutions - for example implementing polymorphism. Nicolai Josuttis teaches how to combine templates with object-oriented programming to produce the power of modern C++ development for high performance programs. It is a book that goes well beyond the basics.

Features:

• comprehensive, detailed, readable, practical and up-to-date

• teaches how to get the power from C++, using the current ANSI language standard and programming mode

• specific hints help C and Java programmers switch and compare languages.

• website provides more examples and links to useful online resources. ... Read more

  Customer Reviews (8)

  Well written, good examples
  Nicolai clearly knows his material very well, yet is able to talk at a comprehensible level. He doesn't dwell on the basics (what is a loop?), and on the other hand, doesn't get into all the arcane features of C++. I think it is a good book for anyone who already knows some programming (not necessarily C or C++), but is still enjoyable and informative for people familiar with C++.
  
  Most examples are complete, concise programs demonstrating the concept. Code is well written and commented. He first gives the file listing, then dissects each new piece to explain what it does and why. Common errors and subtleties are explained. Often he shows several alternative ways of implementing a feature, and explains the pros and cons of each. For instance, implementing an operator first as a member function and then as a global function.
  
  Where a feature may be better implemented with topics covered later, or is covered in more depth later, a page reference is provided. For example, input is first covered with rudimentary error handling, with a forward page reference to the version with improved error handling available using exceptions.
  
  Some of the design rationale behind C++ and the standard library is also given, such as why the std::stack pop() function doesn't return the top element, for exception safety. This helps the reader appreciate the inherent difficulties and to incorporate similar solutions into their own code.
  
  He covers the standard library (STL) and templates in enough detail to be useful, but really a separate reference on these topics is required. In this respect, his C++ Templates book is an excellent companion. (I expect his book The C++ Standard Library to be useful, but can't yet say from experience.)

  Good Start Point for Professionals
  This is a quite good book for professional programmers who are new to c++. Especially for designers and architects. In other words, without the knowledge described in this book, you can never design professional quality software written in C++. Also good for those who want to graduate from 'C++ as better C'.

  GOOD BOOK, BUT....
  THIS IS A GOOD C++ BOOK BUT THE AUTHOR DOES NOT RESPOND TO E-MAILS AND THE BOOK SELLS FOR $55.00 RETAIL, BUT PRICED HERE AT $60.00.

  Pure C++ Tutorial
  In my point of view, this book is one if not the best book I have ever read so far in C++. The author knew exactly what the reader needs to know and presented them in a clear and concise manner. It has very well written & easy to read C++ code samples. For a beginner to intermediate in C++, I think this book is for you as it walks you through a step by step approach to learning C++. The knowledge you would learn at the end of reading will make you feel better and comfortable in using C++. There are books out there that I've found boring if not too advanced at my level, I wish this influence you not to put yourself into that experience.

  Thanks Nicolai for putting this together, a wonderful book that will surely help many people that are interested to learn C++.

  C++ enthusiast
  I am an engineer (not a computer scientist), and my primary computer language is Visual Basic. I have written a good amount of code and I appreciate VB technology very much. (The fact is that this technology works good and cheap enough in wide scope of practical needs).
  I wanted to extend my knowledge in computer programming languages and I began to study C++ computer language. At some point I discovered about the existence of the Standard C++ and I understood that, in my case, the right approach must be studying exactly the Standard C++. Finally I did find my personnel "Entry Point" within Nicolai's very nice book! While I often refer to other books as well, I do use the "Object Oriented Programming in C++" as main base point.
  The Author demonstrated:
  1. Deep understanding of the subject.
  2. Strong defending of the idea of the Standard C++.
  3. Carefully marking the commons and differences between C++ and C programming languages.
  4. Great attention to the detail.
  5. Clear explanations of the definitions.
  6. Perfect cross references.
  7. Generous sharing with the reader.
  8. Excellent style!
  Thanks a lot for the excellent job!
  The Publisher did a good job as well. The book is easy to read and follow. Thanks! ... Read more

Product Description
The first book published that fully describes object-oriented programming in an accessible manner for a wide range of readers. This new second edition covers the changes that have occurred in Objective C version 4.0, the newest release, and the tools that assist in developing object-oriented software. ... Read more

Customer Reviews (5)

Interesting history, but that's about it
(This review is about the 1986 edition, not the 1991. I assume big changes, but either way I haven't read it.)

Okay, so you just got a Mac or an iPhone and you've noticed that the development tools you need are free (and, indeed, come with the computer). You go out and buy books, but you want to see the original book. Well, this is it. Congratulations, you've just purchased an interesting historical document that has almost nothing to do with Mac programming, in a language that is almost but not entirely unlike the Objective-C you'll be using to write your app.

The 1986 edition is truly a time warp -- for example, the choice of "acetate" as an analogy to describe a GUI view is probably going to be lost on anyone who's only ever done page layout on a computer. Cox writes comparisons of Objective-C to Ada, C++, and Smalltalk, but the comparisons are far, far outdated. Three years before the original ANSI C standard came out, Cox was still using K&R C as his substrate language. The coverage of how object-oriented GUI systems work is more or less on target, but since it's based on a very old version of X, it isn't very much like the OpenStep/Cocoa environment. But a bigger problem than its antiquatedness is the fact that (probably by necessity) it's three parts textbook, one part advertisement for Stepstone's (or at the time, PPI's) product. The grating and poorly-thought-through term "Software-IC" (for a binary object library) pops up everywhere.

Used copies, however, can be had pretty cheaply, so if you like computer archaeology it's certainly a nice little trip to the days when object-oriented programming was just going mainstream and Steve Jobs was looking for technologies to build his NeXT system on. There's also enough source code to learn a bit about writing your own Objective-C libraries, if you know how to translate to the @ syntax that ObjC has used since not long after this book came out. For the most part, though, unless you're a serious Mac or programming languages historian, it's not worth going out of your way for.

The original reference work on Objective-C
The original reference work on Objective-C; the second edition was published May of 1991.So don't expect anything about OS X or Cocoa.But it's still a good book.If you want to read about the language itself, its history, the motivations behind its design, and its relationship to other languages, this is the book for you.If you want an introduction to the concept of object-oriented programming that is not mucked up by the foulness of C++ or Java, but rather gets you started down the One True Path of Cocoa right off the bat, this would also be a good place to start.I learned Objective-C from this book, and it is still handy as a reference work.Kind of the Kernighan & Ritchie of Objective-C. Four stars instead of five because it has less and less relevance for the typical Obj-C programmer nowadays, who is almost certainly coding for Cocoa on OS X.

This book is awesome.. it explains alot.
The book is kind of small.. but its packed w/ info onobjective-c. It gives complete info on how to use the objective-c OOPextension as well the objective-c internals.

The main reference on Objective-C.
The first three chapters are conceptual, and compare various approaches to object-oriented programming.Chapters 4 until 8 are highly technical and give detailed information on the Objective-C runtime and class libraries.I find the chapter on user interfaces a bit sloppy. Interesting, on the other hand, is the final chapter with projects for extensions.

One of the best books on Object Oriented Programming
This book is a must read for anybody working in Objective-C (NextStep/Rhapsody). It basically describes Objective-C, how it works, and future directions for the language. It also has a good comparison of other OO languages. Overall, it's a great book ... Read more

Product Description
Microsoft Visual C# 2005, An Introduction to Object-Oriented Programming, Second Edition provides the beginning programmer with a guide to developing programs in C#, a language developed by Microsoft as part of their Visual Studio .NET platform. With C#, you can build small, reusable components that are well-suited to twenty-first century Web-based programming applications. Although similar to Java and C++, many features of C# make it easier to learn and ideal for the beginning programmer. You can program in C# using a simple text editor and the command prompt, or you can manipulate program components using Visual Studio's sophisticated Integrated Development Environment. This book provides you with the tools to use both techniques. ... Read more

Product Description
This collection of original research provides a comprehensive survey of developments at the leading edge of concurrent object-oriented programming. It documents progress - from general concepts to specific descriptions - in programming language design, semantic tools, systems, architectures, and applications. Chapters are written at a tutorial level and are accessible to a wide audience, including researchers, programmers, and technical managers.The problem of designing systems for concurrent programming has become an increasingly important area of research in computer science with a concomitant increase in the popularity of object-based programming. Because parallelism is a natural consequence of the use of objects, the development of systems for concurrent object-oriented programming is providing important software support for a new generation of concurrent computers.Gul Agha is Assistant Professor in the Department of Computer Science at the University of Illinois at Urbana-Champaign. Peter Wegner is Professor in the Department of Computer Science at Brown University. Akinori Yonezawa is Professor at Tokyo Institute of Technology. ... Read more

Product Description
This book describes the design goals and language features of object-oriented languages without viewing them from the perspective of any particular language.Covers key object-oriented principles — date abstraction, inheritance, polymorphism, and dynamic binding in a language independent discussion that focuses on the purpose of each feature. ... Read more

Customer Reviews (14)

Buy this book.
This is a pretty nice piece of work of a bass player, educated at MIT and former instructor at the EECS Dept. of the University of Illinois at Chicago! I was one of the lucky ones who took the Object Oriented Conceptsand Programming class at UIC, when Caleb was teaching the class. This isyour definite reference, delivered from someone who really *knows* theconcepts covered in the book.

A long way from "Random Football"
A short thirty years ago, one of the best bass players on the planet was slightly distracted by all nite work in the computer lab in Champaign-Urbana... I can see that what was Jazz's loss, is an engineeringgain. It a long way from "Soft Machine", "RandomFootball", and basement study sessions, but it appears to have beenworth it. Congratulations, Cal!

A great book...sorry it had to end
With no doubt, this is the best book on object-oriented programming out there. The author addresses not only the theoretical concepts behind OO-programming, but he outlines how to do it using Smalltalk, one of the first OO-languages, and C++, certainly one of the most widely-used OO-languages. I do not know Smalltalk, and did not read the part on this language, so my comments will be limited to the sections on C++ and the general discussions on OO-programming.

The author gives an overview of the semantics or "meaning" of a program. He is very thorough in his treatment, and some of the areas that I found particularly well-written include his discussions of:Order of evaluation and side effects; conditional, controlled, and implicit iteration; the importance of strong typing in giving more reliable code; the run-time stack; passing by name, by value, by value-result,and by reference; declarations versus definitions; the difference between static and dynamic typing; static versus dynamic scoping; object lifetime and instantiation; static, automatic, and dynamic storage; data types; pointers; constrained types; encapsulation and information hiding; abstraction mechanisms; programming paradigms, including imperative, functional, logic, and object-oriented; =class semantics; the distinction between "pure" OO-languages such as Smalltalk, Eiffel, and Java, and hybrid OO-languages such as Object Pascal, Oberon, Delphi Pascal, Ada95, C++, and Objective C; the tradeoffs between execution time and dynamic binding in C++; the justification for using in-line functions rather than macros in C++; static, file, local function, and class scope in C++; static and dynamic storage allocation of objects in C++; the distinction between a class in C++, which must be an instance, and thus not "first-class" as in Smalltalk; friend declarations in C++ and how they depart from OO-philosophy; the example of the "Queue" class; the "this" pointer in C++; "smart" pointers in C++; and class templates in C++.

He does not include a discussion of object-oriented design methodologies (Booch, etc), but does give references for further reading. Excellent summaries are given at the end of each chapter along with exercises.It is definitely a book that serves well also as a reference, even though it was published in 1997, and some changes to the implementation of C++ have occurred since then.

A good attempt to capture OO language features
If you have found that after coding in C++, java, smalltalk or any other OO language that there are certain concepts that have remained ambiguous this books makes a good attempt to make clear distinctions between them.The information is there however it requires a good deal of work to extractit.It would benefit from further layering of concepts, improvedorganization and tighter cross referencing. As it stands it is a little toodense.

A Very Good Book.
This is an excellent book. It illustrates the OO concepts and the languagedesign using Smalltalk and C++ as examples. I have to say it is a very verygood book. C++ and Smalltalk go opposite direction in term of implementingthe language. If you like Bertrand Meyer's book on Eiffel (Object-OrientedSoftware Construction), you should love this book. I learn a lot from thisbook. I recommend this book. ... Read more

Product Description
Learn all the basics of C# 3.0 from Beginning C# 3.0: An Introduction to Object Oriented Programming, a book that presents introductory information in an intuitive format. If you have no prior programming experience but want a thorough, easy-to-understand introduction to C# and Object Oriented Programming, this book is an ideal guide. Using the tutorials and hands-on coding examples, you can discover tried and true tricks of the trade, understand design concepts, employ debugging aids, and design and write C# programs that are functional and that embody safe programming practices. ... Read more

Customer Reviews (12)

Great for beginners
This book is a great place to start for both C# and Object Oriented Programming (OOP). I've been working steadily through the book using C# 2008 Express Edition (free from Microsoft, shockingly), and other than some errors that you'll have to work through (just apply your brain), you'll do well. I've tried other publishers books on programming and they all left me asleep. This one is outstanding. Just make sure you do the exercises at the end of each chapter and then try stuff on your own.

One other point: If you go to the Wrox Publishing programmer forums ([...]), Dr. Purdam (the author) actually answers questions about his book and C# programming. I find that truly amazing.

Great Book! Gets you programming right away!
Fantastic. I just completed reading this book and going through the exercises. I was already creating programs by the second chapter. Dr. Purdum has a very easy to follow, informative, and charasmatic way of getting the material across to the reader. This book explains how to do things and more importantly why. My company recently switched from only using T-SQL Stored Procedures to now creating C# programs to do the same functions. This book immensely helped, and has put me ahead of my peers. Highly recommended and you won't regret reading through this book! I just wish Dr Purdum wrote more on C# than just this book.

Not bad, but definitely for newbies
This was the textbook for a C# class in my college. I withdrew from the class after two weeks for reasons other than the textbook, mainly the instructor. Anyway, this is a good textbook for learning C#, but while the material is explained thoroughly and well, for me it was tedious, since I have several years of programming experience already and have already finished several other software classes recently. The author explains everything as if you don't have any previous software experience; so if you are already familiar with other languages, this book is probably not for you. I don't have another book to recommend in its place, but you should probably look elsewhere.

If you are new to software, it is probably a good fit for you.

The best IT book I have ever read
To be honest, I am a french IT engineer and english is not my native language so I sincerely apologize if I make mistakes while writing this review.
Despite this fact, I found that this book was amazing.
It explains clearly from scratch how to write serious programs using difficult concepts of object oriented programming.
This book is the perfect balance between theory and practice in order to understand perfectly OOP and C# language.
I have read dozens of IT books in my professional life but I need to admit that this book is a must.
Any beginning programmer who follow seriously each step of this book will be able to understand and use OOP and C#.
This book is from my opinion an excellent book for everybody : Beginners as experienced programmers who want to learn C#.
I need to congratulate Mr.Purdum for this masterpiece and I hope he will write another book which will go on building on the strong foundation of this book.
For example a real business software application described step by step would be a great asset for the whole C# community of programmers.
Anyway this book is really a must.

Great Intro
Great intro to C#3.0 Do need foundation in C# and/or programming. Some aspects are slow but overall, a good learning tool to start with ... Read more

Product Description

Object-Oriented Programming and Java presents two important topics in contemporary software development: object-oriented programming and Java. This book takes a different teaching approach from most available literature, it begins with the description of real-world object interaction scenarios and explains how they can be translated, represented and executed using object-oriented programming paradigm.

Principally, Java is an object-oriented programming language. By establishing a solid foundation in the understanding of object-oriented programming concepts and their applications, the book provides readers with the pre-requisites for writing proper object-oriented programs using Java.

Object-Oriented Programming and Java covers the latest in Java technologies and is suitable for undergraduate or postgraduate courses on object-oriented technology, and in particular, using Java as a programming language for creating object-oriented programs.

Product Description

As you work your way through An Introduction to Object-Oriented Programming with Visual Basic .NET, you'll learn how to analyze the business requirements of an application, model the objects and relationships involved in the solution design and, finally, implement the solution using Visual Basic .NET. Along the way you'll also learn the fundamentals of software design, the Unified Modeling Language (UML), object-oriented programming, and Visual Basic .NET.

An Introduction to Object-Oriented Programming with Visual Basic .NET is logically organized into three parts.

• Part One delves into object-oriented programming methodology and design, concepts that transcend a particular programming language. The concepts presented are important to the success of an object-oriented programming solution regardless of the implementation language chosen. At the conclusion of this part, a case study walks you through the design of a solution based on a real-world scenario.

• Part Two looks at how object-oriented programming is implemented in Visual Basic .NET. You will explore the structure of classes, class hierarchies, inheritance, and interfaces. The .NET Framework is introduced along with the Visual Studio integrated development environment (IDE).

• Part Three returns to the case study introduced at the end of Part One. Using the knowledge gained in Part Two, programmers will transform the design into a functional VB .NET application. The application includes a graphical user interface, a business logic class library, and integration with a back-end database.

Customer Reviews (7)

This Book is Excellent!!!
This book is excellent for beginners. If you've never programmed with OOP before, this will give you a good overview of the project, including planning, from start to finish. It was this book that gave me the basic overview i have today. I wish i know of something that went even more in depth.If you already know VB.NET, UML, and OOP this book is for the very beginner. But as a starter, it is excellent. I also liked Sams Teach Yourself Object Oriented Programming in 21 days. It is also great. It explains OOP concepts in more detail. This book teaches you how to do the programming, the Sams book teaches you the reason for OOP.If you are beginner these two books would be great to start with. Don't pay attention to the Java in the Sams book. It is not really a java book. It really is an OOP book.

This book is full of errors.
If you are trying to learn the concept of OOP with VB.NET, this is a good book to start with. If you are trying to learn how to program OOP in VB.NET, I would look else where. I found the book to be full of errors. You can download a list of errata from Apress, but don't expect to be able to fix all of the errors with this. I spent more time trying to figure out why the code did not work than I did learning OOP. I know fixing errors will help you learn what the code does, but that is not why I bought this book. If I could do all over again, I wouldn't buy this book.

A Great Starter!
I have several OOP books that I put aside because they became fustrating and/or clumsy.This book has made it possible to pickup those once forgotten books.

A big plus for this book is that all the examples work and you can download the chapter examples from Apress!The user friendly analogies make it an easy read.The only resistance I experienced was the free personal UML modeler that was referenced in the first part of the book.The first pass through these chapters I followed along by creating the diagrams by hand.After reading the rest of the book, I spent half a day learning the software and completing the chapter examples.

For me, this author paints a pretty good big picture of OOP!My other books are now helping with the details;)

Clear, concise introduction to OOP and VB.Net
This book is very well written. The material is organized well and the information is presented in easily digestable pieces.
The book gives anice overall background of OOP then shows how to implment it (on a very basic level) in VB.NET.

I highly recommend this book for VB programmers who have never incorporated OOP in their programs.

An Intro to OOP with VB.Net
To me "introduction" books are always an interesting venture.Some
are great experiences, and others are nightmares. Overall this book
was a pretty good experience, although there was a major bump in the
road (and a couple of minor ones). In the chapter summary below I will
go into a little more detail on the positive and negative points.

Chapter Summary:

Chapter 1: Overview of Object Oriented Programming
This chapter starts with a very brief overview of the history of OOP.

Brief is good. It also has brief definitions of OOP characteristics;
Objects, Abstraction, Encapsulation, Polymorphism, Inheritance, and
Aggregation. It ends with a blurb about the history of VB.

Chapter 2: Designing OOP Solutions: Identifying the Class Structure &
Chapter 3: Designing OOP Solutions: Modeling the Object Interaction
These chapters go into UML and things like Use Cases, Class Diagrams,
Sequence Diagrams, Collaboration Diagrams, and Activity diagrams. This
seemed exciting to me because I never really get into anything like
this on the job, and I wanted to know a little more about it. Well,
while interesting this ended up being a bump in the road for me.

The Author says to either do the exercises with a UML Modeler you can
download from the net, or creating the diagram by hand. I wanted
to try the tool he used in the examples so I downloaded it. At this
point just let me say that you should be prepared to spend a lot of
time figuring out the tool if you decide to try it. It is not easy.
The directions for doing the exercises don't quite flow with actually
using the tool either. The author does state that it is pretty tricky
to use, but I really feel that the directions for these exercises
should have been better. I managed to get through some of the examples
in chapters 2 and 3 after a couple of hours.

Chapter 4: Designing OOP Solutions: A Case Study
This chapter talks about the process by which one would design an OOP
solution with a case study. The Author goes into good detail about the
actual steps needed, and does a good job explaining the methodology by
which this is accomplished. He also gives some good advice on how to
avoid some of the more common pitfalls of designing an OOP solution.

Chapter 5: Introducing VB .NET
This chapter gives an overview of VB.Net as well as the .Net
Framework. After the overview it gives you a hands on tour of the
Visual Studio .Net IDE. Of course, you will need to have the IDE to do
the tour. This tour shows you many of the screens, option settings,
and menus of Visual Studio .Net. The second exercise shows you the
debugging features of VS .Net. At his point you will need files that
you can download from the Apress web site. I may have missed it, but I
never saw any mention that downloading files was needed for the
exercises. It certainly was not at the beginning of this exercise, and I
think their should be some kind of direction about it present.

Chapter 6: Creating Classes
This chapter is all about classes. How to restrict them, access to
them, creating methods, overloading methods, using constructors to
name some topics. This chapter too has exercises you complete with VS
.Net. They all seemed to work fine for me, and were very easy to
follow.

Chapter 7: Creating Class Hierarchies &
Chapter 8: Implementing Object Collaboration
These chapters discuss things like inheritance, polymorphism,
interfaces, delegation, error handling, shared properties and methods
to new a few. These two chapters also have multiple hands-on
activities so you can continue to learn how to operate VS .Net as well
as learn more concepts of OOP. These activities are well documented,
and I had no problems completing them all without incident.

Chapter 9: OSO Application Revisited: Implementing the Business Logic
This chapter helps bring together all the ideas you were introduced to
in chapter 4. From there it goes into data access by talking about
stored procedures, ADO.net, sqlclient namespace, and many other
details. In order to do the examples you will have to have SQL Server.

Chapter 10: Developing Windows Applications
This is a fun chapter that talks about windows forms, event handlers,
dialog boxes and different types of bound controls. This chapter is
full of hands on activities that are well done.

Chapter 11: Developing Web Applications
This long chapter deals with web forms, server controls, server
control inheritance, server-side event processing, ASP.net, state, and
many other things. It is all about designing an application for the
web. The activities are easy to follow, and work.

Chapter 12: Wrapping Up and Reviewing
A quick summation of what the book covers and some tips on where to
focus next.

Appendix A: Fundamental Programming Concepts
This appendix is basically a primer for beginning programmers.

Appendix B: Exception Handling in VB .NET
A quick 4-page explanation of how exceptions are handled in VB.Net

After finishing this book I had a hard time deciding what grade to
give it. I ended up giving it a 7 out of 10. The many problems I had
with the UML activities using the UML modeler were just too painful
and frustrating to give it higher than a 7.

I will admit that the rest of the book was great and would be very
useful to a beginner trying to become more familiar with VB.Net and
VS.net. The VS.net activities were flawless, and gave good hands-on
experience that beginners would love. The UML material was actually
good as well, but the problems with the modeling tool activities
really influenced my final judging of the book.

In summation, this book is without doubt a beginner's book. Do not buy
this if you already basically familiar with VS .net or UML. If you are a
beginner and do the UML activities with pen and paper I believe it will
be a great learning experience. ... Read more

Product Description
Presents state of the art results on Petri Nets and concurrent object-oriented programming in a coherent and competent way. Softcover. ... Read more

Product Description
This book presents a balanced and flexible approach to the incorporation of object-oriented principles in introductory courses using Python. Familiarizes readers with the terminology of object-oriented programming, the concept of an object's underlying state information, and its menu of available behaviors. Includes an exclusive, easy-to-use custom graphics library that helps readers grasp both basic and more advanced concepts. Lays the groundwork for transition to other languages such as Java and C++. For those interested in learning more about object-oriented programming using Python.  ... Read more

Customer Reviews (4)

Not What I Expected
Although it was in fact the write product, it was not nearly in the condition I expected for it being in "good" condition.The book has about 35-40 pages being held in by a paperclip over 25 more just barely hanging on.I am very disappointed in the condition I have received the book in, and will probably not be using this vendor in the future.

Some python, less OO
This book was OK as a primer on python.However, I turned to the web more and more as our class progressed through this book.I'd say that 60% of what I now know about python I learned from online sources.This book gave me the problems, but not a good instruction on how to solve those problems.Most of the students in my class have echoed these sentiments.I wound up purchasing an O'Reilly book on python to supplement this text.

Some issues:
* While there are many finished classes documented in the book, the actual use of those classes is dramatically missing.
* The index is user hostile.For example, looking up "child class" says "see class, child" instead of just providing the relevant pages.
* The text is far more about how to write python than about OO techniques.Pages are spent on how to write sort and search routines in python, but very little is spent on how to design solutions from an OO perspective.
* UML diagrams are used, but not well discussed.

If you really just want to learn OO and are starting from scratch, you might want to investigate Alice as a teaching language.If you really want to learn Python, then you may want another textbook.

Good digrams, but that is about it
The title is a little misleading unless you take it as a literal python statement.It is true that there is object-oriented programming IN python.It is also true that this book discusses object-oriented programming IN python.But the book does little to discuss object-oriented programming WITH python.The book provides an intro to the common python elements, which the authors do provide a nice object-oriented emphasis.After that the book turns into a project-type book.Project learning (i.e. learning by example) can be a very useful approach to teaching, but in the case of this book, it seems like the emphasis is on the projects and not the more relevant concepts that form the basis of the projects.The book then comes across as a rather narrow and boring approach to learning an implementation of python.As a note, I also find it irritating when authors present oo design and graphics with a 'simplified graphics package', typically of the authors own design.I did not find one mention of TKinter in the book or index.Instead, you are given 'getting started with graphics', using the author's cs1graphics module.It either appears that the authors are deliberately shying away from real-word graphics packages because of their own limitations or that they are suggesting that their students are limited in their ability to tackle what they eventually may need to work with.Ultimately, I think the authors do a disservice in this method of presentation, where you start with a canvas, add a brand new circle (the sun) and continue adding basic shapes until you end up with a scene that vaguely resembles a composite of a tree, house, sun, and car (rectangle with two circles).If the authors extended their initial discussion of oo design and focused on it as it directly applied to python then they might have a book worth half the price they are charging, which in its current state, in my opinion, is worth about 1/10 the price.

Best Python Book but
There are only some problems have the answer (less than 5% of the total).This was not a problem because David Letscher, one of the author, was my professor, since he rarely used problem from the book for the tests and the final.

There is also a small problem with the graphic library, cs1graphics.py which people need to use for some covered topics, is not completed.

However, Of all learning Python books I've read, this book is the best.It covers basic to advanced topics in a very well-organized way with clear explanations.
... Read more

Product Description
A Comprehensive Introduction to Object-Oriented Programming with Java provides an accessible and technically thorough introduction to the basics of programming using java. The text takes a truly object-oriented approach. Objects are used early so that students think in objects right from the beginning. The text focuses on showing students a consistent problem solving approach. ... Read more

Customer Reviews (2)

Not for novices
The standard version of this title ("An Introduction to Object-Oriented Programming with Java") has been cited by several users as being hard to understand for programming n00bs, and I'm sad to report that things are no better for this "Comprehensive" edition.The flaws of this book run wide and run deep, and I'm guessing they'll be off-putting to most people without a preexisting foundation of technical knowledge.

The first problem that hits you is the author's crappy communication skills.Check out the very first paragraph of Chapter 1:
"The two most important concepts in object-oriented programming are the classand the object.In the broadest term, an object is a thing, both tangible andintangible, that we can imagine.A program written in object-oriented style willconsist of interacting objects.For a program to keep track of student residents ofa college dormitory, we may have many Student, Room, and Floor objects.Foranother program to keep track of customers and inventory in a bicycle shop, wemay have Customer, Bicycle, and many other types of objects.An object iscomprised of data and operations that manipulate these data.For example, aStudent object may consist of data such as name, gender, birth date, homeaddress, phone number, and age and operations for assigning and changing thesedata values."

You can probably figure out the basics of what he's trying to say here (since the underlying concept is easy), but do you see how this isn't the most clear and concise way of presenting information?

The next issue is how he jumps too quickly into new code.Chapter 2 starts by throwing out programs replete with terms like "JFrame" and "public static void,"which at this point are still cryptic to us, then quickly moves along using the newterms casually, as if we're already fluent.

An even bigger problem is that he often never explains terms or conceptsproperly to begin with.Examples:
1. "In Java, classes are grouped into packages, and the Java system comes withnumerous packages.We also can logically group our own classes into a packageso they can be reused by other programs.To use a class from a package, werefer to the class by using the following format:. "Hold on dude, WHAT IS A PACKAGE?
2. "The syntax for method declaration is
() { }
where is a sequence of terms designating different kinds of methods, is the type of data value returned by a method, isthe name of a method,is a sequence of values passed to a method,and is a sequence of instructions."Gee, thanks for clearing thatup.
3. And this is how he introduces strings (a common programming concept): "Thetextual values we passed to the print method or the constructor of the JFrameclass are instances of the String class.A sequence of characters separated bydouble quotes is String constants.As String is a class, we can create aninstance and give it a name."Notice he mentions a few characteristics of a string,and then moves onto an example of a string, but completely forgot to tell us whata string is.

Some transitions are abrupt, and once in a while he'll introduce a new concept halfheartedly, then quickly cut out and promise to explain it more fully later in the book.By the way, I've yanked all these examplesfrom chapters 1 and 2 alone.

Trust me, I'm no simpleton; I have a knack for math and logic, I've finished college,and I have programmed before (in BASIC).This is just a massive failure of an introductory textbook: poorly written, confusingly explained, haphazardly organized, and a chore to read.Don't taint your first impression of Java.Buy a better book.

self reinforcing teaching of graphics and OO
This book is similar to another one on the same subject - Introduction To Computer Science Using Java, Student Edition. However, the current book seems to cover the matter at a slightly more advanced level.

It does help that, for instance, when dealing with widgets for programs using graphics, that the widgets lend themselves to an inherently object oriented mindset. Thus the pedagogy of teaching graphical programming in java is self reinforcing. ... Read more