Java 2: A Beginner's Guide (Beginner's Guides (Osborne)) [Paperback]

Herbert Schildt's book was written for people to learn the fundamentals of programming in Java as easily and as quickly as possible. (Of course, each reader can go at his/her own pace.) After I began reading the book, I started to become accustomed to Java's terminology and downloaded Sun's free Java compiler online. Within a few days, I was writing my own simple stand-alone Window's applications and applets. After that, I started exploring more complex concepts.

Herbert Schildt's writing style and book organization made it possible for me to start writing a complex, multithreaded, work-related application within 4 weeks. He begins the book with a history of the Java language; it's relations to C, C++ and C#; it's built-in security & portability; bytecode; and object-oriented programming. He then explores data types, operators, and program control statements before explaining the heart of a Java program: classes, objects and methods. From there, the reader is ready to be introduced to some of Java's more powerful aspects: inheritance, polymorphism, abstract classes, packages and interfaces.

Next, what elevates Java over many other languages is its built in exception handling. Being able to track and locate programming errors is often one of the most difficult aspects of programming, especially when the program is large and complex. Java allows programmers to test various blocks of a program using the statements "try" and "catch". Some methods require the use of the "try" and "catch" block because of their potential to generate an exception that is outside of the program's control (such as file streams).

The next very powerful aspect of Java that Herbert Schildt explores is multithreading. Seasoned real-time programmers will be very familiar with the concept of multitasking, but for many novice programmers, the concept of multitasking or multithreading (as it is called in Java) can be daunting and confusing. Herbert Schildt's explanations of how to use multithreading (and its potential problems) are thorough and relevant. Finally, Herbert Schildt explores the creation of applets.

As your knowledge of Java expands, you'll find it very worthwhile to purchase a more comprehensive Java reference book that contains a broad list of the various classes and methods available within the language. For this, I highly recommend Herbert Schildt's "Java 2: The Complete Reference, Fifth Edition", which is geared for J2SE 1.4.

Overall, I rate "Java 2: A Beginner's Guide, Second Edition" by Herbert Schildt with 5 out of 5 stars. Java is a great programming language, and Herbert Schildt's instructions make learning the language is painless as possible.

Happily this book suffers from none of these flaws. It covers a wide range of applications, it's full of detail on the latest graphical interface tools, there are plenty of small examples, and no command or definitions is introduced without a clear example.

This is an excellent book for someone with some programming experience, but no experience in object oriented methods. Storngly recommended.

I found many oversimplifications and half-truths throughout the book:

"Static methods may call only static methods." Not true -- static methods may call non-static methods if called on an explicit reference.

"A call to a superclass constructor must be the first statement in every constructor." Not true -- you can call the current class's constructor with "this" instead of "super". This is an important technique called "constructor chaining."

"Wait and notify may be called only from synchronized methods." Not true -- they may be called from non-synchronized methods as long as they are called from a synchronized block and called on a reference to an object the thread holds a lock on.

The explanation about how Java "passes objects by reference" confuses many beginning Java programmers, and the trick of passing an Integer to simulate passing an int by reference doesn't work because Java passes references by value and the wrapper classes are immutable. The explanation about method overloading supporting polymorphism is confusing because which overloaded method to call is decided at compile-time, whereas polymorphism means that the method to call is decided at run-time.

There are numerous examples that demonstrate the mechanics of Java without showing how the constructs should be used in an actual Java program. The example of a finalizer neglects to call super.finalize() as all finalizers should. The example of a catch block sweeps the caught exception under a rug instead of recovering from it. The example of a static initializer simply prints a message to show that it was executed instead of doing something useful like loading a class or library.

Readers who learn Java from this book should be prepared to study a more thorough and accurate Java programming book after this one. For those who just want to program in Java as a hobby, this makes a decent introduction to the topic. Just be aware that not everything the book says is true or as simple as it appears.