Volume Number: 15 (1999)
Issue Number: 5
Column Tag: Programmer's Bookshelf

Review: Core Java, Fundamentals

by Paul E. Sevinç, Switzerland

4th edition covering Java 2

This article reviews volume 1 of the 4th edition of Core Java [Horstmann and Cornell 1999].

Core Java is a two-volume book-set written by Cay Horstmann and Gary Cornell, and published by Sun Microsystems Press and Prentice Hall. Volume 1, subtitled Fundamentals, has been available since December 1998. Volume 2, subtitled Advanced Topics, will be available some time in 1999.

For simplicity, the 4th edition of the 1st volume of Core Java will be referred to only as Core Java in the remainder of this review.

Core Java is an introduction to Java 2 Platform -formerly named JDK 1.2- by Sun Microsystems. (Note: The first printing still refers to it as JDK 1.2.)

According to the authors, Core Java has been written for experienced programmers, i.e. programmers with experience in at least one procedural programming language (e.g., C or Pascal). I'll let you know who I personally think this book is well suited for at the end of the article.

Core Java consists of 12 chapters and 3 appendices as well as an accompanying CD. The major topics are: object-oriented programming (OOP), graphical user interfaces (GUIs), programming for the WWW, exception handling, and input/output (I/O). The CD contains all of the book's source code and freeware & shareware tools in Solaris and Windows (no Mac OS) versions.

Throughout the book, when appropriate, the authors compare Java to Visual Basic and C++. Not being a Windows developer, the Visual Basic notes were of no use to me. The C++ notes, on the other hand, ease the transition from C++ to Java. Here is a simple example: after the integer types have been introduced, a C++ programmer is told that there are no unsigned integers in Java.

Also, when a new standard Java class is introduced, it is followed by an abbreviated version of its interface which allows for a quick overview of its most important methods. Reprinting all of them in alphabetical order at the end of the book would have been a nice thing.

The first chapter, An Introduction to Java, is about Java in general: Java's history, how Java relates to the Internet, misconceptions about Java, etc. What I really liked about this chapter is that the authors don't mislead the beginner by blindly following the Java hype. Instead, they state that Java is a good programming language but could have been better, and they also point out that some of the concepts Java is famous for have been around for decades (e.g., Niklaus Wirth made platform-independent compilation popular in the seventies).

Chapter 2, The Java Programming Environment, is Windows specific and can be skipped by Mac-only developers.

Chapter 3, Fundamental Programming Structures in Java, is the chapter that relies most strongly on former experience in procedural programming (e.g., it explains how variables are declared, not what variables are). It covers data types (primitive data types and strings) and their operators, constants and variables, arrays, flow control (conditional statements and loops), and basic console I/O. In Horstmann's and Cornell's opinion, C++ programmers can skim through this chapter; I don't think so. The differences between Java and C++ are big (or rather subtle) enough to cause annoyances. By investing a little time in carefully reading this material, most of them can be avoided. Programmers with a different background (Pascal, say) probably need to read certain paragraphs -or even the whole chapter- more than once, but they shouldn't have any serious problems either. I missed two things only in this chapter: a short explanation of the difference between do-while and repeat-until loops, and that a simple statement can also act as the body of a loop.

The 4th, 5th, and 6th chapters, Objects and Classes, Inheritance, and Interfaces and Inner Classes, are an introduction to the OOP paradigm and how it is supported by Java. Chapter 4 shows how abstract data types (ADTs) are implemented in Java. But first, some OOP vocabulary is introduced and illustrated using clear analogies. (By the way, the authors also recommend two books on object-oriented design and the Unified Modeling Language; the best introduction to OOP I know is [Mössenböck 1998] which, alas, is not available in English at the time of this writing.) Finally, Java's package concept is explained.

Chapter 5 is likely going to split the Core Java readers into two groups. Those in the first group have some basic experience with OOP and love how fast Horstmann and Cornell get to the point. Those in the second group don't have any OOP knowledge prior to reading Core Java and are confused when done with Chapter 5. So should you forget about Core Java if you're going to be in the second group? Not necessarily; just skip the last two paragraphs about run-time type identification (RTTI) and reflection (these are topics I would rather have expected in volume 2). Matters should become clearer when you see object orientation in action.

Chapter 6 is a short chapter on interfaces (Java's construct for multiple inheritance), inner classes, and cloning (deep copying). In the inner-classes sections, the reader also learns about some compilation techniques and possible bytecode security risks.

Despite its importance, the first third of the book isn't very exciting - after all, we do not use PowerMacs because we're fond of console I/O. And even though the core language isn't fully covered yet (exception handling is still missing), a really cool topic is the content of the next three chapters: how to design and implement GUIs.

Chapter 7, Graphics Programming, answers fundamental questions regarding GUIs: What are windows in Java? How can different fonts be used when showing text? Etc. What's important to know is that when there is a choice between a Swing class and an AWT class (UI classes where the former replace the latter which were the only ones in Java 1), the Swing class is used. This future-oriented approach is good unless you have to maintain old Java code. The chapter ends with some simple drawing routines.

Chapter 8, Event Handling, covers the Java event model. As a Mac OS programmer, you're already used to event-driven programming, but Java's events are comparatively high-level (objects vs. constants). Horstmann and Cornell make the whole process of learning about broadcasters, listeners, and multicasting so painless that at the end of the chapter, these concepts almost look trivial.

The 9th chapter, User Interface Components With Swing, is by far the biggest, with more than 150 pages. Every UI element I could spontaneously think of is covered: radio buttons, menus, dialogs, text areas, and many more. (Note: volume 2 will cover some components, such as toolbars, too.) At the beginning of the chapter, the model-view-controller (MVC) pattern is introduced (design patterns are to OOP what algorithms & data structures are to procedural programming [Mössenböck 1998]). Knowledge of MVC is especially necessary for some advanced modifications (i.e., subclasses) of the elements. But these advanced sections can safely be skipped and the authors also say so.

Chapter 10, Applets, shows what changes are necessary in order to turn an application into an applet - that's the easy part. The tedious part is how to make the applet behave properly on different platforms using different browsers. It's not the authors' fault that this is tedious; actually, they do a pretty good job of showing the possibilities one has with the Java plug-in or with older versions of Java.

Chapter 11, Exceptions and Debugging, could -from a purely technical point of view- directly follow Chapter 6 in order to cover the whole language before the Java classes. But from a pedagogical point of view it was smarter to arrange the chapters the way they are; more so because, oddly enough, exceptions are hardly an issue before Chapter 12. After Java's strict rules concerning exceptions and exception syntax and use have been covered, some debug advice is given. Its essence is: either make no mistakes when coding (...) or get a commercial debugger.

The 12th and last chapter, Streams and Files, is mainly about storing information in files. Again, some of the more technical issues (e.g., how does object serialization work in detail) can be skipped. Some security issues are discussed, too. What's going to be useful beyond file manipulation are the sections about streams, but how they relate to network programming is another topic to be found in volume 2.

Core Java is a book that evolved with Java, throwing away text of older editions to replace it with up-to-date information. It is well suited for self-study (beware: there are no exercices), but if most of your books end with "for Dummies", don't even think about buying this one. The examples are very illustrative, even though I would still consider them toy examples.

Programmers with some OOP experience will find it most useful; for those familiar with Java 1.1 it's overkill. Beginners with little practical programming experience might be overwhelmed unless learning procedural programming was no challenge.

If Core Java: Fundamentals is not the best book about this topic, it is still one of the better. And I am certainly going to take a look at Core Java: Advanced Topics. What about you?

• [Horstmann and Cornell 1999] HORSTMANN, Cay, CORNELL, Gary. Core Java: Fundamentals. Sun Microsystems Press / Prentice Hall, 4th edition 1999.
• [Mössenböck 1998] MÖSSENBÖCK, Hanspeter. Objektorientierte Programmierung in Oberon-2. Springer, 3rd edition 1998.

Paul E. Sevinç is an EE student at the Swiss Federal Institute of Technology Zurich (ETHZ) -where he recently designed and implemented a C++ framework for multiobjective optimization with genetic algorithms- and a student member of the IEEE. He is very interested in Compiler Construction, Operating Systems, and Cryptology, but he also likes working as a swimming coach. You can reach him at psevinc@stud.ee.ethz.ch.