Rating: 
Summary: You will benefit from a study of this book
Review: This is not a book you can simply read. Mr. Eckel's formal academic training in physics and engineering is reflected in the character of this book and you must be prepared to approach it as a serious study and programming project at the university level of rigor. You will need lots of time if you want to "graduate". The book is very code intensive. If you don't have access to a Java development environment to step through the code examples, examine variables and methods, the state of threads, and work through the exercises then I would not recommend this book to you. The book is actually the course material for a student-oriented computer lab environment and attempting to absorb the contents of this book by reading alone would be an extremely difficult experience indeed. The book goes deep into the workings of the language and represents a valuable review exercise for experienced Java developers, but an intense and arduous learning experience for those new to Java. Regardless of your programming experience, you will benefit from a study of this book. The pros and cons are provided below: Pro: The author has empathy and has seems to have anticipated readers reactions such as confused, surprised, doubtful, and then goes on to clarify. You are not left hanging. Pro: The author explores deep concepts by introducing interesting twists and exposing various caveats in the code segments. Pro: The chapters on threading and distributed computing are excellent and provide very insightful descriptions of the subject. Pro: Each chapter is logically and consistently presented as Introduction, Theory, Practice, Analysis, and Exercises. Pro: The author is able to remain subjective and even exposes some questionable Java design decisions and apparent bugs, e.g. in the Java I/O system. Pro: The CD includes some useful code scaffolding such as the applet running framework. Pro: A solutions guide to the exercises is (finally) available for a small fee. Pro: The author has excellent writing and communication skills. Pro: The code examples actually work. Con: The paper is super cheap and gives too much light reflection. I always had to adjust the position of the book to move the reflection elsewhere. A major irritation! Con: The use of color and UML diagrams is not provided. This makes the book rather dry and often difficult to obtain an overview of the text and code structures. At best bold text is used to highlight class and method names but this is not enough. The code in the electronic version of the book does use color, which makes it much more readable then the same code printed in the book. Con: Program listings in monotype font make it hard to scan for key words and program blocks. Also, the code listings are packed tightly together. The resulting lack of white space makes reading the code a real chore. Con: The next edition should be published as two separate volumes. The book contains over 1100 pages and this is already the upper limit of what most people are prepared to deal with. Con: The section on passing and returning objects tends to ramble on forever (pages 1013 - 1061) without really making a point. Con: The book contains far too much advertising clutter. There are 6 pages of promotional ads, 8 pages of biased reader reviews, 9 pages of legal [stuff]. I simply cut these pages out. Now the first page in my book is the overview - the way it should have been in the first place.
Rating: 
Summary: Could be better.
Review: I don't want to repeat all the criticism that this book already received. Just few points:
1. The CD-ROM attached to the book has nothing to do with the book itself (the title of the CD is "Thinking in C: Foundations for Java & C++"). I would like to have something more useful. I did'n buy this book to learn C language.
2. Eight pages of reader comments with all this "brilliant", "the best computer book", "excellent", is too much. These pages could be better used.
3. When you buy the book online you don't know that you have to pay extra for the solutions to the exercises. The solutions are sold on Bruce's site. Not bad way to make extra bucks for the author, but it's bad for the readers who have to pay extra money.
4. The author dives into the depths of the language but forgets to explain the elementary things. The assumption is that the reader already knows C++ should be discaimed. I haven't seen many books that are so poorly organized.
Rating: 
Summary: Overrated...
Review: What are these people thinking? I get the impression sometimes that all you need to do to get a five-star rating is number all the pages. This is not a terrible book, but it's definitely not five, or even three, star material. I also have Horton's "Beginning Java 2" and Deitel's "Java - How to Program". I don't think these are five-star books either, but they're both much better than "Thinking in Java". Several things hurt this book. One is the author's reliance on comparing concepts to C++ - great if you know C++, but I firmly believe you don't need that to learn java, IF the material is presented correctly. Neither Horton nor Deitel assume any exposure to C++. Another failure is in the author's code examples. He is generous with these, as is expected, but his descriptions and explanations of his examples are insufficient in many cases. No problem with easy examples, but the reader is left to struggle when more complex examples are presented. It seems like the longer the example, the shorter the explanation. Both Horton and Deitel offer very comprehensive explanations of their examples. Deitel even goes so far as to number every single line of code, and explain virtually every line of code, number by number. Compounding this is the almost complete lack of diagrams and graphics. For example, the author rambles on while trying to explain the hierarchy of the Exception class, when a simple tree diagram (as most books use) and brief explanation would have been so much clearer. In addition, there are no graphics of what his GUI code examples produce. If you're trying to work through one of the author's GUI examples, you have no way of knowing with any certainty what it's supposed to look like, because the author doesn't include any graphics to show you. Same problem with his examples that generate text output to a DOS window - no pictures to show you what the output should look like. Both Horton and Deitel include graphics to show what the code will produce. Also with regards to his GUI coverage, the author treats layout managers much too lightly and blows off GridBagLayout completely, essentially saying it's too complex for him to address and that you should instead look to a Swing book for guidance. Both Horton and Deitel address layout managers, including GridBagLayout, without problem. If you were to compare the TOC of the three books, you might think "Thinking in Java" had the edge, with it's coverage of beans, JNI, JSPs, servlets, RMI, CORBA, and JDBC. However, their coverage is little more than a quick summary followed by recommendations to seek out other books on the respective topics. In summary, this book is not a complete waste, and I do use it to complement my others. It's single greatest redeeming quality is that, technically, it's free. I'd recommend going to bruceeckel.com and downloading the text. Review that and then decide if you want to buy the hardcopy.
Rating: 
Summary: Learn C First Then C++ Then Java
Review: Granted there is no one way to do anything, but some ways are better than others. I speak from experience of spending *MUCHO DINERO* on Java books. Learn C first, it's a small language and you can master it doing embedded programming on the Palm. Then learn C++ which is a true large applications language. If you still want/need to learn Java after all that then learn it, but beware, Java is all-inclusive, and simply humungous. Java has built in libraries for everything under the Sun, and you'll have to learn most of them and keep up your knowledge to be any good at all. Simply put, to be a successful Java programmer you'd best have a mentor, lots of reading time, experience in C/C++ and a very sharp mind. Also, keep in mind that Java is currently a Web and server language, and not really good for desktop apps or Embedded because it is just too big and slow for lack of pointers. Don't be conned into thinking it's easy.
Rating:
Summary: Java Masterpiece
Review: Assumptions: If you don't like the works of Peter van der Linden, (or Jason Hunter and Brett McLaughlin, for that matter) stop here; you have no business reading my review. Level of experience: Tech writer, not a programmer Strong Opinion: Along with "Just Java", this is absolutely the best general book on Java ever written. Like Peter, Bruce has the twin gifts of clarity and context. He presents the material in clear, clean, precise and lively prose -- and he puts every concept into context. That is, he doesn't just explain "what" Java does, he explains the assumptions underlying "why" Java does it. One (albeit deluded) reviewer of this book complained that Bruce included info on the Internet and background on Client/Server in chapter one -- a chapter on objects. Well, duh! In this incredibly concise, extremely well-written chapter, Bruce stitched together the evolutionary threads that made Java make sense as a web programming language. Later on, in chapter two, Bruce presents *memory* in its full context: registers, stack, heap, etc. and talks about why java does things with memory the way it does. I don't know much C or C++, but I think -- in many circumstances -- it's quite valuable to understand the way Java operates vis a vis these other languages. It brings context to the table and, for me at least, context is vital in understanding concepts. Another reviewer (to remain nameless) complains that bruce repeats himself, citing references in several different chapters to garbage collection (instead, apparently, of putting all the references in one tidy gc chapter). Well, once again, this completely misses the point. Bruce talks about garbage collection in several different chapters becasue it lends context to the topics he's discussing. You have to wonder about some of the people who write these reviews (present company excluded!) I could go on and on about this book, but the point by now is obvious. If you value clarity and context and want to know not just "what" Java does but "why" Java does it, read this book. It's a masterpiece.
Rating:
Summary: Keep shopping
Review: It's difficult to learn Java using only this book, as he doesn't get to the necessary depth, and he constantly mentions a Java feature and says, "but we'll learn more about that later." There are better books out there!
Rating: 
Summary: Who is the audience?
Review: I could not determine which audience this book is intended for. The author assumes that readers are already familiar with C++ - at least this helps to understand the book better. But coming from a C++ background, I found the book wordy and carrying lots of redundant information on subjects that most C++ programmers will already be familiar with. The "redundant information" are for, I imagine, beginners to computer programming. But this information is difficult to understand for a person who is studying programming for the first time. So I am confused to which audience this book is targetting. There are definately nuggets of information that I find valuable - but these can be more readily accessible elsewhere - like in an O'Reilly primer. And beginners will be better served by reading a gentler introduction to Java.
Rating:
Summary: gREAT! But...
Review: This book is great, especially for someone moving from C++ to Java. This book should have had the title THINKING IN JAVA WITH THE MIND OF A C++ PROGRAMMER, or something similar. If you are a C++ programmer, you will LOVE it! Before you buy this book, check out the electronic version of the book, available as a free download at http://www.mindview.net/Books. See if the writing style suits you, and the frequent references to C++. You will get frustrated with this book if you have no programming experience at all. The only thing I don't like about this book is its poor organisation of topics. But, you might ask, why I gave it 5 stars. It's becuse of its EXCELLENT content.
Rating:
Summary: Excellent overview of Java
Review: I probably own 50 computer books or so and this one ranks in the top three. It presents a great overview of most of all the key areas of Java from general language concepts to topics such as JDBC. The style of presenting a topic and providing numerous simple examples makes understanding the concept easy. The only complaint is the terrible optics of the boring font sytle that is used. It's also recommended a book such as Java in a Nutshell or referring to the sun documentation on the API's is used when reading this text. However, whenever I want to refresh my understanding of a certain topic, this is the book that refereneced. It's easy to understand and it covers a lot of areas. If you really enjoyed a book like Stroustrup's The C++ Programming Language, where every sentence is a challenge to comprehend, this isn't the book for you. But if you like clear simple explanations, Thinking in Java is the book.
Rating:
Summary: Content very good, organization not so good
Review: The book is chock full of really useful information, but I had a few problems with the book:
1. It should be called "Moving from C/C++ to Java". If you don't know C/C++, you will find the many references to them annoying.
2. This is not a book for beginning programmers. In the introduction the author does say that this book is intended for a reader who has some programming familiarity.
3. I found some of the organization confusing. For example, I think the last 1/3 of the "Introduction to Objects" chapter (Internet, client/server programming, etc.)should be in another section. These topics don't really have anything to do with objects.
| 
