Now I can't wait to get all of Ruth Maran's other books. School was never this fun. Thanks, Ruth for creating a book series that REALLY DOES THE JOB! A+++

A must for the beginner!

If you plan on coding exclusively with JDK 1.1 I would wait for the upcoming two volume set (by the same title) from these authors. If they are as good as this volume, they will be worth the money in the time that they save.

It will take you no more than a second or two after opening this book to realize that your search for the perfect Java reference guide is over. Co-authored by one of the founding members and lead developer of the Java project at Sun, this book weighs in at almost 1700 pages, over 140 of which are used for the comprehensive index, and all of which are put to good use.

The book covers all the class libraries, including the AWT and applet packages, and includes brief overviews of each package. The bulk of the book is made up of the class library reference section. The classes are organized alphabetically, with their member methods following. Each class is introduced with a diagram showing it's place within the class hierarchy, along with its syntax, a description, a member summary, and example code. Each member entry includes sections on purpose, syntax, description, parameters, see also, and an example (some of which refer back to the class example). According to the book cover there are more than 600 examples and over 20,000 lines of code. (There is no CD-ROM included but the code can be downloaded from the Web.)

If all this sounds like a dream come true for Java programmers, it is. Although I haven't spent enough time with the book to be able to judge its accuracy, I would recommend it without hesitation to anyone programming in Java. It's the reference guide you've been waiting for.

The author starts by taking high-level perspective on the subject, showing the different design considerations that need to be applied when choosing which J2EE technologies to use. A case study (a ticket booking system) is described and elaborated on throughout the book, showing how these design considerations affect a real-world solution.

The book also provides a load of coding tips I found useful, from better use of reflection, to judicious use of design patterns, to how to minimise your refactoring. The author assumes the reader is an experienced developer, so doesn't focus on rudimentary Java and architecture. I found this useful, but it means the book is more focussed to a specific audience.

Amazingly, the book also provides an entire framework based on J2EE on which you can put your application logic. My only complaint is that this is not included in a companion CD - you have to download it.

Overall, the book works because it shows you how build solutions, not just understand the technology.

No other book on web programming that I know of comes even close to this one. Some noteworthy features:
-- Always framework-oriented approach (which in my view is the only possible choice for real-world projects)
-- Heavy emphasis on architectural side of web development (follows from the previous point)
-- Comparison of different view technologies from practical point of view, w/o exclusively subscribing to a particular one which seems popular (like, JSP).
-- Excellent coverage of MVC paradigm, again, w/o subscribing to a particlar implementation (like Struts, etc)
-- Extensive coverage of all levels ("tiers") of a web application.

But what really shines, are the insights on architecture, namely the things which is impossible to find out by theoretically studying J2EE specifications and books such as "Enterprise Java Beans" and the like. For example, why Entity EJBs don't work. Or when is collocated EJB architecture is more appropriate than the distributed one, and why. After reading the book, many concepts just clear up. Not to say that everything is written in a clear and concise language (despite a few typographical errors that Wrox books are notorious for).

In short, this book is simply amazing.

I think this is a better book for beginners than the O'Reilly Java Thread's book. The O'Reilly book tends to quickly pile through each concept while the Sam's book takes a more leisurely approach. The O'Reilly book also occasionally goes off on tangents. Hyde's book, however, points out potential sources of trouble while taking an easy to follow, serial thread to understanding asynchronous programming in Java.

The examples are easy to follow and the way that the author refers to the code line numbers in the text is very helpful. Concepts that I never quite grasped were explained in such a simple manner that I was left thinking "It's so easy! Why did I have trouble understanding this before!?".

I wanted to point out a few sections of the book that were especially helpful:

1) Synchronized Statement Block (pg 144-146). I have attained my Java certification at the programmer level, so I already knew how to use the synchronized keyword as method modifiers and in blocks. However, this section of the book really cleared up the concept of what it actually means to get a synchronized lock on an object. This line, on page 144, made it all clear: "... obj is a reference to the object whose object-level lock must be acquired before entering the block of code."

2) I can't find the page number, but the book makes a reference to the point that when two threads are running you can't be sure when the thread scheduler will remove it from the running state and place another thread into the running state. This really helped me understand how multi-threading programs work in general. Instead of talking about threads as slices of time (as some texts do), it was much easier to understand the concept of the almighty thread scheduler taking individual threads on or off the running state and that when they would be placed back into the running state, they would continue from where they left off before.

3) Deadlocks (pp 160-165). I have heard of this situation before but never really understood how a situation like this could arise. The diagram on page 161 and sample program on page 161 really brought the point home.

4) The Wait/Notify Mechanism (pp 168). The example on page 169 helped me understand why wait( ), notify( ), and notifyAll( ) are part of the Object class. I often wondered why these methods weren't part of the Thread class. This entire chapter was a pleasure to read because it clearly explained how wait and notify work and how they should to be used. The timing diagrams were also very helpful.

5) Threads and Swing (Chapter 9). The motivation example (page 232) for why it is sometimes necessary to create a new thread in a Swing application really helped me get a better understanding of the event dispatching thread. This made it very easy to understand SwingUtilities.invokeAndWait( ) and SwingUtilities.invokeLater( ).

I have a few suggestions for future editions of the book. The first suggestion is for providing exercises at the end of each chapter. Or perhaps there could be a Part 3 to the book which lists multi-threaded programming projects that readers can try. For example, I wrote the CubbyHole program on page 192 by myself, before looking at the code in the book. The second suggestion is to have more information about debugging in multi-threaded programs. A listing of the techniques as well as the common tools used would be most helpful. The third suggestion is to provide some examples when you would use ThreadLocal and InheritableThreadLocal in the real world.

Thank you, Mr. Hyde, for writing such a beautiful book!

If you're are an experienced Java developer, you will get a lot from this book. I still recommend to the Java folks that you also read up on the specialty areas, e.g. ADO.NET, Remoting, etc., if you will be working in those areas.

Even though this book is large, it's easy to read, has example code throughout, and covers a lot of what I needed to know. It had a breadth I found lacking in other Java to .Net books.

Unlike the other books I looked at, this one provides enough information so that you learn how to compile the example code using the free command-line compilers of the .Net Framework SDK rather than making you get Visual Studio.

Written by the Joshua Bloch, the acknowledged expert on the subject, it is as authoritative as they come and extremely well-written. After six and a half years as a senior developer architecting and implementing algorithms and class libraries in Java, this book shocked me by summarizing much of what I knew about how to use the language effectively, while teaching me much that I did not know. It continues to top my recommended reading list for all new software developers at my company.

- An plain English explanation of each class and method.
- Sample code for every class and method.
- Intelligent organization that enables you to find a given class or method quickly.
- A comprehensive, well-organized index that thinks like you do.

This summarizes the content of this book and the other two in the series and explains why they are the three books I wouldn't dream of programming in Java without. (I've been a professional Java developer since 1996.) Buy the book and make your life easier.

Java 2: A Beginner's Guide is very aptly named. Having NO previous experience to draw from, this book does a very good job of explaining things is a very orderly fashion, with plently of examples and even projects to work through. Although I've only completed the first 200 pages, I can honestly say that it's "clicked" for the first time. The going is slow; I would recommend typing each example and think about what the code is actually doing, but I know that my retention rate will be very high. This book makes learning to program enjoyable, and that's quite an achievement coming from me - I greatly dislike writing code. I would whole-heartedly recommend this to anyone looking at code for the first time, as it will certainly make my classroom assignments and labs a breeze.

The only drawback to this writing is that I am a third into the book, and I don't appear to have covered a huge amount of material. There's good reason for this, however. The "Complete Guides" to Java are 1200 pages, and are quite hefty tomes. Since this book is branded as a reference for the beginner, I can't really mark it down for that reason. This book does represent a great way to get started on learning the Java language.

Jayson Tobias
CCNP CCDP MCSE

This book was touted as being a book which teaches programming in the Java environment from the ground up. As an experienced programmer, I can say that the book did cover all of the topics a beginning programmer would need, BUT the author fell short in the method/function department. Functions/methods/services are too important to buzz by in less than a chapter. You need to really dig in and get dirty to teach functions properly.

Don't let me get too negative though, the book was extremely well written and a pleasure to read. I felt like I was making steady progress throughout the text. The examples were fun and (best of all) they worked.

Another really nice thing about this book is that it keeps me from having to go out and buy a bunch of other books that each cover one of the topics included in this one. Most of the topics in Professional Java Programming have been covered elsewhere, but it would have cost me alot more money to go buy all those other books than it did for me to just get this one. But even in the case of topics that have been covered elsewhere, this book does a good job. An example of that is its coverage of layout managers, and the description of how GridBagLayout works in particular was the best I've ever read.

I do have a couple of gripes, such as the lack of a CD. Yes, I know that I can download the code from the Wrox web site, but I'd still like to get a CD. I also think the chapter on distributed objects should have been longer or at least the RMI section broken out into its own chapter. I'd like for it to have covered the activation framework, since that's an advanced topic and this is a book on advanced topics. The distributed objects chapter is probably really good if you're new to the subject, but for advanced programmers (which I understand the book is targeted for), it doesn't provide a lot of new information. Overall, though I'm pleased with this title and would recommend it to tohers.

I was very pleased to see that Wrox came out with a new title which covered many of the advanced topics such as internationalization, creating custom GUI components, Java Native Interface (JNI), and many others. I initially feared that I would not enjoy this title as much as Horton's, but Brett did an excellent job. Although he does not cover J2EE technologies such as JSPs, servlets, and EJBs (I'm about to read "Professional Java Server Programming"), he does cover both client and server topics, many of which are relevant to thin client development. For example, I very much enjoyed his chapters on XML, threads, and internationalization, which is a topic that does not appear to get much attention in most Java books.

One thing that isn't covered in much depth here is object-oriented design, but again, that is covered in detail in another title: "Beginning Java Objects". To anyone new to Java and OO programming, I highly recommend these three titles.

In addition to a chapter on JDBC, this book includes a chapter that describes the various persistence options available to Java programmers, and nicely frames JDBC's role as one such option. That chapter also describes the InputStream, OutputStream, Reader, and Writer classes in the java.io package, along with an in-depth discussion of serialization. Another favorite of mine was the chapter on creating custom GUI components, a topic that I've not seen covered in many other places.

My only complaint is that this book doesn't come with a CD-ROM, but the code listings in the book are at least downloadable from the publisher's web site.