Rating: 
Summary: Good but leaves room for improvement
Review: This book has its strengths but it also definitely has its weaknesses. On the plus side, there are numerous valuable discussions and programming tips. On the weak side is that they are often very difficult to find in a hurry, and not sufficiently supported by fully self-contained examples, that illustrate the topic under discussion. (Contrast Deitel's "Java How to Program"). The author seems to prefer holding discussions, which often diverge and switch focus, rather than concentrating on continuously and smoothly presenting a given topic. This is much less of a problem for those who already have Java (or perhaps C++) experience, but reason enough for beginning Java programmers to steer clear until they gain more experience. A thing which speaks for book, especially for those with C++ experience, is the abundance of sidebars pointing out ways in which the Java topic under discussion differs from the equivalent construction/syntax in C++. Also on the plus side is the tendency to summarise new features list-style in an "API" section (generally classes or functions that have been introduced in the current section/chapter, for the first time in the book). This would be even more helpful, especially as a reference, if the text was set on a different shaded background to emphasise it.
Rating: 
Summary: A great book for advanced programmers
Review: This is a preview of my forthcoming review. FORGET MY PREVIOUS POSTING BELOW, IT'S USELESS WITHOUT THE TABLE! I've written a comparative review of the following books: Ralph Steyer: Java 1.2 Kompendium (Markt und Technik; ISBN: 3827253179) (German!) Cay S. Horstmann, Gary Cornell : Core Java 2, Volume 1: Fundamentals, 4/e (Prentice Hall; ISBN: 0130819336) Peter van der Linden: Just Java 1.2 (4th ed, Core series, Sunpress/ Prentice Hall; ISBN: 0130105341) Bruce Eckel: Thinking in Java (Prentice Hall Computer Books; ISBN: 0136597238; with the new chapter on Collections). Aaron Walsh: Java 1.2 Bible (IDG Books Worldwide; ISBN: 0764580302). Look up the review of the last four books from Amazon.com and Ralph Steyer: Java 1.2 Kompendium's review from Amazon.de - I had to remove all the columns of the other 5 books from the table below b/c Amazon's HTML parser doesn't understand table tags. In order to get a clear, (hopefully) objective view of all the books, I've also read Jamie Jaworski's Java 1.2 Unleashed (Sams.Net, 1998; ISBN: 1575213893) book before the test, but, as the book is only intended for experienced programmers interested in additional and enterprise APIs and not for beginners, I dropped it from the test entirely. It would have been unfair to test such an expert-only book in a review of beginners' books. Core Java has been one of the leading books on Java for three years. It has always been almost the best reference without actually being a rehash of the API docs. It can also be recommended for novice Java programmers, albeit the comprehensibility of the book is sometimes far from perfect. Nevertheless, if you already know what OOP is, and you're looking for the most up-to-date and most complete reference, Core Java is the right choice over either Just Java or Thinking in Java, the two other good books in this review. Note: only the first volume of Core Java 4th ed has been published. In the table below, I used parentheses to evaluate the corresponding chapter in vol2, 3rd edition of the book. Don't let these remarks mislead you - I'm only referring to the 3rd edition, NOT the forthcoming 4th one! Let's hope vol2 of 4th edition will be even better than the previous one (and also contain ALL the swing widgets and everything about Java 2D). Core Java is one of the two books that always keep on comparing Java to C++ (and VB, just to annoy some hardcore C/C++/assy/Java coders that hate anything non-1337 :-)). Only Thinking in Java can be compared to the book in this respect. Chapter 1 (19 pages) is an introduction. The authors thoroughly debate the Java buzzwords and the common misconceptions about the language, speak a bit of the history of it etc. Chapter 2 (20 pages) discusses installing the JDK and the authors' own scripts for WinEdit32. Fortunately, the no-longer-required CLASSPATH setting is not touched upon - the same stands for the entire book, it has been really completely rewritten and doesn't contain JDK 1.1 references any more. These would, indeed, confuse the beginners (albeit it should have notes describing the differences for the experienced -this is a mistake that should be corrected in the next edition). CLASSPATH is only discussed where it is required - in Ch 4, discussing packages (with a minor mistake: the reference to the 1.1 classes.zip should have been removed). Chapters 4,5 and 6 discuss OOP and related subtleties (inner classes, interfaces, reflection etc) of the language. I feel the discussion a bit dry - Linden's book has much more comprehensive, albeit a bit more superficial chapters on OOP. Eckel's step-by-step introduction of inner classes is far more comprehensible and Linden's tables and systematic discussion helps more to make a distinction between the different kinds of inner classes. Horstmann's explanation is a bit dry and hard-to-understand, albeit far better than that of the 3rd ed (AFAIK Horstmann didn't even mention static - that is, top-level - inner classes in the previous edition of the book). Building the PropertyTest project is very hard to follow. Chapters 7-10 discuss Swing, applets and graphics. These chapters are completely up-to-date and very thorough - they're much better than any other book's chapters on the same subject. No attention is paid to outdated AWT components and the old 1.0 event model. This is the only book to explain how easy it is to convert between applets and applications and what the pitfalls are when doing so. A good book should do the same - the students must be taught not to consider the two forms of executables entirely different. Chapter 12 discusses the I/O (in the 3rd ed., it was in Vol2). A very well written chapter; CJ is the only book to explain the subtleties of versioning and the serialized class file format. Horstmann keeps up a large errata-list on his page. Very few authors do the same (Linden and Eckel do; non-Prentice Hall authors generally don't). This book is a must to every serious Java developer. Absolute beginners should buy some introductory book as their first book, but switching to Core Java will be mandatory when you learn the basics (OOP, Collections etc) from them. What did I compare? I tried to evaluate each book in a comparative fashion. Unfortunately, when it's time to evaluate a book's being comprehensive AND discussing / mentioning everything with ONE rating, it's hard do decide which to prefer. Should we give a better mark to a book that is more comprehensive but less wide-reaching, that is, lacking the discussion of some features of the language? Should we do the opposite? Fortunately, there weren't many cases where this caused me headache, as, in general, the books are both comprehensive AND fully discuss everything. Nevertheless, I included a row in the table. This row evaluates each book's being both beginner-friendly (that is, whether it's intended to a newcomer) and discussing everything at much higher depth than the API docs. The higher the mark, the better suited for the target audience (beginners or the experienced) the book. These two ratings, of course, don't have to be equally high for a good book - for example, Java in a Nutshell, an outstanding reference, would hardly get a rating higher than 2 when evaluating its suitability for beginners. A book, on the other hand, that receives ratings that are both below 3, isn't intended for anybody. Marks: 0: the author doesn't even mention this 1: the worst; only few sentences are devoted to the subject 5*: the best - outstanding, far better than any other book References in italic ((1)..(9)): see under the table Abbreviations: GBL = GridBagLayout The parentheses in the first column: see the remark above (Core Java 2, 2nd paragraph)! R: 5 B: 4Is it a reference for the experienced or an introduction for beginners? 5Basics of procedural programming (w/o OOP) 4OOP comprehensibility (-)(5/-)Threads / 1.2 thread deprecation 5Exceptions, error handling 5 (8)Packages 2 AWT 1.0 event model 5Layout managers 5* (9)AWT 1.1 event model 5*Basic Swing widgets (-)(-)Advanced Swing widgets 5*1.1 I/O 5java.math - BigInteger, BigDecimal (-)(4 - no UDP)Java.net (-) (7)Collections 5inner classes (-)(JDK 1.1: 5*)JDK 1.2 security (-)(5*)1.1 clipboard handling (-)(5)Java Beans 5 RTTI, Reflection, Class (-)(1) CORBA et al (DCOM etc) (-)(5*)RMI (-)(5*)i18n (-)(5) JDBC 5*Comparing Java to C++ 5/5/5*Object serialization / versioning / object file format (-)(5*)JNI 5/5*Applets / conversion to applications and vice versa 5/5Describing / Using naming conventions (7): 4th edition Vol1 only discusses Vectors (the Collection classes will be discussed in Vol2); 3rd edition discusses the old dynamic classes well (8): neither of the books reviewed in this article discusses packages as they should be discussed - that is, the relationship between the packages and the file system is introduced at a very late stage, if ever. All books miss crucial information of actually compiling classes that belong to a specific package. This is why there is no clear winner in this subject - this is a bit annoying, as, for a beginner, it's one of the most complicated questions to understand how the packages are located in the file system and what CLASSPATH is. Unfortunately, this subject is only introduced by Sun's own SL-276 revision B course book, the book that discusses mapping of packages, object locks, synchronization, wait/notify and 1.2 thread deprecation (suspend/resume/stop) the best. Core Java is the only to mention some practical info (the compiler doesn't automatically place .class files of a given package to the subdirectories in the current dir). It doesn't show the user how the -d parameter should be used of javac to avoid manually copying the compiled .class files. All books that have been reviewed lack this, extremely important, explanation (except for Sun's SL-276 book). (9): it even discusses using the event queue - the other books discussed lack this. To summarize: All these books are particularly weak as far as Swing widgets are concerned. The
| 
