This document is intended to help those familiar
with the second edition of Java Software Solutions understand the
changes that were made to create the third edition. If you are new
to the book in general, you may want to begin with an overview
and a scan of the Table of Contents.
In preparing for the third edition of the book, we had many discussions
with instructors using the book to find out what they liked and what
they didn't like about the second edition. Addison-Wesley
executed a sweeping user survey with this goal as well. We want to
thank everyone who provided feedback in any form. Our goal is ongoing
improvement.
After carefully reviewing your input, our overall philosophy became
"don't fix it if it isn't broke." Your feedback made it
very clear that you liked the overall flow of topics in the book,
the tone of the writing, the nature of the examples, the use of the
Keyboard class, and the issues covered. Thus, our changes did not
affect these key areas much.
We begin this document with a discussion of the general changes that
affect the whole book, as well as the few significant topic modifications.
The remainder of this document details the changes made to individual
chapters and the appendices. Page references are from the third edition.
You can jump to a particular chapter with the following links.
1 | 2 | 3
| 4 | 5 | 6
| 7 | 8 | 9
| 10 | 11 | 12
| Appendices
General Changes
The following general changes were made for the third edition:
 |
The book is now published in full color.
This is one of the first CS1 textbooks to do this. We made sure
to use color to a pedagogical advantage. One aspect of this
is the syntax coloring of the source code. We made sure to avoid
the "alphabet soup" coloring schemes you sometimes
see and kept things fairly simple: comments in green, reserved
words in blue, the rest in black. Reserved words are in blue
in the regular flow of the text as well. |
|
We've added examples throughout the book.
These include some additional full listing programs as well
as many more code fragments interspersed among the discussions. |
|
We performed a sweeping review of all of the writing
to create improved topic discussions throughout the book,
even in areas where significant changes were not made. |
|
Another important change was the increased and
improved end-of-chapter problem sets. There was over
a 56% increase in self-review questions, exercises, and programming
projects. The problem set
revision details provides a numeric chapter by chapter breakdown. |
|
The book now covers UML diagrams and uses
them to illustrate program designs. We focus on class and object
diagrams, specifically avoiding getting bogged down in the plethora
of detail in the UML world, much of which is not relevant to
CS1 students. |
|
The most significant topic revision for the third
edition is the modified and additional coverage of GUIs.
The graphics track sections in Chapters 5 through 9 were completely
overhauled to present a far more intuitive, comprehensive coverage
of topics related to the development of Grahical User Interfaces. |
|
The details underlying the Keyboard class
are now covered earlier (Chapter 5). The book examples still
use the Keyboard class throughout, which simplifies the code
and offers a wonderful example of abstraction. But now the unadorned
Java I/O issues can be explored earlier if desired. |
|
The topic of object serialization, briefly
introduced in the second edition, is discussed in far more detail
now, with examples. |
Chapter 1 - Computing Systems
Chapter 1 remains an overview of computing systems including hardware,
networks, and the Web. These issues establish some important groundwork
and terminology, but could be skimmed, skipped, or left for reading
as desired. The introduction to programming languages in this chapter,
however, is fundamental to the rest of the book.
Some specific changes made in Chapter 1 include:
|
The hardware specification in Figure 1.8 was updated.
(p. 11) |
|
A discussion of CD and DVD technologies was added.
(p. 16-17) |
|
The list of Java reserved words in Figure 1.19
was updated. Several that were held in reserve are no longer,
and strictfp was added. (p. 35) |
|
The editing-translating-executing process is explained
in more detail. (p. 41-42) |
|
An overview of the Java 2 Platform editions (standard,
enterprise, and micro) was added. (p. 46) |
Chapter 2 - Objects and Primitive Data
Chapter 2 discusses basic issues related to the management and use
of objects and data. Now the discussions stress object-speak
even more, making sure even simple examples are discussed with respect
to an object-oriented approach.
Some specific changes made in Chapter 2 include:
|
A brief overview of OO issues (classes, objects,
and inheritance) was added to the beginning of the chapter to
establish some terminology. (p. 62-63) |
|
Specific examples of primitive type declarations
were added. (p. 78-80) |
|
The syntax diagram of the import statement now
indicates that the package name is required. As of version 1.4,
classes cannot be imported from the "unnamed name space." |
|
The random number generation examples now rely
largely on the nextInt(n) method of the Random class. The emphasis
is therefore shifted away from scaling the random results. (p.
95-98) |
|
The quadratic formula is presented in equation
form to help explain the Quadratic program example. (p. 102) |
Chapter 3 - Program Statements
Chapter 3 explores key programming statements, mainly conditionals
and loops, and introduces the need for a careful development process.
The statements covered in this chapter allow the classes written in
the Chapter 4 to be realistic and comprehensive.
Some specific changes made in Chapter 3 include:
|
The stages of program development are now presented
at the beginning of the chapter to set the stage. (p. 130-132)
The ExamGrades example that formally follows these stages is
still presented toward the end of the chapter. |
|
Many additional code fragment examples are included
in the discussions of conditionals and loops throughout the
chapter. |
|
In the discussion of the switch statement, we
clarified that only int and char types are valid for the switch
expression (p. 145) |
|
The details of comparing characters and strings
(lexicographic ordering) are now explained in more detail. (p.
151-152) |
|
The issues related to the palindrome testing example
have been refined. (p. 166-169) |
|
The StringTokenizer class is now introduced in
Chapter 3 (in the second edition it was somewhat buried in Chapter
4). The class is presented with a new example, stressing its
natural relationship to loop processing. (p. 169-173) |
|
In the three applets presented at the end of the
chapter, the constants were moved into the paint method because
declaring class level data is not covered until Chapter 4. (p.
188-195) |
Chapter 4 - Writing Classes
Chapter 4 remains an introduction to writing programs with multiple
classes and methods. Note that we never present a program that consists
of a single class with multiple methods (which would be a purely procedural
approach). Once a program design is worthy of multiple methods, it
is worthy of multiple classes. This philosophy was evident in the
second edition, and has not changed.
Some specific changes made in Chapter 4 include:
|
Import statements that import a single class from
the default package, such as 'import Coin', were removed from
all examples in the book. As of version 1.4, classes cannot
be imported from the "unnamed name space." |
|
The option of having multiple classes in one file,
with one public class, is now discussed (p. 215) |
|
A discussion of the automatic initialization of
variables declared at the class level was added. (p. 218) |
|
An introduction to UML diagrams was added (p.
218-220). UML diagrams are used from here on to illustrate program
designs, and some are left as exercises. |
|
Figure 4.7 was added to drive home the purpose
of visiblity modifiers on both variables and methods. (p. 222) |
|
The section called Object Relationships was moved
after the sections Method Overloading and Method Decomposition. |
|
The introduction to the StringTokenizer class
that used to be part of the Method Decomposition section (p.
235) was moved to Chapter 3. |
|
The proper term for character combinations such
as 'th' and 'cr' is consonant blend. The discussion and
code of the Pig Latin example were changed accordingly. (p.
235-242) |
|
The list of consonant blends processed by the
PigLatinTranslator class were refined. (p. 241) |
|
The section on Object Relationships was refined
and an example for the aggregation relationship was added. (p.
243-254) |
Chapter 5 - Enhancing Classes
Chapter 5 remains a collection of issues related to the design of
classes. It is not nearly as linear as other chapters, and therefore
you have even more freedom to pick the topics of interest.
Some specific changes made in Chapter 5 include:
|
The discussions of the null and this references
were expanded (p. 270-272) |
|
The program example of static methods and variables
was made a bit more interesting (p. 284-285) |
|
A discussion of wrapper classes was added (p.
283-287) |
|
A section discussing the inner workings of the
Keyboard class was added to provide an earlier introduction
to Java I/O issues. An example presenting a non-Keyboard version
of the Wages program from Chapter 3 is presented. (p. 287-290) |
|
An example demonstrating the access issues related
to inner classes was added (p. 291-293) |
|
The second edition example demonstrating interface
declaration and use was replaced with one that is more realistic.
(p. 294-298) |
|
The discussion of polymorphism via interfaces
is now deferred to Chapter 7 where it can be compared and contrasted
with polymorphism via inheritance. |
|
A section describing dialog boxes and their use
was added. (p. 301-303) |
|
The second edition graphics track coverage in
Chapter 5 was replaced by a more natural introduction into GUI
development. Mouse and key events are deferred until later chapters.
Chapter 5 now covers push buttons, text fields, and action listeners. |
|
The coverage of animations is now deferred to
Chapter 8. |
Chapter 6 - Arrays
Chapter 6 remains an introduction to arrays and array processing.
Some specific changes made in Chapter 6 include:
|
The second edition program example called ReverseNumbers
is now called ReverseOrder to distinguish it from the Chapter
3 example called ReverseNumber. (p. 324-325) |
|
The name of the second edition section called
'Creating Object-Array Elements' was changed to the more intuitive
'Filling Arrays of Objects.' (p. 333) |
|
The CDCollection class now uses collection.length
instead of a separate integer variable. (p. 337-338) |
|
The discussion of the Vector class was replaced
by a discussion of the ArrayList class. (p. 355-358) |
|
A section describing check boxes and radio buttons
was added. The Quotes example from Chapter 9 of the second edition
was simplifed and separated into two programs, which are now
presented here. (p. 363-371) |
Chapter 7 - Inheritance
Chapter 7 is an overview of inheritance and related issues. As a primary
concept in the object-oriented paradigm, we wanted to make sure this
chapter retained its status and thereforeresisted suggestions to push
it further back in the book.
Some specific changes made in Chapter 7 include:
|
UML diagrams that depict inheritance relationships
and abstract classes and methods are presented throughout the
chapter. |
|
The coverage of indirect use of class members
was moved before the discussion of polymorphism. (p. 402-406) |
|
The book's discussion of polymorphism is now collected
here rather than being split between Chapters 5 and 7. |
|
The new (UML) diagram in Figure 7.8 for the Firm
example shows abstract classes and methods, overriding, and
the infrastructure that supports polymorphism. (p. 409) |
|
The graphics track sections were reworked. (p.
422-438) Mouse events are now covered in this chapter. |
Chapter 8 - Exceptions and I/O Streams
Chapter 8 continues to cover two somewhat related topics, exceptions
and I/O. The discussions of these issues benefit from being covered
after inheritance has been established, though it isn't absolutely
necessary.
Some specific changes made in Chapter 8 include:
|
The syntax diagram for the try statement was modified
to reflect the need for exactly one "parameter" in
a catch clause. |
|
The discussion of the Keyboard class was modified
to reflect the earlier discussion that now occurs in Chapter
5. (p. 465-466) |
|
The discussion of object serialization was augmented
significantly, including two new full program examples. (p.
747-480) |
|
A new graphics track section was added covering
file choosers, color choosers, image icons, and key events.
These discussions include severl new and revised examples. (p.
480-494) |
|
The discussion of animations, which was covered
in Chapter 5 in the second edition, was moved here. (p. 494-499) |
Chapter 9 - Graphical User Interfaces
Chapter 9 was the single most modified chapter in the third edition.
Given the revised coverage of GUI issues in the graphics track sections
of previous chapters, and our desire to add a large amount of material
on this topic, this chapter required a significant overhaul.
Some specific changes made in Chapter 9 include:
|
We added a review of the GUI issues covered thus
far in earlier chapters. (p. 508-509) |
|
The discussion of general GUI design was brought
to the front of this chapter. (p. 509-510) |
|
Layout managers are demonstrated with a new example.
The discussion of specific layout managers now includes flow,
border, grid, and box layouts. (p. 510-526) |
|
The discussion of GUI containment hierarchies
has been augmented and includes a visual example. (p. 526-528) |
|
The coverage of various special features has been
expanded, including two new full program examples. (p. 528-539) |
|
A new section on additional components was added,
including coverage of scroll panes, split panes, lists, combo
boxes, and sliders. Three new full program examples are included
in this section, plus a revised version of the Java Jukebox
example from the second edition. (p. 539-559) |
|
A section providing an overview of events has
been added, including a chart mapping components to the events
they generate. |
|
A final section describing some additional GUI
components and issues was added, prompting readers to continue
there pursuit of this huge area. |
Chapter 10 - Software Engineering
Chapter 10 remains an overview of software engineering issues with
an emphasis on development process models. A major part of this chapter
is the use of an evolutionary design model to develop a much larger
project than they otherwise see in the book -- the PaintBox project.
Most of the changes in this chapter reflect a new version of the PaintBox
software. The code for two refinements of this project are available
for anyone to download. The remaining refinements, which are assigned
as Programming Projects, are available only to instructors.
Some specific changes made in Chapter 10 include:
|
The section discussing testing was moved before
the section on prototypes. (p. 576-579) |
|
The discussoin of the PaintBox project was generally
revised to reflect the new version of the software. (p. 586-597) |
|
Figure 10.9 was added to provide a fairly specific
description of the scope for each of the seven identified refinements
for the PaintBox project. (p. 591) |
|
New (UML) diagrams in Figures 10.10 (p. 592) and
10.12 (p. 595) help illustrate design decisions in the PaintBox
project. |
|
Screen shots of the PaintBox program demonstrate
its functionality after refinement #1 (p. 593), refinement #2
(p. 596), and refinement #7 (p. 597). |
Chapter 11 - Recursion
Chapter 11 remains an introduction to recursive thinking and programming.
Very few changes were made to this chapter.
Some specific changes made in Chapter 11 include:
|
The example called MirroredPictures in the second
edition is now called TiledPictures in the third. This was done
in an effort to better describe the visual effect that the program
creates. (p. 621-623) |
Chapter 12 - Data Structures
Chapter 12 is an introduction to the world of data structures and
their representations. This chapter is not intended to serve as a
comprehensive discussion of this very large topic, but rather provide
a glimpse into issues that someone pursuing the study of computing
and programming further will likely encounter.
Some specific changes made in Chapter 12 include:
|
The domain of the library books example was changed
to a magazine rack to distinguish it from the book example used
in Chapter 7. (p. 641-644) |
|
A brief introduction to trees and graphs was added
to the section on classic data structures. (p. 650-653) |
Appendices
The appendices are designed to make the book a valuable reference
as well as a pedagogical tool. The set of appendices (their order
and general content) stayed the same from the second to third editions.
Some specific changes made in the Appendices include:
|
The Glossary entries were updated and augmented.
(p. 661-680) |
|
A brief introduction to Appendix L (Java Syntax)
was added. (p. 747) |
|
Several syntax diagrams in Appendix L were modified
to fix errors or clarify processing. (p. 747-759) |
|
Many irrelevant and/or deprecated classes were
removed from Appendix M. (p. 762-906) |
|
Many classes (mostly Swing classes) were added
to Appendix M. (p. 762-906) |
|
