ACCU Home page ACCU Conference Page
Search Contact us ACCU at Flickr ACCU at GitHib ACCU at Google+ ACCU at Facebook ACCU at Linked-in ACCU at Twitter Skip Navigation

Search in Book Reviews

The ACCU passes on review copies of computer books to its members for them to review. The result is a large, high quality collection of book reviews by programmers, for programmers. Currently there are 1918 reviews in the database and more every month.
Search is a simple string search in either book title or book author. The full text search is a search of the text of the review.
    View all alphabetically
Title:
Understanding Object-Oriented Programming with Java
Author:
Timothy Budd
ISBN:
0 201 30881 9
Publisher:
Addison-Wesley
Pages:
367
Price:
£28-99
Reviewer:
Colin Harkness
Subject:
java; object oriented
Appeared in:
10-6
You might want to compare this book with Budd's other titleAn Introduction to Object-Oriented Programming (2nd Ed). That book taught OOP with examples from many languages, whereas this one deals solely with Java.

Certainly Java is a good language with which to learn OOP. The language is relatively clean. You have a large standard library from which to take examples of inheritance, polymorphism, interfaces, frameworks and patterns. Compilers are generally quite up-to-date and cheap (or free). You can create visual applications without being tied to one compiler vendor and/or platform. This is important. Most students will have modern graphical PCs at home. Displaying Pascal's Triangle on a DOS box is not likely to impress.

Budd makes good use of these advantages. Throughout the book, OO concepts are discussed with examples from the Java library. This is infinitely better than the usual dull attempt at a String or Stack class. Readers are taught to build on the framework rather than have to write everything from scratch, which is one of OOP's selling points. While some of the examples are academic cliches (Fibonacci series and prime numbers) many are much more fun and graphical (Pinball and Solitaire games). Difficult ideas like composition vs. inheritance, overloading vs. overriding and various design patterns are very well explained.

I found this book easy to read and understand. (In comparison, I never did finish Booch's book.) Its slim dimensions (367 pages) are a definite advantage. A professional programmer might think something like Bruce Eckel'sThinking in Javawas better value (1098 pages) but I doubt many students would thank their lecturers for making them read it.