Review-Core Java
Volume Number: 15
Issue Number: 5
Column Tag: Programmer's Bookshelf
Review: Core Java, Fundamentals
by Paul E. Sevinç, Switzerland
4th edition covering Java 2
About This Article...
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.
About The Book...
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.
Introducing Java
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.
Java & OOP
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.
GUIs
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.
More Core
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.
Conclusion
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?
References
• [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.