Book Information


Authors: Cay S. Horstmann
Paperback: 864 pages
Publisher: John Wiley & Sons; 3 edition (June 6, 2003)
Language: English
ISBN: 0471469009
Product Dimensions: 9.5 x 7.4 x 1.4 inches Link

 Book Review

In the software industry over the years, many different languages have risen to the forefront. Many have disappeared, after a brief flash of popularity. Some, such as C and C++ have kept their popularity and usefulness, and some, such as LISP, COBOL, or FORTRAN have faded with the passage of time.

In universities and colleges around the world, another language is being taught. Java is a young language that is quickly rising in popularity among applications programmers the world over, due to it’s pure Object-Oriented structure, C++-based syntax, extensive system libraries, and protective abstraction from system hardware. Due to it’s use of the Java Virtual Machine (JVM), Java is easily portable between many different environments and architectures, and will run on any system for which a Virtual Machine has been written. Java, as a language scales from small mobile devices such as cell phones and PDAs, to enterprise-level server applications.

Computing Concepts With Java Essentials is a well-written book by Dr. Cay Horstmann, a leading author of texts and references in areas such as Java, C++, and general Object-Oriented design. This book provides an introduction to Object-Oriented design through the use of the Java programming language.

Aimed at beginning to intermediate programmers, this book starts right from basic subjects, such as “What is a Computer”, to more advanced topics such as sorting and searching methods and recursion. While on the journey, Horstmann touches on subjects including the software life cycle and data structures.

The focus of this book is on good Object-Oriented coding practices and guidelines. Horstmann, in the preface, divides the book into 3 separate sections. The first eight chapters of this book were meant to be an introduction to the fundamentals of Object-Oriented programming, covering basic topics such as classes, objects, variables, strings and control structures. The second section, chapters nine through sixteen, covers more advanced topics, including inheritance, arrays, exceptions, streams, and GUI programming. The last section, chapters seventeen through nineteen, contains an introduction to data structures and algorithms, covering recursion, sorting and searching, linked lists, binary trees, and hash tables.

Horstmann’s style is simple, and easy to understand. He presents his material in a logical fashion. When presenting a subject, he will begin with a general introduction to the topic, showing common errors, productivity hints, and best practices in separated sections along the way. Occasionally Horstmann will move into an ‘Advanced Topic’ section where he will consider a more complex area of a chapter’s subject. Horstmann also makes good use of Java code examples to portray his thoughts in a tangible way, which students and readers can take and try themselves. Quite often, to demonstrate a subject, Horstmann will lead the reader through the design of an entire program, in order to drive a point across.

At the end of every chapter is found a quick summary of the chapter, references for further reading, a list of classes, objects and methods introduced in the chapter, and a set of exercises, for the reader to test his knowledge, and apply the subjects learned in the chapter. These exercises range from trivial questions based on the reading, to in depth programming projects which could require 5-6 hours of work to complete.

This book is very well written, and leads to a good working knowledge of Object-Oriented design, and the Java programming language. Although weak in content for more advanced programmers who already have a good knowledge of Object-Oriented programming, this book provides a good basis for a beginning programmer to start his journey into the world of modern programming.

 Table of Contents


  1. Introduction
  2. An Introduction to Objects and Classes
  3. Fundamental Data Types
  4. Applets and Graphics
  5. Decisions
  6. Iteration
  7. Designing Classes
  8. Testing and Debugging
  9. Interfaces and Polymorphism
  10. Event Handling
  11. Inheritance
  12. Graphical User Interfaces
  13. Array Lists and Arrays
  14. Exception Handling
  15. Streams
  16. System Design
  17. Recursion
  18. Sorting and Searching
  19. An Introduction to Data Structures

Appendix A1: Java Language Coding Guidelines.

Appendix A2: Java Library

Appendix A3: The Basic Latin and Latin-1 Subsets of Unicode.

Appendix A4: Glossary


 Overview of Chapters

Chapter 1: Introduction

  • Basics of a computer
  • Compiling
  • How to write a simple program
  • Compiling errors

Chapter 2: An Introduction to Objects and Classes

  • Basics of Objects and Classes
  • How to design and test a class
  • Instance fields, constructors, public interfaces
  • Specifying implementation
  • Variable types
  • Explicit and implicit method parameters

Chapter 3: Fundamental Data Types

  • Number types, assignment, constants
  • Mathematical functions
  • Type conversion
  • How to use Strings
  • How to call static methods
  • How to get input
  • How to compare primitive types and Objects

Chapter 4: Applets and Graphics

  • How to write simple applets
  • How to draw complex shapes
  • How to make different colors
  • How to compare visual and numeric information
  • How to use different fonts

Chapter 5: Decisions

  • How to use the ‘if’ and ‘else if’ statements
  • How to compare values
  • How to use Boolean expressions

Chapter 6: Iteration

  • How to use loops
  • How to use loops to process information
  • How loops are used with random numbers and simulations

Chapter 7: Designing Classes

  • How to choose which classes to use
  • What the difference is between accessor and mutator methods
  • What preconditions and postconditions are
  • How to use static methods and fields
  • What variable scope is
  • What packages are

Chapter 8: Testing and Debugging

  • What is testing
  • How to perform unit tests and regression testing
  • How to use a debugger

Chapter 9: Interfaces and Polymorphism

  • What do you do to develop reusable code
  • How to convert between types
  • What Polymorphism is
  • How to process timer events

Chapter 10: Event Handling

  • What events, event listeners, and event sources are
  • How to process mouse and text inputs

Chapter 11: Inheritance

  • What inheritance is
  • What inheritance hierarchies are
  • What subclasses are, and how to construct them
  • How to perform access control

Chapter 12: Graphical User Interfaces

  • What is Swing, and how to use it
  • How to use inheritance to customize frames and panels
  • How to manage your layout
  • How to create menus, and choices

Chapter 13: Array Lists and Arrays

  • What array lists are, and simple algorithms for array lists
  • How to declare and access arrays
  • How to store numbers in array lists
  • How to copy arrays
  • How to use multi-dimensional arrays

Chapter 14: Exception Handling

  • What exceptions are
  • How to throw and catch exceptions
  • How to design your own exceptions
  • What the ‘finally’ clause does

Chapter 15: Streams

  • What Streams, Readers and Writers are
  • How to read and write text files
  • How to use file dialogs
  • What command line arguments are, and how to use them?
  • What an object stream is
  • What random access is, and how it works

Chapter 16: System Design

  • What the Software Life Cycle is
  • How to design classes, and create interfaces

Chapter 17: Recursion

  • What recursion is, and why it is effective
  • How to debug recursive programs
  • What the halting problem is, and how it applies to recursion
  • What mutual recursion is

Chapter 18: Sorting and Searching

  • What the difference is between the bubble sort, selection sort, quicksort and merge sort
  • How to determine algorithm efficiency with big-Oh notation
  • How linear search and binary search methods work
  • What it means for two objects to be ‘comparable’

Chapter 19: An Introduction to Data Structures

  • What linked lists are, and how to implement them
  • What the difference is between abstract and concrete data types
  • How stacks and Queues work