Special Edition. Using Java 1.2. The Most Complete Reference [Englisch] [Taschenbuch]

The book is particularly weak at using the Java naming conventions (sometimes entire pages have variable names that start with uppercase letters; a lot of variables have underscores in them etc). It does not explain them at all - or, what it says is plain wrong (p. 176, for example). It's only constant naming conventions that are explained well.

Chapter 1, What Java Can Do For You, presents quite cool examples of Java's usability. Only few pages have been 'wasted' on this subject, and the examples presented here are sure to make most ppl be eagerly waiting for the next chapters.

Chapter 2, Java Design, tells the reader the most important aspects of the language: being interpreted, platform-independent etc. and what it means in practice. It also goes in telling not-that-widely known facts about the JVM (address range, max. size of methods). Also summarizes the security model very thoroughly - it even shows tables of the possible attacks on memory, OS, CPU, confidential data etc. that a malicious program could do. It lists the Java API libs - showing the 1.1 and (1.)2 libs separately. Also has a section on the new 1.2 Enterprise libs.

Chapter 3, Installing the JDK and Getting Started, shows how JDK (and ADK) should be installed. I don't really know whether the first JDK 1.2 betas required the users to include rt.jar in the CLASSPATH. The entire book tells the user to do so.

Chapter 4, JDK Tools, introduces the command-line options of the most important JDK tools (except for javad, which is explained later). Also discusses their Mac equialents.

Part 2, Chapter 5, OOP, is a not very overwhelming treatment of basic OOP subjects. That is, the authors don't throw in many subjects that would be only explained later (this is why this chapter is much superior to chapter 2 of Lemay's book - I found the treatment of basic OOP concepts even better than that of Eckel's Thinking in Java) - polymorphism is the only exception, which is only explained later.

Chapter 6, HelloWorld! Your First Java Program, shows the reader the basic Hello World program as both an application and an applet. It doesn't even try to explain main() - fortunately, at a later stage, it explains why it's static. On the other hand, all applet methods are explained (paint, start, stop etc)

p. 91: "it's necessary that the filename be the same as he class file..." - the authors correct this inaccurate information only later (on p. 164: "although only required for public access...").

p. 94: "after the init() method, the browser first calls the paint() method, next, the start() method is started" - not really true - start() is being called before paint() (I've tested it under 1.2.1/Win and AV; commercial browsers may behave differently though).

p. 95: shows the API documentation, but doesn't actually tell the user how it should be used. As at the time of writing the new style API docs were also available, the authors should have presented the new API structure and the differences between the old and the new api docs... (speaking of the old API docs presented here, the authors should have at least mentioned to look up the inherited methods from superclasses).

Chapter 7, Data Types and Other Tokens:

p. 98: the keyword boolean is almost exclusively referred to as Boolean in the entire book. Some example programs also have this mistake.

p. 108: the section (1.5 pages) on arrays could have been written much better. It doesn't show the new 1.1 shorthand for initialization arrays separated from declaration. Multidimensional arrays are only mentioned as examples, but are not discussed at all.

It was a wise move to make a distinction between the two fundamental types of variables: basic data types and references.

Chapter 8, Methods, discusses almost everything: visibility, parameter lists, return value etc.

p. 127: an example of the book's often confusing classes for objects: "when a class is passed"

p. 127: "in Pascal, [variables] are always passed by reference..." - actually, the opposite is true - you have to explicitly tell the compiler to pass them by reference (with the keyword var).

p. 128: another page full of variables beginning with uppercase letters.

p. 129: labeled statements: Thinking in Java explains them much more thoroughly.

p. 130: separators: " {: used both to open a parameter list or used to begin a block of statements or an initialization list". The two words may have been copied from the previous row, which described the separator (. The same problem persists in the next explanation: " [: used both to open a parameter list for a Precedes an expression used as an array index " - everything underlined should be removed from here.

Chapter 9, Using Expressions, operators, associaty, precedence; cool C-comparisons (e.g. ++/-- can be used with any numeric type in Java, unlike in C)

p. 140: casting - I miss a figure of the implicit casts between basic types from this book, too. Doesn't spend much text on object reference casting - this book also lacks at explaining why you can't implicitly cast a superclass reference to a subclass.

Chapter 10, Control Flow: chapter 9 already discussed bitwise operators - now logical operators are also explained. Also introduces short-circuit operators (without actually calling them so). The authors should have emphasized short-circuit evaluation only takes place when using these operators.

Chapter 11, Classes:

p. 160: the following statement also lacks any explanation: "you can not perform an operation reserved for the Bike [sub]class on an instance of rthe Vehicle [superclass]".

p. 163: mentions the default class visibility is protected - it's not really true as you can't subclass a class that has default visibility in any other package. The authors must have confused class visibility with method/field visibility - accessing the fields/methods of a superclass in another package. Another error can be found here - from now on, the authors refer to these 'protected' classes as 'friendly'. They don't mention anywhere in the book what the difference is between Java's protected and C++'s protected; neither do they explain what happened to the C++'s friend.

p. 163: another severe editing error: "may not be not be evident at first"

p. 166: a good remark: "by making your code private, you may enable other classes to use static methods of your class without enabling them to create an instance of it."

p. 167: override / overload: it presents the caveat referring from using different signatures when trying to override. I still missed the comparison to C++ (even if it was only done by Thinking in Java - it's still worth knowing if you come from C++).

p. 168: a clear and clever explanation of how JVM loads both applets and applications, paying special attention to emphaizing in which case does the class have an implicit instance.

p. 170: another example of the class<> object confusion: "this is used whenever it's necessary to explicitly refer to the class itself" and "being able to refer to itself is a capability that is very important for a class when a class needs to pass itself as an argument to a method ". What is more, the this() constructor call isn't introduced.

p. 172: doesn't explain when super() must be explicitly used

p. 181: inner classes: four pages only. Doesn't introduce static (top-level) and anon inner classes. The latter are used a bit later, but without any explanation.

p. 186: explaining / using the naming conventions are painfully missing from here too: the authors use package names like Transportation.

p. 189: only the standard 1.0 Java packages (applet/awt/io/lang/net/util) are listed here, no 1.1 packages at all. Doesn't mention the need for separate subpackage import either.

Chapter 12, Interfaces:

p. 198: "all methods in interfaces are public by default this is in contract to class methods which default to friendly" - again, I miss the comparison between C++ friendly and Java default visibility.

p. 201: also mentions one of the best capabilities of interfaces: being able to cast up to their type. I still miss examples like those of Core Java that actually show where it can be used (the Timer/Timed example with a callback function, for example).

Chapter 13, Threads: the example is far too large (and is an applet - another reason