Customer Reviews

Objects First With Java: A Practical Introduction Using BlueJ (2nd Edition)

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

 

 

One really bad way to teach basic math in elementary school is to stick a calculator into a kid's hand and have her learn how to use it. The kid might be multiplying large numbers together in no time, but she won't have any real understanding of what she's doing. There's an analagous problem with learning computer programming languages using the latest whizzy integrated development environments (IDEs). The IDE does a lot of the leg work for you behind the scenes and code gets 'automagically' generated, but you don't really understand what's going on. Worse still, some of the major Java IDEs are so feature-rich that it's an uphill struggle just to understand the IDE, let alone to try and learn Java and object-oriented programming (OOP). If what I've just described mirrors your own experience in trying to learn Java using the popular Java IDEs, then read on ... the wonderful Bluej Java enviroment and this accompanying book, may be just what you've been looking for.

"Objects First with Java" is an absolute Godsend for anybody who wants to really learn Java from the ground up, and in the process, develop a clear understanding of object-oriented programming. The examples in the book are superbly illustrated using the author's "BlueJ" Java environment which comes on the CD included with the book. BlueJ lets you create your own Java modules and then interact directly with them, allowing you to experiment with their behavior as you edit and compile individual Java classes. Based upon the example projects that also come on the CD, you can alter or rewrite the Java code, compile it with BlueJ and immediately see the results. This kind of direct experimentation makes learning more fun and allows the reader to really assimilate the core principles of the Java language and the OOP paradigm that it embodies.

The book is beautifully laid out with code snippets, subject summaries and exercises all color-coded. The text is written in an accessible and conversational style that is lacking in a lot of the traditional, "dry" computer texts that are often about as much fun as having root canal work. In spite of this, the book manages to completely avoid the "light and fluffy" approach of some tutorial style texts that are overly chatty and ultimately rather lighweight. "Objects First" is a serious text for anybody wanting to learn Java and OOP and although I consider myself an experienced programmer in other computer languages, with considerable prior exposure to OOP, I never felt bored or talked down to by this book.

In summary then, I whole-heartedly recommend this book to new and experienced programmers alike who wish to learn Java well and my advice would be this: Do yourself a favor, put aside the complex Java IDE for now, buy this book, download the latest editions of BlueJ and Sun's Java environment from the web (the versions on the CD are not the latest and greatest) and REALLY learn Java!

I have been teaching programming to beginners for almost 20 years. I found leaning object oriented programming took me a long time, I believe it has taken most of the text book authors a long time also, many of them still don't get it. The authors of Objects First have taken a giant leap and provide an introduction to OOP (using Java) that is a must read for anyone wanting to learn to program with objects (even more experienced programmers).

Do not read any OOP texts that refuse to start with a discussion of objects from the first page. This book simply gets it right!

In addition to the great topic coverage, the authors use the BlueJ environment to demonstrate OOP concepts. This environment is unique (and free) and allows students to explore OOP in a way that other programming environments simple don't provide.

Not only do the authors clearly discuss OOP but they also discuss important software engineering concepts along the way.

Buy this book, work through the incremental exercises, and you will not be disappointed.

This book is what I've always looked for, it doesn't expect you to know anything about OOP or even programming. Step by step the author takes you into the concepts of OOP. There are no "hidden" steps, that you must understand without explanation, every construct that is used is explained when it's used, and the steps are small enought to give everyone the time to understand everything thoroughly. The book has always additional excercises for every chapter, that help you to retry the concepts you've learned. This is very helpful because you might have the feeling that you'd understand what you've read, but it might be that you just understood the example not the concept itself. So I can recommend this book to everyone who wants a real good start in Java and OOP. This book is not meant as a reference book, it's meant for teaching yourself and others in the basics of Java and OOP with the help of BlueJ.

This book is intended to be a course text book for an introductory course in Java and Object Oriented Programming. The authors have made a conscious decision to cover the material in a different order to almost all other books on the subject. You won't find an initial chapter on classpaths, compilation and the main method, there's no pseudo-procedural "hello, world" example. The book leaps straight in to creating objects from classes, examining values and calling methods.

There is a trick to all this, of course. The book is based on a kind of Java development environment optimised for teaching called "BlueJ". BlueJ is a free download, and a copy is included on a CD with the book, along with all the source code examples. I've had a play with BlueJ, and it certainly makes important things like the distinction between a class and an object, and the inheritance structure of the code, much clearer than traditional IDEs.

If you are planning to teach a course on Java or OO, you should certainly take a look at this book. Even if you don't run the course exactly as presented, the approach is fascinating. If you are trying to pick up these tricky ideas on your own, this book might also be very useful. Even if none of those cases apply, the BlueJ software is still a really neat tool for prototyping.

Finally, a book that teaches objects and Java without any procedural programming baggage!

Unlike other books that introduce objects in chapter 4 or 5 (almost as an afterthought!) and start out with the pre-object "Hello World" program, this book dives right into creating objects and manipulating them. "public static void main" doesn't even rear it's ugly head until half-way through the book, where it belongs. The included Bluej IDE ... is incredibly easy to use and it's very intuitive.

I bought a copy of this for the library at work to help my team of procedural COBOL programmers understand objects and Java. It seems to be more valuable than the other books purchased and several thousand dollars of training.

Another benefit is that the examples you write from the text are actually useful tools!

Please, seriously consider getting this book if you are starting to learn Java or just don't quite understand objects. It will spare you a lot of frustration.

I didn't buy this book for an introductory course in college, I bought it cause I wanted to go through some topics that weren't that clear for me. I definitely have to say this is a great book for reading. As some others have said, this is no reference book, this one is for enjoying and learning basic concepts not nicely taught in college. Buy it if you are a newbie or a not so newbie who wants to review important things in OOP and Java. An important thing is that since this is not a reference book, you won't find many examples regarding a certain topic... for that you can use the internet

I haven't finished it yet, but so far so good !!

This text is so refreshing. It is presented using a more contemporary
approach than any other text on the market. (Believe me I have seen
a lot of them) because its presentation is pure concept without
overburdening one with unnecessary details.

Concepts are only introduced at a level necessary to understand the
task at hand and revisited later in different contexts to deepen one's
understanding. Project programs are relevant and many issues can be
learned from reading the source code. The authors have students
designing parts of programs from the first chapter. If you want to be a
professional programmer or a software engineer this book is for you !

The text is in tutorial style using the BlueJ IDE. The BlueJ IDE is
so visual and displays a UML like diagram representing classes
and relationships in the program projects. By using the BlueJ IDE
(included on the CD along with all the coding)
one can "feel" what it means to create an object, call a method, or pass
a parameter. One of the authors is a developer of the BlueJ IDE.

One is taught how to structure a vaguely described problem into classes
and methods. The text even includes a complete case study where all
topics discussed earlier are revisited ...from application design through
design of class interfaces, to discussing many important functional
and non-functional characteristics and implementation details.
You will see reliability, data structures, class design, testing and
extensibility applied in a new context.

Do all the exercises conscientiously and you will discover what I
am discovering......this textbook is worth its weight in gold. Enjoy !

I have used this book as a textbook for an introductory Java course at a community college for the last 3 semesters. Of all of the textbooks I have looked over and used (and I've seen a lot of textbooks!), this one provides the very best introduction to object-oriented programming and Java. Java's basic syntax is deceptively easy, and it's really no trick to get even the most challenged student to follow directions and get an applet working. But, that approach has not produced students who have the least clue how to write their own applet or application outside of class. The syntax-first approach does no favors for folks who have a Cobol/mainframe background either. It's the objects part of Java that is the trick -- in addition to an understanding of how to use the API documentation. Some very good examples are used to introduce OOP/OOD concepts in an orderly fashion; syntax definitely is secondary in this approach. The BlueJ tool provides a "learning IDE", which is an important teaching aid. I have had excellent results with students of many differing backgrounds, and intend to continue using this text.

This innovative and remarkable book doesn't rate 5 stars because of a lack of basic textbook support features. Some rather below-average lecture slides are provided and about 1/2 the exercise solutions are available. Absolutely no test question bank is provided. This makes teaching from this text a far more time consuming exercise than using the average textbook for any instructor, and somewhat intimidating for an instructor who does not have an excellent industry background in Java and OOP/OOD. On the other hand, there is a mailing list for teachers using this text, and I have found David Barnes and Michael Kolling as well as other instructors to be very responsive to postings to this list.

The lack of solutions may prove somewhat frustrating to self-learners as well. But, I suspect that participation in the BlueJ mailing list should provide the support needed.

Not all intro Java books are created equal, and this one is definitely worth the price.

I've had formal education in 3 programming languages, and this book is by far the best one I've ever read. It's because the chapters walk you through the design, implementation, and refactoring of actual Java projects. Vocabulary and concepts are taught in the process, so you find yourself absorbing the facts by necessity.

The book comes with an application called BlueJ, which models Java classes and object relationships. You can check your work against code samples on the CD as you complete the milestones of each project.

If you learn by doing, and you need to learn Java and OO, this book is for you.

More than that, after more than 20 years in IT, this is also the best IT text book I have ever read, end of story. I had done a 5-day Java course some months before I read the book, and found it a real slog. Just as the authors claim, the syntax first approach which was used in the course, was as confusing as hell for all of us old COBOL mainframers there.

Although you may find BlueJ is not without its bugs, the concept behind it, of visually displaying objects, and not emphasizing the Java Main method, is truly inspired (get the book if you dont know what I mean)!

One thing: make sure you get the 2nd ed of this book, I found some annoying quirks in the 1st first edition, that the authors have cleaned up here(eg, you had to trawl thru their website to get some of the install instructions).