What are some potential trips/traps in the SCJP exam?

• Two top-level public classes cannot be in the same source file.

• main() cannot call an instance (non-static) method.
• Methods can have the same name as the constructor(s).
• Watch for thread initiation with classes that don't have a run()
method.
• Local classes cannot access non-final variables.
• Case statements must have values within permissible range.
• Watch for Math class being an option for immutable classes.
• instanceOf is not the same as instanceof.
• Constructors can be private.
• Assignment statements can be mistaken for a comparison; e.g.,
if(a=true)...
• Watch for System.exit() in try-catch-finally blocks.
• Watch for uninitialized variable references with no path of proper
initialization.
• Order of try-catch-finally blocks matters.
• main() can be declared final.
• -0.0 == 0.0 is true.
• A class without abstract methods can still be declared abstract.
• RandomAccessFile descends from Object and implements
DataInput and DataOutput.
• Map does not implement Collection.
• Dictionary is a class, not an interface.
• Collection (singular) is an Interface, but Collections (plural) is a
helper class.
• Class declarations can come in any order (e.g., derived first,
base next, etc.).
• Forward references to variables gives a compiler error.
• Multi-dimensional arrays can be "sparse" -- i.e., if you imagine
the array as a matrix, every row need not have the same
number of columns.
• Arrays, whether local or class-level, are always initialized
• Strings are initialized to null, not empty string.
• An empty string is not the same as a null reference.
• A declaration cannot be labelled.
• continue must be in a loop (e.g., for, do, while). It cannot appear
in case constructs.
• Primitive array types can never be assigned to each other, even
though the primitives themselves can be assigned. For example,
ArrayofLongPrimitives = ArrayofIntegerPrimitives gives compiler
error even though longvar = intvar is perfectly valid.
• A constructor can throw any exception.
• Initializer blocks are executed in the order of declaration.
• Instance initializers are executed only if an object is constructed.
• All comparisons involving NaN and a non-NaN always result in
false.
• Default type of a numeric literal with a decimal point is double.
• int and long operations / and % can throw an
ArithmeticException, while float and double / and % never will
(even in case of division by zero).
• == gives compiler error if the operands are cast-incompatible.
• You can never cast objects of sibling classes (sharing the same
parent).
• equals() returns false if the object types are different. It does
not raise a compiler error.
• No inner class can have a static member.
• File class has no methods to deal with the contents of the file.
• InputStream and OutputStream are abstract classes, while
DataInput and DataOutput are interfaces.

• Exam objectives: Several important new language features

have been added, including enums, generics, static imports,
and autoboxing/unboxing. API features added to the exam
include java.lang.StringBuilder, java.util.Locale,
java.util.Formater, java.util.Scanner. java.util.regex.Pattern, and
java.util.regex.Matcher. Java IO features have been added,
including File, BufferedReader, BufferedWriter, FileReader,
FileWriter and PrintWriter. Concepts such as loose coupling and
high cohesion have been added, as well as greater emphasis
on encapsulation as it relates to JavaBean conventions. Bit
manipulation (e.g., shifting) has been dropped.
• Number of questions: 72
• Time: 175 minutes
• Passing score: 59%
• Level of difficulty: The consensus is that it is more difficult.
• Format of questions: you will always be told how many
options to choose. No credit is given for partial answers. Drag-
and-drop questions were also introduced for this version of the
exam.