.. why is a book on sale in 2008 typeset as if it's 1970s? Is $40 per copy not enough to hire a designer - or provide a binding that is not going to fall apart in a week?

As far as content is concerned, my benchmark has been the SCJP prep book by Sierra and Bates. I took a random topic, generics, and how much more lucid and to-the-point the SCJP book was.

.. what an ugly-looking book this is, from the 1970s-style typesetting, to the flimsy binding. As far as content is concerned, my benchmark has been the SCJP prep book by Sierra and Bates. I took a random topic, generics, and oh, how much more lucid and to-the-point the SCJP book was.

Although this book purports to be written for anyone with even a little bit of prior programming experience, I am finding it very difficult to follow. This, even though I have been dabbling in programming since 1976 and I have gotten 'A's in several programming classes.

The author makes three major mistakes all throughout the book:

First, he uses compressed code formating that makes it difficult to see where one part of the code ends and another starts. I know it is common for advanced programmers and authors trying to save paper to use this format, but it should not be used in a book for beginning Java programmers. I spend more time just trying to sort out which curly bracket matches to which curly bracket than anything else in trying to read his code.

Second, he continuously uses advanced techniques and Java features in sample code meant to illustrate beginning concepts. This leaves the reader confused about what the code is doing at all and forces them to simply take on faith that what the author says about the code is true. For instance, in the section titled "Your first Java Program" (page 78) the author instantiates an anonymous object and passes it to a method. There was no reason to include this line of code. But the author stuck it in there and then waved his hands at it saying merely, "The argument is a Date object that is being created just to send its va1ue (which is automatically converted to a String) to println(). As soon as this statement is finished, that Date is unnecessary, and the garbage collector can come along and get it anytime. We don't need to worry about cleaning it up." In those few sentences the author has made reference to several more advanced features without even explaining them. So, in trying to understand that one unnecessary line of the reader is spun off on at least three different tangents.
The next sample program is even worse. The very first line that actually does anything is " System.getProperties().list(System.out); " Holy cow! The System.getProperties() method returns a Properties object which is an extension of the Hashtable class. Then the second dot operator calls the list method for Properties object that has "replaced" the System.getProperties() part of the code as far as the second dot operator is concerned. The list() method then accepts as an argument a static PrintStream object which the list() method then sends its output to. And the author says merely, "The first line in main( ) displays all of the "properties" from the system where you are running the program, so it gives you environment information. The list() method sends the results to its argument, System.out." But to someone who is only just now reading this page in the book, "System.out" is how you print something, NOT something that can be passed as an argument. And have you ever tried to Google a period (.)? How is a beginner supposed to figure out that the list() method is a member of the Properties object that was returned by the System.getProperties() method. Sure, you can dig it out of the JavaDocs but a beginner won't be able to do this easily. Besides, if you are going to force the reader to dig everything out of the JavaDocs then what the heck is the book good for?
This same pattern is repeated throughout the book. Every single example has something in it that is more advanced than a person who has gotten to that part of the book could reasonably be expected to be able to figure out.

Finally, the biggest problem with this book is that the author has created his own set of libraries and uses them heavily in his code but doesn't indicate where. So, if you don't have the entire JDK memorized you have no clue when he is using something from the standard libraries or something from his own libraries. If you are trying to learn the basics of Java, you don't want to have some other stuff mixed in at random. Sure, the author's libraries may solve some interesting problems and it may make some things easier to code. But it DOES NOT teach the reader about how Java works other than it is possible to completely obfuscate everything you do.

So, my conclusion is that this book is really good for nothing. It is too confusing for the beginner and is way too wordy for an expert. Intermediate users will spend more time digging through the JavaDocs than they do reading the book.

Ok, I have read about 200 textbooks or better in my day, 20 - 30 or so in the programming area, and I have to say this was the worst text book I have ever looked at. It was poorly written and poorly organized.

This is a beginner addressed book on Java: if you are already skilled in programming with procedural or even OO language, you'll find this book very useful.
The text is very simple and clear, the examples are incisive and at the end of each chapter you'll find a couple of exercises that can be very useful to focus the concepts.
A "thinking in enterprise java" would be a great successor to this good book.
5 stars!

Thinking in Java is a quite comprehensive book for intermediate to advanced level for Java programmers. Each chapter can be read individually in order to learn inner details of Java 5/6 language. This is not a book for a new comer to Java language.

Much of the code in the book is predicated on you using some of his custom libraries. As a result, you learn things his way, not necessarily the standard way to code Java.

I really liked this book, its a complete one. I used it to study for the SCJP 5.0 Exam as a complement to the Kathys book. Its however not a beginners book. You have to have some programming background cause its very theorical book. It explains in depth every subject, and its it drawback too, it gets a little boring with so much explanation, and in some examples it focuses more on the Design Patterns than Java. This is the Java Bible,every thing you will need is inside.

I have been a Java developer for 7 years, and my knowledge of Java increased by double, if not more, after reading this book. This book is fantastic to get deep into general Java topics. No kidding, I learned enough that I was able to point out features in Java that even our "gurus" at work did not know. Now I am one of the gurus! Note that the book covers no J2EE and is only an intro to concurrency so suppliment with books specific to those topics if you need.

I really like that fact that the book was sent to me very quickly. The seller explained everything of the book's flaws; every description is as is and no exaggeration. Thank you, I hope my next product comes from this seller as well.

Only thing you have to keep in mind: don't try to read this book like a novel, never try to read it fast, it's a HARD and LONG commitment. you have to put aside at least 3 months to digest fully, read several pages together with several examples, read the comment for those examples, try it out yourself....

compared to other so-called 'good java' books, which all put fancy graphics and stuff, this one is plain but 'THE BEST', you will gain a lot from reading it.

I have been a java progammer for several years, this books still give me so many surprise ....

trust me, you won't regret buying it if you are really want to learn...

This book - nor the author - needs any introduction for those who have read any of the previous editions of this book, or read other books written by Eckel (Thinking in C++ series). If you are new to Java - this is the book to get you going and get you started with the latest version of Java SE5 and 6. It covers everything, literally. The book is over 1400 pages, and it covers the JAVA programming language from the beginning to advanced topics such as parallel programming with threads and even GUI and user interface design. The topics are comprehensive and field with examples demonstrating the topic which is being discussed. The examples are relatively short in length, and get to the point. There is no one example that the author builds upon, making each chapter a discourse that can easily be read separately.

There have been many important improvement and new features added to Java SE5 such as Generics and such things as Enums and better String manipulation (StringBuilder class being a prime example). Generics - or programming with Templates if you are a C++ programmer - are the most important and complicated addition to this version of Java and the author spends plenty of time explaining it. As you may very well know, programming with templates is a very challenging and somewhat daunting task in C++, and it does not get much easier in Java. The challenge with the Java programming language is that the language must be backwards compatible with the older versions of Java. This has caused the language designers to make some rather difficult choices of how generics are used in Java. Bruce covers the topic very well, and takes about a quarter of the text to talk about generics and containers in Java.

Let's not forget the other things that make Java great; things such as its Object Oriented design and its ease of programming. The good-old topics such as polymorphism, interfaces, exception handling and I/O are covered in detail as one would expect. Improvements and additions are made to the topics are needed to cover advancements made to the language. Much of the semantics of C++ are slowly making it to Java; things such as Enums, formatting of the output as one does in printf(...). One of my favorites must be the concept of annotations, similar to pre-compile directives in C, and almost exactly the same as C#. Annotations are metadata that is added to your code which tags your code with information that you can use later. You can such things are suppressing warning messages, and denote deprecated methods and other user defined tags when needed.

Threading and parallel programming, graphical user interface design and libraries, runtime type information and design patterns and their implementations mark some of the other topics that are covered throughout the book. As with his other books, you can download an electronic version of this book from Bruce Eckel's web site. All the source code is also provided, and tested with JSE5.
This book marks another great achievement for Bruce - right next to his other books. Thinking in Java is easy to read, concise, complete and filled with examples and howto's. The author covers the latest advancements to the Java programming language, and does so with ease and clarity for the beginner to advanced readers.

This book - nor the author - needs any introduction for those who have read any of the previous editions of this book, or read other books written by Eckel (Thinking in C++ series). If you are new to Java - this is the book to get you going and get you started with the latest version of Java SE5 and 6. It covers everything, literally. The book is over 1400 pages, and it covers the JAVA programming language from the beginning to advanced topics such as parallel programming with threads and even GUI and user interface design. The topics are comprehensive and field with examples demonstrating the topic which is being discussed. The examples are relatively short in length, and get to the point. There is no one example that the author builds upon, making each chapter a discourse that can easily be read separately.

There have been many important improvement and new features added to Java SE5 such as Generics and such things as Enums and better String manipulation (StringBuilder class being a prime example). Generics - or programming with Templates if you are a C++ programmer - are the most important and complicated addition to this version of Java and the author spends plenty of time explaining it. As you may very well know, programming with templates is a very challenging and somewhat daunting task in C++, and it does not get much easier in Java. The challenge with the Java programming language is that the language must be backwards compatible with the older versions of Java. This has caused the language designers to make some rather difficult choices of how generics are used in Java. Bruce covers the topic very well, and takes about a quarter of the text to talk about generics and containers in Java.

Let's not forget the other things that make Java great; things such as its Object Oriented design and its ease of programming. The good-old topics such as polymorphism, interfaces, exception handling and I/O are covered in detail as one would expect. Improvements and additions are made to the topics are needed to cover advancements made to the language. Much of the semantics of C++ are slowly making it to Java; things such as Enums, formatting of the output as one does in printf(...). One of my favorites must be the concept of annotations, similar to pre-compile directives in C, and almost exactly the same as C#. Annotations are metadata that is added to your code which tags your code with information that you can use later. You can such things are suppressing warning messages, and denote deprecated methods and other user defined tags when needed.

Threading and parallel programming, graphical user interface design and libraries, runtime type information and design patterns and their implementations mark some of the other topics that are covered throughout the book. As with his other books, you can download an electronic version of this book from Bruce Eckel's web site. All the source code is also provided, and tested with JSE5.
This book marks another great achievement for Bruce - right next to his other books. Thinking in Java is easy to read, concise, complete and filled with examples and howto's. The author covers the latest advancements to the Java programming language, and does so with ease and clarity for the beginner to advanced readers.

A perfect book for ancient programmers seeking to update their skill to incorporate Java SE 1.5/1.6 programming

... if you want compare your solutions to the exercises with the author's. You will have to shell out another $20 directly to the author for solutions to the exercises -- if he ever gets around to completing the writing of those solutions. At the time I am writing this review, almost 15 months have passed since the book was published -- but still no solutions to the exercises. The author's last newsletter, circulated four weeks ago, said their publication was "imminent". I wonder what "imminent" means to him?

I know many people think this book is excellent, but for me it was tedious, dull and impractical. And heavy! What's it weigh? 10 pounds? The pages are padded with -- I'm sorry, I just don't know a more tactful word for it -- drivel. Whatever marketing value a big thick programming book may have, it correlates negatively with usefulness, as in the present case.

Each of the examples and exercises seemed devised to illustrate some theoretical abstract aspect of OOPS (Object Oriented Programming Systems). I would have been more pleased with learning something that I might readily put to use. Compare this more abstract approach with the exposition of Perl in Wall's "Learning Perl". Wall dives right in to a loginid/password authentication application. Too simple for an e-commerce site, for sure, but sufficiently practical that you can imagine some use for it, to help cooperative coworkers avoid inadvertent interference, for example. Or consider Kernighan & Ritchie's "The C Programming Language", in which the first lesson following the "hello world" program is a Fahrenheit - Celsius conversion. Eckel is content that we print a few debugging lines indicating that a function -- er -- method (in OOPS-speak) -- executed. While showing that the method main() should accommodate some string arguments, Eckel doesn't mention using the arguments in the first dozen chapters (I didn't finish the book), although this is the sole input technique introduced.

Eckel should have started early with some kind of little project, like a craps game, or a shopping cart for a sporting goods merchant website, or even Fahrenheit - Celsius redux.

From time to time, Eckel mentions that there are situations in which the theory he presents has good use, but he leaves the reader to guess what those might be.

In short, the problem with this book is motivation. Should the reader ask "Why is this important?", there's no answer.

This is not a beginner's book to programming, but if you have a little bit of programming experience and the desire to learn, this is the book for you. Thinking in Java helps you understand the thought process and concepts that the developers of Java had in mind when they developed the language. Bruce Eckel is a very experienced teacher and excellent communicator who is able to present the concepts in an understandable way. This is not for bedtime reading, you should have Java installed on your machine and interact with the book. Of course, nothing is better than attending a seminar by Mr. Eckel but this book comes pretty darn close. Don't bother with the "free" versions of this book's earlier editions, the Java Language has evolved and moved beyond them (Java added "generics" which is a major and painful language after-thought). It is clear that Mr. Eckel is not a fan of the way that Sun implemented Java (and I agree with him). But if you limit the use of Generics you can get by. If you are relatively new to programming and have the desire to learn, you should expect to spend at least three months crawling through this treasure book. It will be worth the effort. If you are an experienced programmer, this book will reveal the underlying concepts in a meaningful way to help you understand the differences between Java and C# and you can get through it in about a month. In addition, this book tries to show you how to organize your code for human readability (when properly done, your code almost reads like a human language - and please remember, I said "almost"). As a final comment, Java is a complex and verbose language (especially since Sun added generics) so this book will always be a good reference.

This is not a beginner's book to programming, but if you have a little bit of programming experience and the desire to learn, this is the book for you. Thinking in Java helps you understand the thought process and concepts that the developers of Java had in mind when they developed the language. Bruce Eckel is a very experienced teacher and excellent communicator who is able to present the concepts in an understandable way. This is not for bedtime reading, you should have Java installed on your machine and interact with the book. Of course, nothing is better than attending a seminar by Mr. Eckel but this book comes pretty darn close. Don't bother with the "free" versions of this book's earlier editions, the Java Language has evolved and moved beyond them (Java added "generics" which is a major and painful language after-thought). It is clear that Mr. Eckel is not a fan of the way that Sun implemented Java (and I agree with him). But if you limit the use of Generics you can get by. If you are relatively new to programming and have the desire to learn, you should expect to spend at least three months crawling through this treasure book. It will be worth the effort. If you are an experienced programmer, this book will reveal the underlying concepts in a meaningful way to help you understand the differences between Java and C# and you can get through it in about a month. In addition, this book tries to show you how to organize your code for human readability (when properly done, your code almost reads like a human language - and please remember, I said "almost"). As a final comment, Java is a complex and verbose language (especially since Sun added generics) so this book will always be a good reference.

I had heard a lot of positive talk about this book, so I picked it up based on that...only to find I could read it online later. The book contains exceptional in-depth information about the Java language. The writing is conversational which makes it fairly easy to read. It is less a reference book as it is written to help you understand how Java was intended to be used. It is a definite read for anyone working with Java for the long haul. If you are coming from the C++ world, there are good comparisons and contracts between C++ and Java as well. The only down side, some of the examples do get a bit long winded. A clean up in this area would have helped the book tremendously.

The 4th edition is updated to reflect changes to Java for J2SE 5/6. The content is easy to follow and contains insights on the use of the language's features and library. You will even find some critique of the language features which may be helpful when doing large software projects.

The sample code and the exercises further strengthens one's working knowledge of Java. One must make sure to do the exercises to gain more from this book.

The 4th edition is updated to reflect changes to Java for J2SE 5/6. The content is easy to follow and contains insights on the use of the language's features and library. You will even find some critique of the language features which may be helpful when doing large software projects.

The sample code and the exercises further strengthens one's working knowledge of Java. One must make sure to do the exercises to gain more from this book.

I'll make this short. I depend a LOT on buyer reviews on Amazon to help me decide what to get. This book is the best book on Java, taking the reader from the basics right up to the sexy stuff in J2SE5 like queues and generics.

This is the book that my 20+ other Java books are judged against.

I'll make this short. I depend a LOT on buyer reviews on Amazon to help me decide what to get. This book is the best book on Java, taking the reader from the basics right up to the sexy stuff in J2SE5 like queues and generics.

This is the book that my 20+ other Java books are judged against.

Thinking in Java second edition was my first purchased java book.
Even now, after so many years being java developer I still can find in this new edition a lot of very interesting details about Java language.
(Especially chapters about generics and concurrency are really amazing)
If I will be limited to have just one Java book on my desk, that would be this one!

I've had many textbooks that you can hardly read, but this one is great and easy to follow. I have some background in C++, and this book is the perfect level.

Bruce Eckel's "Thinking in Java" is the best technical book that I have ever used. I have read many technical books on Java, C, Visual Basic and a host of other programming languages and this book is by far the best written that I have ever read.

The book introduces the reader to the concepts behind the technology and builds on these concepts by providing examples and exercises. Each topic is explored in reasonable depth. This gives the reader a good foundation to build on. The book also references other texts for more detail and depth on specific topics.

I strongly recommend this book to anyone wishing to learn Java or be introduced to the object oriented programming paradigm.

I bought it by recommendation and after reading it would recommend to others.

I actually got the html version of this book for free online. I got this after I wasn't at all satisfied with my first crack of learning JAVA with Wiley's "JAVA in 60 minutes a Day". After finishing that book, I suspected that A LOT of stuff was not covered this was also due to the fact the author just got plan lazy at the end.

After reading the first few chapters of TIJ 3rd edition, I thought I may have a winner. I was also and still considering getting Head first JAVA patterns, but since this book was free, I decided to go throught this one first.

As I already said reading few the first few chapters kept me interested and more importantly, I finally felt that I was learning something. The author uses pretty good examples and also more importantly, all of his code compiles and runs properly, which is more than I can say for other JAVA and other programming books in general that are rushed to the market. This book has clearly gone through serious proof reading before publishing which makes reading and studying the code much less frustrating. I can't tell you how frustrating it is to see a code snippet in a book only to compile it and it have snytax and Runtime errors all over the place. I have not run into this problem with this book so far. The only thing you have to do to some of the code is change the packages to match your own directory structure or better yet just use his verbatim.

Now for my dislikes. While this book seems to be very throrough, it can lead to VERY LOOOOONG chapters. I am still on Chapter 11: Collections of Objects, and this is my 5th day on the same chapter. Working anywhere from 8 - 10 hours / day, I don't have the time do a chapter a day. When I first started this book I usually did a chapter with the excersises in a couple of days, now its more like a week. One good thing about viewing this in a web browser is that there are no page numbers. If I actually saw how many pages some of these chapters were in the book version I would be overwhelmed. Even still the length of some of the chapters cause them to become boring and you may find yourself just wanting to rush through the last parts just so you can be done. Whenever I feel myself getting like this, I take a break and come back to it later. This forces me to to not "rush" through. I have to do this becuase I am not trying to "zoom" through the book, I am taking my time and asorbing what the author is trying to teach. I even started compiling and running his examples and actually going through each line of code to see what he's doing. This is a must in some of the later chapters because there is some subtle code that you may miss if you just read it in the book. This is not one of those "Learn x in 1 day" books. This will take time but in the end I think I will be satisfied. I think this book would also make a good reference book if you forget how to do something due to the abundance of information.

Another complaint is that his code is very hard to read at times due to his odd placement of curly braces ("{" and "}") and also he takes some shortcuts in his code occasionally. I am coming from VB6 and C++ and in C++ I am accustomed to having my curly braces on different lines especialy with a class and function definition. However he frequently uses this format: (note: the tabbing is not captured below)


class A {
private int i;
public void f(){
//do something.
}

}

I would write the exact same class this way: (again, tabbing is not captured.)

class A
{
private int i;
public void f()
{
//do something
}

}

Of course both versions are perfectly fine, but it just comes down to a readability issue and what you are used to. It may not seem like a big deal to begin with, but once the programs get more complicated, if you are used to my or one of your own styles his code will become very hard to read. I ended up copying his code into Notepad and placing the braces as I am used to so I can more easily read the code.

His writting is also very hard to read at times. He frequently uses parenthesis to explain something else while he's still trying to explain what he was originally talking about. His overuse of parenthesis can throw you off your original thought if you are not careful.

Examples:

"As expected, arrays are faster than any container for random-access lookups and iteration. You can see that random accesses (get( )) are cheap for ArrayLists and expensive for LinkedLists. (Oddly, iteration is faster for a LinkedList than an ArrayList, which is a bit counterintuitive.) On the other hand,....."

"You need to build only one container, and any Java object will go into that container. (Except for primitives, which can be placed in containers as constants using the Java primitive wrapper classes, or as changeable values by wrapping in your own class.) This is the second place where an array is superior to the generic containers: When you create an array, you create it to hold a specific type (which is related to the third factor--an array can hold primitives, whereas a container cannot). This means that you get compile-time ..."


A final complaint is that he occassionally throws in some things in is sample code that he has not gone over yet. Many times he explains what he does AFTER the code, but sometimes you are left wondering what the heck he just did, hoping that it would be covered in the next section or a later chapter.

In summary this is a good book for me so far. It can be time consuming, frustrating and boring in some places, but I think the author does a good job in teaching you. As others have said this book is not for beginners and definetely not for someone who has no Object Oriented exposure with any language. This is my second time "learning" JAVA and I am getting through it probably because I was already at least familiar with many of the things he teaches. If this was my first run through it, I probably would be having a much, much harder time. This book is doing a much better job than those watered down "Learn JAVA in 2 hours!" books.

This is without a doubt my favorite Java book on the shelf. To start, let me make it clear that this book is not intended for beginning Java programmers. Enough said on that.

I am constantly turning to it given its extensive coverage of the language. Concepts are explained in-depth with (most of the time anyways) thoughtful examples. I would highly recommend this book to anyone wanting to master the language.

My best to Mr. Eckels!

Id say Eckel doesn't choose so obvious examples for what he wants to explain, and he lacks finesse in writing so you have to read REAL slow, but this book is good so far I've read it.

I payed nice sum of money for it, although you can download it for free.

What you can download FOR 20 $ are solutions to questions at the end of each chapter.

Isn't that a little too much? Couldn't they sell the book and give away free CD/PDF file with solutions of homework questions? Or write answers at the end of the book? This reminds me of selling bycicle with flat tires or with no seat...

I wouldn't reccomend this book to newbies in world of obj oriented languages.

Id say Eckel doesn't choose so obvious examples, and he lack finesse in writing so you have to read REAL slow, but this book is great so far Ive read it.

Wouldn't reccomend it to newbies in world of obj oriented...

This is NOT a beginner's book. The sheer size of this weighty tome is overwhelming, and it does not come with rollers. It is a great book for your second pass thru Java, certainly more so than any other book that I've looked at. I have extensive teaching experience and I do spend lots of time examing books. Eckel is a very readable and much more than competent writer as attested to by the great sucess with his previous C and C++ books. They are still great reading and studying books. For Java starters, you can't do much better than the Sierra and Bates book, 'HeadFirst Java' from O'Reilly. (By the way, at good price from Amazon). Check out their newest, Design Patterns in Java. Everything in the 4th edition of this now classic Eckel book looks more polished. In agreement with other reviewers, this book lacks a polished publishing job. Where are the pictures ? A little UML might be nice. Can we get a nicer font and less huge margins.
This review is dedicated to the memory of the Sahara Forest.

[Note: this review refers to the 3rd edition. I haven't had access to the 4th edition to see what has changed.]

The summary says it all. This 1,000+ page monster probably has the best coverage of all the Java books purporting to be considered as introductory texts. In terms of completeness, it is better than the Sierra/Bates and Deitel books. However, these two books are much more approachable, with better layout and presentation, whereas working through this book is sheer drudgery.

The book uses extensive use of long examples to demonstrate the various language concepts and features. This approach IMO is very long-winded, and bumps up the size of the book to its present doorstop size. The coverage of inner and anonymous classes gets bogged down with the excessive use of example listings, while the treatment of the Java I/O System runs to 110 pages, and Collections to 120 pages, more than double that used by Deitel! A better approach IMO, as successfully used by Lippman in his popular C++ Primer, would have been to use small code fragments to demonstrate each point, and then present a more complete, compilable example at the end of each section or chapter. With free time a precious commodity, I want to learn new topics as quickly as possible, and learn the more esoteric details from more specialised sources later.

The presentation of the book could also be improved. As has already been mentioned by other reviewers, there is a dearth of diagrams to break up the monotony of the presentation. For example, Eckel makes occasional reference to design patterns in the text. Why not add UML diagrams to emphasise the point? Also, the coverage of the Java I/O Syetem, with its large collection of interrelated classes, simply cries out for a class diagram.

The book can be used as a very readable language reference. I should mention that Eckel's writing style itself is quite readable; a pity about the dour presentation. The on-line availability of the book is also a boon for searching particular topics.

[Note: this review refers to the 3rd edition. I haven't had access to the 4th edition to see what has changed.]

The summary says it all. This 1,000+ page monster probably has the best coverage of all the Java books purporting to be considered as introductory texts. In terms of completeness, it is better than the Sierra/Bates and Deitel books. However, these two books are much more approachable, with better layout and presentation, whereas working through this book is sheer drudgery.

The book uses extensive use of long examples to demonstrate the various language concepts and features. This approach IMO is very long-winded, and bumps up the size of the book to its present doorstop size. The coverage of inner and anonymous classes gets bogged down with the excessive use of example listings, while the treatment of the Java I/O System runs to 110 pages, and Collections to 120 pages, more than double that used by Deitel! A better approach IMO, as successfully used by Lippman in his popular C++ Primer, would have been to use small code fragments to demonstrate each point, and then present a more complete, compilable example at the end of each section or chapter. With free time a precious commodity, I want to learn new topics as quickly as possible, and learn the more esoteric details from more specialised sources later.

The presentation of the book could also be improved. As has already been mentioned by other reviewers, there is a dearth of diagrams to break up the monotony of the presentation. For example, Eckel makes occasional reference to design patterns in the text. Why not add class diagrams to emphasise the point? Also, the coverage of the Java I/O Syetem, with its large collection of interrelated classes, simply cries out for a class diagram.

The book can be used as a very readable language reference. I should mention that Eckel's writing style itself is quite readable; a pity about the dour presentation.

[Note: this review refers to the 3rd edition. I haven't had access to the 4th edition to see what has changed.]

The summary says it all. This 1,000+ monster probably has the best coverage of all the Java books purporting to be considered as introductory texts. In terms of completeness, it is better than the Sierra/Bates and Deitel books. However, these two books are much more approachable, with better layout and presentation, whereas working through this book is sheer drudgery.

The book uses extensive use of long examples to demonstrate each language concept and feature as they are introduced. This approach IMO is very long-winded, and bumps up the size of the book is its present doorstop size. The coverage of inner and anonymous classes gets bogged down with the excessive use of example listings, while the treatment of the Java I/O System runs to 110 pages, and Collections to 120 pages! A better approach, as successfully used by Lippman in his popular C++ Primer, would have been to use small code fragments to demonstrate each point, and then present a more complete, compilable example at the end of each section or chapter. With free time a precious commodity, I want to learn new topics as quickly as possible, and learn the more esoteric details from more specialised sources later.

The presentation of the book could also be improved. As has already been mentioned by other reviewers, there is a dearth of diagrams to break up the monotony of the presentation. For example, Eckel makes occasional reference to design patterns in the text. Why not add class diagrams to emphasise the point? Also, the coverage of the Java I/O Syetem, with its large collection of interrelataed classes, simply cries out for a class diagram.

I should say that Eckel's writing style itself is quite readable. The presentation is simply too dour to use as a first introduction to the language. However, the book can be used as a very readable language reference.

Book provides good starting point for learning the basics of java.

This book is the clearest text on what Java is and removes the scariness of programming in this language. I found it easy reading and very captivating.

Thank you Mr. Eckels!

Gung Godo

I first bought this book in 1999 on the first edition covering JDK 1.1. Over the years I have browsed the newer editions and compared it to other java "teaching" books out there. This book is simply beyond compare. If you want to UNDERSTAND Java programming, get this book. If you just want to know how to slap some java code, get other books.

I enjoyed this book. I am not a professional programmer, so I was interested in a basic introduction to Java. Eckel does a good job at explaining key concepts. I expecially liked his discussions on polymorphism - probably the best I have read to date (I think I finally understand abstract classes!). His examples are beneficial in that they are stripped down to illustrate key points. He also addresses inner classes and interfaces well. I would recommend getting a decent java IDE and stepping through the code examples (I have been using Eclipse). If you are new to java - I would recommend this book! Wagsman.

Bruce Eckel respects his readers. TIJ is one of the most well thought out tech books I've read.

When it came time for me to begin learning Java, I was overwhelmed with all of the information available. I felt buried. Java books all seemed to start at the deep end and go deeper. Internet forums were filled with either people that "got it" or people like me that had no clue.

Someone then gave me an older copy of TIJ, and I began reading. At the time, much of the OO jargon was over my head, but the manner in which it's presented in TIJ allowed me to continue reading without feeling completely lost. Instead of meaningless diagrams and polysyllabic buzzwords, Bruce uses plenty of concise code examples to illustrate his explanations.

Bottom line, check out a few chapters of this book online. You will want to buy it after that.

This book does an excellent job of introducing reader to the concepts and intricacies of Java language. The author shows deep understanding of language, and communicates in a clear and conversational way. However, I would have liked to see more diagrams in this book. Of all the Java books on planet, this one probably has the least number of diagrams, which in my opinion, is not a good thing as many people, including me, are spatial learners and understand things much better through illustrations. The biggest problem I had was that the chapter on GUI does not have even a single diagram or picture, which made it very difficult for me to visualize many things.

Other than this single aspect, the book is great. It is interesting to read, has big size font, and the examples and exercises are focussed on language concepts rather than fancy stuff.

This book is available, for free, from the author's website (www.bruceeckel.com); the book, however, is far easier to read in book form than your monitor or a foot-high stack of printouts.

What I love so much about this book is that Eckel doesn't so much tell you how to "go through the motions" of writing Java (like 99% of programming reference books), but instead goes into great detail about what the creators of the language were actually trying to accomplish, and why they did what they did. The net effect is that you are truly able to "think in Java" (corny, I know...).

For the same reasons, however, I wouldn't recommend this book to novice programmers. Many of the concepts covered (such as heap allocation, upcasting/downcasting, JavaDoc, etc...) go into some fairly abstract computer science ideas, and while this material is covered in an extremely easy-to-follow fashion, I think much of it will go over newbie heads.

I know Java pretty well. But I enjoy a lot reading Eckel's book because he presents aspects of Java you rarely find in ordinary Java books. Bruce admirably mixes low level concerns with conceptual representations. He has a real talent to explain the "why" of things. This understanding differenciates the expert form the simply proficient. For this reason, as an experienced Java programmer, I do not consider reading Bruce's book a waste of time !

I am reading Thinking in Java, have read a couple of more books before on Java but Bruce Eckel has a flawless style of exploring and explaining a programming language, learning becomes more like a glide through the concepts...brick by brick he constructs a beautiful conceptual foundation of the language...everything in the exact right place in the mental sequence where it should be...perfect!! He should write a book on each programming language :-)

If you've been wandering through places to find the best conceptual reference...this one is it.

This book was great. I cannot deny that the author seems intensely intelligent, but able to convey his Java knowledge in an understandable way. His examples, though, are freakishly LONG. This, for me at least, made the learning process somewhat labored. Worth the money, though. The book covers a LOT of ground very well.

I started out with a printed version of Bruce Eckel's Thinking in Java 3. After some two hundred pages I decided to put the book down. Why?
The biggest problem was the examples. They simple grew longer and longer and contained lots of code that had absolutely nothing to do with what Mr. Eckel attempted to explain. For instance, most examples were provided with code whose only job it was to prove that the program really produced the intended result ("see I was right?"). Not very interesting from an educational point of view.
Another problem: Mr. Eckel is afraid of graphics. His book is full of text, but he hardly uses graphics to visualise a topic, thus making the information harder to memorise.
The title of the book is somewhat misleading. Mr. Eckel is not thinking in Java at all. Mr. Eckel is thinking in C++ and projects his knowledge on Java. The continuous references to C++ are very annoying for anyone not familiar with that language, such as me.