Last updated October 6, 2002.
Add the keyword assert to the table.
"Casting the reference literal null, which is not of any type, to a reference type results in a compile time warning."
and should be replaced by:
"The reference literal null can be cast to any reference type."
(a) Member variable i is accessible in all classes in other packages.
(b) Member variable j is accessible in all classes in other packages.
(c) Member variable k is accessible in all classes in other packages.
(d) Member variable k is accessible in subclasses only in other packages.
(e) Member variable l is accessible in all classes in other packages.
(f) Member variable l is accessible in subclasses only in other packages.
In the middle of the page, replace the line beginning with:
" setKWH from the superclass ... "
with:
" setWatts() from the superclass ... "
Change choice (e)
(e) The overriding method can have a different return value than the overridden method.
to (replace "value" with "type"):
(e) The overriding method can have a different return type than the overridden method.
With line (2) uncommented, the compiler distributed with J2SE 1.4 compiles the code without error. However, this is a recent change to the Sun compiler. We cannot see that the Java Language Specification (JLS) has been changed to allow such disambiguation, and other standards compliant compilers such as IBM's Jikes still reject the code. We don't know whether this is a case of misinterpreting the JLS, or a bug in the Sun Java compiler distributed with J2SE 1.4.
In the paragraph for Blocked state, make the following two changes:
Change "Blocking state" to "Blocked state".
Change the sentence:
"A thread also blocks if it fails ..."
to:
"A thread will be blocked if it fails ..."
The bullet:
"The wrapper classes (Boolean, Character, Number, Byte, Short, Integer, Long, Float, Double)"
should read (delete Number):
"The wrapper classes (Boolean, Character, Byte, Short, Integer, Long, Float, Double)"
In the middle of the page, change "\u0000" to '\u0000'.
The sentence:
"The remove() method deletes and returns the element at the specified index, contracting the list accordingly."
should read:
"The remove(int index) method deletes and returns the element at the specified index, contracting the list accordingly."
The following import statement can be deleted:
import java.applet.*;
The sentence:
"The Polygon class has the following constructors:"
should read:
"The Polygon class has the following constructor:"
In the row for the PrintWriter, change the sentence:
"A filter that allows textual representations of ..."
to:
"A writer that allows textual representations of ..."
Change the exception in the constructors:
RandomAccessFile(String name, String mode) throws IOException
RandomAccessFile(File file, String mode) throws IOException
to:
RandomAccessFile(String name, String mode) throws FileNotFoundException
RandomAccessFile(File file, String mode) throws FileNotFoundException
In the middle of the page, replace the following:
"It also has a special method that has the same name as the class. Such methods are called constructors, ..."
with:
"It also has a special method-like declaration that has the same name as the class, (2). Such declarations are called constructors, ..."
In the middle of the page, replace the sentence:
"Static members are distinguished from instance variables in a class definition by the keyword static in their declaration."
with:
"Static members are distinguished from instance members in a class definition by the keyword static in their declaration."
Replace the last row of the table:
-2147483648 |
-017777777777 |
-0x7fffffff |
with:
-2147483648 |
-020000000000 |
-0x80000000 |
"Narrowing conversions between char and byte (or short) values on assignment always require an explicit cast, even if the value is in the range of the destination datatype."
The new rules state that a narrowing primitive conversion is valid if the following conditions are fulfilled:
1. The right-hand side expression (i.e. source) is a constant expression
of type byte, short, char or int.
2. The type of the left-hand variable (i.e. destination) is byte, short,
or char.
3. The value of the constant expression is in the range of
the destination datatype.
Replace the following sentence in the lower half of the page:
"The value LITTLE_ADVICE results in only one advice at (5) being given."
with:
"The value LITTLE_ADVICE results in only one advice at (4) being given."
To make the figure consistent with Example 7.2, do the following:
In the figure, add public accessibility, '+', to the class AccessInTopLevelClass.
In the figure, remove public accessibility, '+', from the interface NestedTopLevelInterface1.
On top of the page, replace the line:
String replace(char old, char new)
with:
String replace(char oldChar, char newChar)
Replace the question:
"What would be the effect of calling enableEvent(AWTEvent.KEY_EVENT_MASK) on a component?"
with:
"What would be the effect of calling enableEvents(AWTEvent.KEY_EVENT_MASK) on a component?"
In the middle of the page, replace the sentence:
"Note that the first read() method read a byte, but returns an int value."
with:
"Note that the first read() method reads a byte, but returns an int value."
In the lower half of the page, replace the line:
FileOutputStream(File file) throws IOException
with:
FileOutputStream(File file) throws FileNotFoundException
Replace the following:
Information about the JDK and its documentation can be found at the following web site:
<URL:http://java.sun.com/products/jdk/1.2/>
with:
Information about the Java 2 SDK Standard Edition (referred to as JDK in the book) and its documentation can be found at the following web site:
<URL:http://java.sun.com/j2se/>
A short note on creating and using packages.
A package statement can only occur as the first statement in a Java
source file.
The statement
package com.acme;
instructs the compiler to place the Java byte code for all the classes (and interface) specified in the source file in the package com.acme.
Think of a package name as a path in the file system.
In this case the package name com.acme corresponds to the path name com/acme.
So the Java byte code for all the classes (and interface) specified in the
source file Exercise1.java will be placed under the catalog com/acme.
Question: where is com/acme?
You can choose the location of com/acme by using the -d option
(d for destination) when compiling with javac. Assume that the
current directory is called work, and the source code file Exercise1.java
is to be found here. The command
javac -d . Exercise1.java
(note the dot after the -d option to indicate the current directory) will create com/acme under the current directory, and place the Java byte code for all the classes (and interface) in it.
work
|
------------------------
| |
Exercise1.java com
|
acme
|
Exercise1.class
How do we run the program? Since the current directory is work and we want to run Exercise1.class, the *full name* of the Exercise1 class must be specified in the java command:
java com.acme.Exercise1
This will now result in the main() method from the com.acme.Exercise1 class being executed.
Replace the sentence in the lower part of the page:
"The same applies to the reference literal null, which is not of any type and therefore cannot be cast to any type."
with:
"Casting the reference literal null, which is not of any type, to a reference type results in a compile time warning."
float fast = (float) 100.5D; // Narrowing: double to float.
with (gives a better example of truncating):
float fast = (float) 300.5D; // Narrowing: double to float.
Replace the line:
"At (1) in the examples above, both the byte value in v1 and the char value in v2 are first promoted to int."
with:
"At (1) in the examples above, both the char value in v1 and the byte value in v2 are first promoted to int."
Replace the sentences:
"The number of bits shifted is always in the range modulus 32 for an int value, and in the range modulus 64 for a long value."
with:
"The shift distance is calculated as the value of the expression (right operand value & (size-1)), where size is either 32 or 64 depending on whether the promoted type of the left operand is int or long. Thus the shift distance is always in the range 0 to 31 when the promoted type of left operand is int, and in the range 0 to 63 when the promoted type of left operand is long."
= 0xfffffffa
with:
= 0xfffffffd
= 0xc0
with:
= 0x80
At the top of the page, replace the following:
"..., and therefore does not apply to local arrays as well (Section 2.9, p. 34)."
with:
"..., and therefore does not apply to local array variables as well (Section 2.9, p. 34)."
Extra horizontal line in the class diagram for matrix:double[][] should be deleted.
The last sentence of this page:
"The method definition in the subclass can only specify all or none, or a subset of the exception classes (including their subclasses) specified in the throws clause of the overridden method in the superclass."
should be replaced with (insert checked ):
"The method definition in the subclass can only specify all or none, or a subset of the checked exception classes (including their subclasses) specified in the throws clause of the overridden method in the superclass."
In the last sentence of this section, replace the following:
"...: the variable accessed is from the class corresponding to the reference type, ..."
with:
"...: the variable accessed is declared in the class corresponding to the reference type, ..."
Replace the code lines:
// Definitions:
interface A {};
class B {};
class C extends B implements A {};
class D implements A {};
with (remove ;):
// Definitions:
interface A {}
class B {}
class C extends B implements A {}
class D implements A {}
In the last line, replace "massage" with "message". :-)
Replace the sentence:
"The System.gc() method can be used to force garbage collection, and the System.run Finalization() method can be used to run the finalizers (which have not been executed before) for objects eligible for garbage collection."
with:
"The System.gc() method can be used to request garbage collection, and the System.run Finalization() method can be called to suggest that the finalizers (which have not been executed before) for objects eligible for garbage collection be run."
In the line that starts "Dead state: ...", replace "Runnable" with "Running".
Delete the following lines:
void select(String str)
Selects the item that matches the argument string in the list.
(top, left)
with:
(left, top)
"The origin of the drawing region in a component is given by (getInsets().top, getInsets().left)."
with:
"The origin of the drawing region in a component is given by (getInsets().left, getInsets().top)."
Replace the sentence:
"Root components JComponent, JWindow, JFrame, JDialog and JApplet all extend their respective native AWT components, as shown in Figure 17.5."
with (delete JComponent):
"Root components JWindow, JFrame, JDialog and JApplet all extend their respective native AWT components, as shown in Figure 17.5."
Replace the sentence at the top of the page:
"Also platform-dependent, the canonical path usually specifies a pathname in which all relative references have been completely resolved."
with (insert "absolute"):
"Also platform-dependent, the canonical path usually specifies an absolute pathname in which all relative references have been completely resolved."
In the upper half of the page, replace the sentence:
"The PrintStream class is now mostly deprecated, but its print() methods, which act as corresponding print() methods from the PrintWriter class, can still be used to write output to System.out and System.err."
with:
"The PrintStream class offers print() methods which act as corresponding print() methods from the PrintWriter class. These methods can be used to write output to System.out and System.err."
To the existing list, add the following:
@see <class-name>#<member-name> <label>
@see <class-name>#<method-signature> <label>
{@link <class-name>#<member-name> <label>}
{@link <class-name>#<method-signature> <label>}
Additional explanation:
Strict adherence to the Java language specification requires the following declaration to start the execution of a Java program:
public static void main(String[] args)
This does not rule out any other legal non-accessibility modifiers like final. The Java compiler is however taking liberties with the specification allowing other declarations for starting the execution of a Java program.
See also the note on Inheritance of Superclass Members at the end of this errata.
Replace the line:
"... , but rather uses the public interface."
with:
"... , but rather uses the public method describe() in class Star to do that."
Replace the answer with:
18.2 (b)
The separator constant is of type String and contains the character used as path separator on the native platform. The most common platforms only use a single character as a path separator.
public class BinConversion {
public static void main(String args[]) {
System.out.println(convert(43));
}
public static String convert(int i) {
String res = "";
do {
res = i % 2 + res;
i /= 2;
} while (i >= 1);
return res;
}
}
Choice (d):
The value returned by >>> will never be negative as long as the value of the right operand is not divisible by 32.
should be replaced with:
The value returned by >>> will never be negative as long as the value of the right operand is not divisible by 32, and the left operand is non-negative.
Replace the answer with:
Q29 (b), (c) and (e)
Unlike local variables, all member variables are initialized with default initial values. All numeric variables are initialized to zero, boolean values to false, char values to '\u0000' and all object reference values to null. (c) occurs when an un-initialized member variable is used in an initializer block before its declaration.
Replace the line:
"The value for i is shifted right with sign-fill 4 places:"
with (replace 4 with 2):
"The value for i is shifted right with sign-fill 2 places:"
Replace choice (d) with (delete the words "The constructor"):
(d) MyClass() cannot be declared final.
Replace the question:
"Given the following variable declaration within the definition of an interface, which of these declarations are equivalent to it?"
with:
"Given the following variable declaration within the definition of an interface, which of these declarations can be substituted for it?"
Replace the code line:
private static String msg = "Shine the inner light."; // (2)
with (delete the word static):
private String msg = "Shine the inner light."; // (2)
Replace the question:
"Which of these are methods in the CardLayout class?"
with:
"Which of these method names are in the CardLayout class?"
Replace the first sentence of the last paragraph:
"A JTree uses an object implementing the TreeCellRenderer interface to render cells in each column of the table."
with:
"A JTree uses an object implementing the TreeCellRenderer interface to render the elements in the tree structure."
Replace the sentence:
"Only methods can be declared synchronized."
with:
"Only methods and code blocks can be synchronized."
Replace the question:
"Which modifiers and return types would be valid in the declaration of a working main() method for a Java standalone application?"
with:
"Which modifiers and return types would be valid in the declaration of a main() method which starts the execution of a Java standalone application?"
for (int i = 0; i < stackArray.length; i++)
with:
for (int i = 0; i <= topOfStack; i++)
The last bullet (and its sub-bullet) should be deleted:
The question:
"Which of these are valid declarations of the main() method?"
should read:
"Which of these are valid declarations of the main() method in order to start the execution of a Java program?"
"Given a variable x of type int (which may contain a negative value), which are correct ways of doubling the value of x?"
should be rephrased:
"Given a variable x of type int (which may contain a negative value), which are correct ways of doubling the value of x, barring any overflow?"
IndexArrayOutOfBoundsException
with:
ArrayIndexOutOfBoundsException
Second paragraph, in the sentence:
"Subpackages do not afford anything extra when it come to accessibility of the members."
replace "come" with "comes":
"Subpackages do not afford anything extra when it comes to accessibility of the members."
abstract void haunt()
with (semi-colon missing):
abstract void haunt();
objRefA.superclassVarA; // (4) Not OK.
with:
objRefA.superclassVarA = 10; // (4) Not OK.
The sentence:
"The <statementi> associated with the first case label that is equal to the value of the integral expression is executed."
should be changed to (delete "first"):
"The <statementi> associated with the case label that is equal to the value of the integral expression is executed."
The sentence:
"The first form of the return statement can also be used in constructors and initializers, as these also do not return a value."
should be changed to:
"The first form of the return statement can also be used in constructors as these also do not return a value."
"The method definition in the subclass can only specify all or a subset of the exception classes (including their subclasses) specified in the throws clause of the overridden method in the superclass."
to (i.e. insert "or none,"):
"The method definition in the subclass can only specify all or none, or a subset of the exception classes (including their subclasses) specified in the throws clause of the overridden method in the superclass."
IndexOutOfBoundsException
with:
ArrayIndexOutOfBoundsException
The new method definition in the subclass can only specify all or a subset of the exception classes (including their subclasses) specified in the throws clause of the overridden method in the superclass (Section 5.8, p.162).
to (i.e. insert "or none,"):
The new method definition in the subclass can only specify all or none, or a subset of the exception classes (including their subclasses) specified in the throws clause of the overridden method in the superclass (Section 5.8, p.162).
| Entity | Declaration Context | Accessibility Modifiers | Outer Instance | Direct Access to Enclosing Context | Defines Static or Non-static Members |
| Package level interface | As package member | public or default | No | N/A | Static variables + non-static method prototypes |
| Top-level nested interface | As static class member | all | No | Static variables in enclosing context | Static variables + non-static method prototypes |
Replace these 2 lines of code:
double zz = A.this.z; ... double yy = A.this.y;
with
double zz = TopLevelA.this.z; ... double yy = TopLevelA.this.y;
The sentence:
"The method random() returns a random number greater or equal to 0.0 and less than 1.0, where the value is selected randomly with the range according to a uniform distribution."
should be (change "with" to "from"):
"The method random() returns a random number greater or equal to 0.0 and less than 1.0, where the value is selected randomly from the range according to a uniform distribution."
Change the code line:
String[] uniqueJiveArray = (String[])jiveSet.toArray();
to:
String[] uniqueJiveArray = (String[])jiveSet.toArray(new String[0]);
The method prototypes:
void drawRoundRect (
int x, int y, // top left corner
int width, int height // of rectangle
int arcWidth, int arcHeight
)
void fillRoundRect (
int x, int y, // top left corner
int width, int height // of rectangle
int arcWidth, int arcHeight
)
void fill3DRect (
int x, int y, // top left corner
int width, int height // of rectangle
int arcWidth, int arcHeight,
boolean raised
)
void draw3DRect (
int x, int y, // top left corner
int width, int height // of rectangle
int arcWidth, int arcHeight,
boolean raised
)
void fill3DRect (
int x, int y, // top left corner
int width, int height // of rectangle
int arcWidth, int arcHeight,
boolean raised
)
should be changed to (all of them are missing a comma, and in the last 2 prototypes a code line must be deleted):
void drawRoundRect (
int x, int y, // top left corner
int width, int height, // of rectangle
int arcWidth, int arcHeight
)
void fillRoundRect (
int x, int y, // top left corner
int width, int height, // of rectangle
int arcWidth, int arcHeight
)
void draw3DRect (
int x, int y, // top left corner
int width, int height, // of rectangle
boolean raised
)
void fill3DRect (
int x, int y, // top left corner
int width, int height, // of rectangle
boolean raised
)
The paragraph:
"Although subclasses of the Applet class can provide a default constructor, it is seldom used to initialize the applet. This is instead done in the init() method of the applet."
should be changed to:
"Although subclasses of the Applet class can provide a default constructor for initialization purposes, this is usually done in the init() method of the applet.
Replace the page with the following:
Exam Objectives
Supplementary Objectives
"... and "c:\documents\book\chapter1", respectively."
with (delete the text "\documents"):
"... and "c:\book\chapter1", respectively."
"Note that the read() methods read an int in the range 0 to 65535 (0x0000–0xFFFF), i.e. a Unicode character. The value –1 is returned if the end of file has been reached."
should read:
"Note that the read() methods read Unicode characters which are int values in the range 0 to 65535 (0x0000–0xFFFF). The first method returns the character read as an int. The last two methods return the number of characters read into the char array. The value –1 is returned by all methods if the end of file has been reached."
with:
In the 4th. paragraph of this section, replace the first sentence:
"For multiple choice questions, the program will present a list of answers with either radio buttons or checkboxes."
with:
"For multiple choice questions, the program will ask the candidate to select a specific number of answers from a list."
Replace the URL
<URL:http://suned.sun.com/usa/cert_test.html?content=scpj2_obj>
with the following:
<URL:http://suned.sun.com/USA/certification/progobj.html#Java2>
The last objective should be deleted and inserted on page 621 (see below).
The objective deleted from page 618 should be added to the objectives for this section:
Add the following study notes after the objectives (see previous corrections for this page):
Study notes
Navigation in the file system is done using the File class. The concept of a stream is central to dealing with input and output. Input and output streams are provided for reading and writing bytes and characters. Classes FileInputStream and FileOutputStream are streams for dealing with the file content. Class RandomAccessFile allows direct access to the file content as opposed to sequential access provided by FileInputStream and FileOutputStream. Readers and writer are provided for reading from and writing characters to streams. Classes InputStreamReader and OutputStreamWriter can be used to specify a character encoding when reading from and writing characters to a stream. Streams can be chained to filters (subclasses of FilterInputStream and FilterOutputStream) to provide additional functionality (for example buffering of data, reading and writing Java primitive values).
The sentence:
"For each invocation of check(), each variable pair is incremented and their values are always equal when the method returns."
should be changed to
"For each invocation of doit(), each variable pair is incremented and their values are always equal when the method returns."
The sentence:
"Mouse-motion listeners can be registered on all objects that are instances of Container."
should be changed to:
"Mouse-motion listeners can be registered on all objects that are instances of Component."
The Java Language Specification (JLS) states in section 8.2 that
"Members of a class that are declared private are not inherited by
subclasses of that class. Only members of a class that are declared protected
or public are inherited by subclasses declared in a package other than
the one in which the class is declared.
Constructors, static initializers, and instance initializers are not
members and therefore are not inherited."
According to this view, inheritance is linked to DIRECT ACCESSIBILITY of superclass members. In this sense the private members of the superclass are NOT inherited by the subclasses, but these members do EXIST in a subclass OBJECT. Private members of the superclass may be indirectly accessible from a subclass object if the superclass provides the appropriate implementation. In the example below, the private variable i in superclass A exists in object b of subclass B, but this data member is not inherited by the subclass B.
class A {
private int i = 10; // Not inheritable
public void printI() { // Inheritable
System.out.println("i " + i);
}
}
class B extends A {}
public class Inheritance {
public static void main(String[] args) {
B
b = new B();
b.printI();
}
}
Output from the program:
i 10
JLS further states (section 8.4.6):
"A class inherits from its direct superclass and direct superinterfaces all the non-private methods (whether abstract or not) of the superclass and superinterfaces that are accessible to code in the class and are neither overridden (§8.4.6.1) nor hidden (§8.4.6.2) by a declaration in the class."
We will make the appropriate changes in accordance with JLS in the next edition when the time comes.