Thinking in Java (4th Edition)

If you have some procedural programming experience already then this book will be great for you to switch to the world of OOP. If not, then take it slow, but it can still work. I took an OOP course featuring C++ and got lost quickly, but in just a few chapters of Bruce Eckels' book, he helped me to understand what I had missed. The book starts out with a great foundation of explaining what objects are, then tells us that Everything is and object, and explains why. It explained these concepts in simple terms. The book then pays a little respect to program flow. For those who already have had programming experience, this is a quick read. Then it is back to the OOP ideas and then on into some more advanced Java topics. Excellent grouping and interesting section titles keep it a relatively light read. It covers the Java language, not just applets. That was refreshing.

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.

I heard so many good things about this book - and can't say I was not disappointed! First, I must say, this book has *A LOT* of material. It covers much more subjects than any other java book I saw. However, it's not very clear. and it uses "too many words", so to speak. For example, there is a chapter comparing some strange nuances that C++ and Java differ in... Who cares?? I spent so much time reading these things, it was difficult to tell what is important, and what isn't. Also, there are no code sample runs, which makes the examples difficult to understand. Last, for every small thing the author uses 2-3+ pages of examples, which makes understanding cumbersome, sometimes 1 page would be enough. However, it's still worth buying, because of the depth. When I just started learning Java, I bought another Java book which had considerably less material than this book, and read it, and if I needed more information, I would just read the appropriate chapter in "Thinking in Java".
To sum it up, in my opinion, worth buying, but not as the only book. Good as the 2nd java book.

As an object-oriented consultant and author myself, I wanted to express that I believe this is one of the great Java books avaiable. What distinquishes it from other books is that it is written by one of the few people whom I consider to be an expert in both object-oriented design and Java. The fact that Bruce clearly understands how to teach and write makes it even more valuable. Extensive code examples allow people who like to see the details wade through them. If you are more conceptually oriented, his bigger view of object-oriented design makes learning why you do certain things clearer.
Bruce even brings in design patterns in a very applied manner. Until I read his explanation of how stream io was an implementation of the decorator pattern, I always wondered why it was done this way.
If you are a detail oriented individual, it may be that you would want a more reference type book to start with (say, Horstmann's Core Java). However, Thinking in Java would still be an invaluable companion to peruse in tandem. If you are a bit more conceptual and like to understand why you might be doing what you are doing, then this book is definitely the one to use.
Alan Shalloway, author of Design Patterns Explained: A New Perspective on Object-Oriented Design

This book is not "Teach Yourself Java while watching TV" or "Learn Java in 3 minutes a day" - this is really more of a comparison to many other languages, along with lucid explanations of java's unique features. You should have some programming experience before picking up this book. C++ or smalltalk experience would be helpful. Any structured language though would be good to get started. The reason you should have SOME background is that the author spends a lot of time drawing parallels between java and other languages, and it helps to have some perspective. At least if you don't know about the language he's talking about, then at least you can fill in the language of your choice and try to draw your own parallel. The chapters on garbage collection and exceptions were very helpful. Serialization became clear to me. Good coverage of the difference between the stack and the heap and why you have to "new" a class but not a primitive data type.

Bruce Eckel, author of "Thinking in C++" has done it again. This book is one of the best books on learning Java I've found, yet you can still refer back to it when you run into problems.
That's because not only does it discuss Java clearly, but it also discusses the "gotchas" in the language.
Perhaps the best thing about this book is that it doesn't subscribe to all the hype. You can tell that Java has great potential, but yet there are still problems. This is quite a relief from the arrogant Sun style of "don't argue with us, we know more then you".
I personally recommend that you buy this book and Java in a Nutshell. Between these two books, TIJ for in depth discussion of Java features, and JIN for a reference, a professional programmer should have no problem coming up to speed on Java.

... but not for beginner with no programmng experience at all.
If you are a C++ programmer and want to transfer to the Java world, this is the book for you.
This is the only java book i read so far that really makes you not just do programming but also think in java. Before I picked up this book, i was so naive and believed that Java was only a little more powerful than C++. but in fact, i am wrong.
While teaching me Java, the author also shows all the programming tricks in Java to me. If i don't have the book, it will take me 1 or 2 years in Java to get that. The chapter on inner class is incredible. And the explanation on Garbage collector is very helpful too.
Honestly, to master a language, you can't depend on only one book even it's as good as thinking in java. but this book should be one of your collection.

I was extremely disappointed in this book after reading all of the strong reviews. My main complaints come down to two major areas: the excessive use of sample code and the poor choice and grouping of contents.
First, many of the major ideas are presented in blocks of sample code. At first, this is good, because the samples are short and you are just seeing the basics. However, this soon becomes a very bad thing. Often, key new pieces are buried in a long sample program, most of which is boilerplate repeated from the previous example. You often have to read through a couple of pages of code to see one small new snippet.
To make matters worse, the relevant new sections in the sample code are not highlighted from the surrounding old stuff. And sometimes they only appear in the example code and are not mentioned in the book's text. It is just too hard to see the important parts.
Additionally, some of the code examples are almost completely pointless. For example, when talking about method overloading, the book contains about four pages of code with variation after variation of the same 1-line function just varying the type being passed in. This is silly. Showing every single permutation is ridiculous! Plus, the book never includes the output of any of these programs. Often, the whole point of the example cannot be determined without looking at the output, and the book doesn't reproduce that, nor does it explicitly state the point of the example.
The second problem area is the organization of material. There is a lot to cover and it makes sense to defer less important details. Unfortunately, the book just throws in tons of junk! For example, in the 85 page I/O chapter, the book makes diversions into gzipped I/O streams and string tokenizing. Now these may be useful utilities, but there are so many basic elements to cover, I really wished the chapter stuck to the core.
Ironically, in the next chapter on Class objects and RTTI. The author glosses over almost all of the details (except for a few you can glean only by reading the code snippets). I'd rather defer the stream tokenization until later and have a page or two of explicit description of Class objects.
Argh! Then we get to the Windows and Applets chapter which begins to describe JFC and Swing and various widgets and layout schemes, and manages to go the entire chapter without a single picture or diagram of what to expect!
I found this book to be frustrating, not explicit enough for a programming book, and not organized well for an introduction to Java.

While the actual syntax and diction of this book weren't too horrible, the overall presentation and organization of the book is very poor. The author divides up the chapter not according to decimal numbers (for example chapter 1.1, 1.2, 2.1, etc...) but THE SIZE OF THE HEADLINES. Even if you flip back and forth constantly to compare sizes, you’ll need a ruler to measure the point size of the headlines to tell whether the author is trying to introduce an entirely new concept or explain more about a previous one.

Trying to find a definition to one of the vocabulary words in bold text is painful. Very rarely does the author actually come out and say what a term means. Instead he will go into how it is useful, and how it can be useful in methods (ideas and such; not class functions).

The author spreads ideas around in the text. For example, I think I've read about four chapters so far that end by talking about how good the garbage collector is. It would be nice if the author instead talked about the garbage collector in one specific chapter in the book and just told the reader to refer to this chapter whenever they wanted to learn about the garbage collector instead of describing what it is and why it is good over and over and over.

At first impression this book is for the beginners. Just read the chapter
names: Introduction to Objects, Controlling Program Flow, Polymorphism. But
when you dig deeper, you find non-trivial details and unique views on the subject.
This book looks at the Java language and its main features and facilities from many
different angles, and many of its points are refreshing. What's more
remarkable is that the author does not dump on you intrinsic details as if
preparing you for the Java topics on Jeopardy, as some authors do. Bruce
Eckel finds pearls in common features and gives you just enough details to make
a point. This is a very clear, thought provoking, and useful book.

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.

As a programmer who already has a deep understanding of object-oriented design, I find this book to be terribly dull. Bruce Eckel clearly understands his subject matter, but he chooses to beat every subject to death before moving on. Frequently this takes the form of code listings *many pages* in length just to illustrate applying a particular principle to every single primitive datatype in Java. This book could be much improved by reducing many of the code listings to snippets that only show the relevant bit of code.
This book is also printed in a very large font, which, besides for bloating the book to larger than it ought to be, actually makes it less readable. The coding style required to cram all those code listings onto the pages in an oversize font makes for very difficult-to-read code.
Nonetheless, I'd recommend this book to someone with a minimum of programming experience wanting to learn OO design in Java. Bruce does a good job of explaining the basic principles of OO thinking.

Eckel is a master at getting his point across. Thinking in Java is the perfect book for beginner to intermediate programmers who either know a language and want to learn Java and what it can offer, or those who are just beginning programming and want to start with Java. It's also a helpful reference for syntax and language usage. Eckel outlines all of the major topics (some in very much depth, others a little more superficially) in Java programming such as EJBs, inheritance, threading, network programming, and others. Also included with this book is "Learning C" on CD, which Eckel actually talks readers through and explains step by step the C language. This is a highly recommended book, although one might be inclined not to buy it... :-)

this text is excellent for someone migrating from C++ to Java. The fact that in the first chapters the author goes into extra lengths to explain that a "function" is not called "function" in Java, but "method" because it conveys the notion of "as a way to do something", as if it is something new, when actually "method" was used decades ago in Smalltalk and Objecdtive-C, tells me that the author and the audience are C-plus-plusers that evangelized their programming language to the degree of having ignored all other. And an opportunity was lost when explaining the difference between wrapper classes and type primitives, and the fallacies of mixing one with the other, since primitives don't understand method invokations. There seems to be a residual attachment to 1970's knowledge of 8600 CPU architecture and how assembly language and C allocates memory when reading about "registers" as one of the possible ways to allocate memory. Personally, I think that's computing archeology, and should not be mentioned in a generic Java programming book. If it were for a specialized small-memory footprint Java book, say, for example, for coding small apps on the Palm Pilot, then yes, it would have been ok.

[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.

This book goes way beyond the "tips and tricks" explained in so many other Java books. It explains in exhaustive detail how and why one should use the object oriented features of the language to produce professional-grade code. It explains many finer points of scope resolution, syntax, and class design which I have never seen covered anywhere else.
It does not attempt to cover every nook and cranny of the standard libraries, and chooses instead to use the most important ones to illustrate how things work in Java, and to demonstrate instances of good object-oriented design and coding practices. The whole idea is that, once you understand the underlying principles of the language, you'll be capable of using the free Java API documentation without needing everything to be explained to you any further.
I have only two minor quibbles. One is that the examples he provides often strike me as overly simplistic. I understand the need to keep code samples short and sweet, but I find it harder to remember the significance or the relevance of a coding construct when it is just used to push around "dummy" data members for the sake of demonstration. Longer, more realistic code samples would have helped me assimilate and retain the material better.
The other quibble is that I find the wording of some sentences to be a little vague. I sometimes find myself reading the same sentence several times before I feel that its meaning is clear to me. But this doesn't happen often.
Some other reviewers have panned this book. Maybe they were expecting that learning Java was going to be easy. It is not and it never will be. If you feel that you have some understanding of how to hack in Java, C or C++, and now you want to become a skilled object-oriented Java software engineer (and you're willing to put in the time and effort required to achieve this), you will find this book to be worth many times its cover price.

I am a (happy) consultant working for the biggest dot-com in the world (not that one, the other one) and in the process of getting ready to take the Java Exam. This is a classic.
Yes, learning Java is becoming more tedious as the language gets more mature; Java 2 has just added a 'few' classes, but like I always say, you don't learn English by reading one single book; the same analogy applies here. You should read a set of Java books (and keep on reading) to move from one level to the next. That 'set' should include this one.
Thank you,

I'm rather surprised at some of the reviews. One says that it's for experienced and another for non-experienced programmers. I'd say that this book could be used for both. In fact, Bruce never claims that this book is for beginner programmers. A pre-requisite is that you should have some programming experience. True, not necessarily Object-Oriented Programming (OOP), but some experience. The book even includes a CD on programming in C. I believe the intro to objects chapters were great. Since, I had a solid background in OOP already, I asked a number of non-OOP to read it. Most understood the concepts. Also, I don't know many peoople who understood OO concepts just from a book. When some colleagues (new to OOP) had trouble with these chapters, we reviewed a few topics and then the chapters made sense. In addition, the book reiterates those intro topics throughout the book in order to drive the OO concepts home.
All that aside, Bruce seems to make the most difficult subjects so clear that I slap myself on the head and go "Why didn't I see that in the first place?". This book provides the best breadth of the Java language. I believe the book explains all concepts of a Java topic in great detail. I also like how he contrasts Java to C and C++ for those that have that background. If you're new to a topic in Java, I'd suggest starting with this book. You'll understand the concepts and be able to go elsewhere (other books, Java docs, etc.) for more detail. To me that's the key -- understand the concepts. If you understand the concepts from a language's perspective, you'll be able to easily delve into the details and because of that, be more productive. And that's what this book is all about -- Thinking in Java.
One more comment. I would highly advise getting this book and his CD. It's just like being at one of his seminars, except not being able to ask questions. Plus, the CD is a bargain.

I highly recommend this book to anyone wanting to learn Java. Bruce is one of the best technical writers to emerge on the scene in a while. In addition to providing great source code examples of Java, he also lays the groundwork for discussions on Design Patterns and more advanced Java topics such as RMI, JNDI, and threads. The Core Java series by Horstmann and Cornell is also a must read, but I think Bruce gets the nod if you have several years of coding/design/development experience and want to make the leap into OO and Java.

If you had graduated from school recently, and would like to take a career in Java, this is the book that will appeal to you the most. Why am I talking about the propensity of this book for new grads? Simple. It has a text-book approach throughout. However, the author takes enough pains to go out of the way to lay strong emphasis on the basics. Sometimes the details are so overwhelming, that you would tend to think as though you are being led astray. But, I bet you that such hard taming of the subject will surely make you a Java Guru.
In Tamil language, they say, "A modicum of rice, would prove the worth of an entire feast". To prove the indispensability of the book, please go through Chapter 4 - Initialization & Cleanup. If I had paid the money to get this book, I am satisfied for just this one simple chapter. I can boldly talk about Object initialization now. I used to tease some of my friends who had been in the Java field for years working in EJB and other cool stuff.But when I throw a simple question on Java Objects initialization, they fall apart. This is not strange. This is not unusual. Because, any book in the market tends to shrug off such topics as of little importance. However this book has lots of basics covered with fine detail, that would only be very appealing to a majority of developers out there.
On the cons side, some examples are just mere verbose kind of stuff, running into pages. That is kind of sickening ad nauseam. There is practically no continuity in the examples, unlike some related examples in Core Java book.
Overall a very good book for a building a robust fundamental base in Java.

Overall Rating: Well done! This book will be a valuable teaching and reference tool.
Teaching Value: Excellent! An essential book on this topic.
Reference Value: A complete reference. I would not need any additional reference on this topic.
This book is tremendous. The explanations are so clear and direct. Being a Java professional I read so many java books, but this book is incomparable. It's the best-advanced thinking Java book I've ever read. The best part of this is book the step-by step explanation. Each chapter takes one new topic and explains it with simple steps and examples, which is easy way to understand anything and that is really appreciable in this book. Each example program is explained with its output. The chapter on threading is magnificent, its gives the fundamental to deep knowledge of each concept, and with such easy step that one can grasp it thoroughly. All the object-oriented principles are explained so well as they apply to java along with working examples.

This book rocks period! I read half the book online and decided to give Bruce credit and bought it. I have never had such an easier time reading a huge book. Bruce Eckel's writing style keeps you coming back for more even when you have finished with the book.
Don't listen to those reviewers who state that Bruce doesn't use real world examples. Bruce uses concise and "to the point" examples and syntax that are used in everyday programming. He doesn't boggle your mind with huge source code that will confuse the reader. The purpose of this book was to get the reader a solid foundation in Java and OO.
If you are looking for some real world examples for projects then get the book Design Patterns by the Fab 4.
Hats off Bruce, I await your next book!

I purchased first edition of this book long time back, probably around 2000. It was my first book on Java. It turned out to be great choice to learn the language. Every aspect is supported with good code examples. Author also explained advanced topics such as garbage collection, object serialization, reflection, multi-threading and network programming. Backed with code examples as well. I was Java novice at that time, but this book gave me solid ground to understand some of complex Java programming concepts.
I really enjoyed reading this book. I am giving all five stars and it well deserves it. One wish I have is this book printed in hard cover.

This book comes in handy as an excellent reference for the beginner Java programmer. As many of you know, when it comes to Java it is almost impossible to fit everything into one book. Bruce Eckel does a good job of creating an overall reference book.
If you are picking the book up for a front to back read, this is a bit harder. The first 200 or so pages are exceptional. Bruce brings up some overall points that I agree with 100%. However after page 200 or so it becomes a reference book. At least for me, reading a reference book front to back simply is not possible.
Good book overall. A must have for the beginner Java programmer!

This is overrated by some reviewers.
First of all, this book will suit a C++ programmer most. The writer expects the reader to have some programming experience, so you need some programming experience to read and comprehend the book. If you are a C++ programmer trying to get a taste of Java, this book must be in your shelf. Most chapters of the book are excellent, but some are very dull.
The book covers the basics of the language very very well. Whenever I had some query about the basics, I opened the book, and on almost every occasion,I found the answer.
The chapters on GUI are dull, those should have had figures so the reader could get the picture of what the GUI would be like for the respective code. The book should have had more figures.
... This books is based on Java 2 version 1.3 RC 1. A new edition, third edition, of the book is about to hit the shelves.

Normally, I start with a new programming book at the introduction vowing solemnly to barrel straight through to the end...and then falling flat on my face and taking a course on it instead.
This book is a page turner and the exercises kept me up until 3 a.m. coding. This comprehensive book has inspired me and has turned me into a lover of this amazing language.
and to keep it all real: the worst criticism I could think of... The CD contains a huge tutorial on C++ (among the java stuff)!
What the heck?

I felt obligated to write this review about TIJ3 in the hope that it might help someone else to make an informed decision that's looking for what I thought is an excellent book on a very complex subject (really a masterpiece). The style in which Bruce discusses the content is most relaxing while at the same time being in-depth coverage on complex subject matter. His style reflects his ability to get people through complex subject matter where they might otherwise skim through the subject lightly or even skip over it entirely. TIJ3 is a must read and a must have as part of any reference library. After you get into the book you'll see why the book has received so many awards (TIJ1 and TIJ2 also). Bruce is a master when it comes to teaching and explaining complex subjects and we're very lucky that he has that same ability to put it down on paper.

While Eckel is certainly an expert in the realm of Java programming this book is certainly not appropriate for beginners to the Java language. I happen to agree with another reviewer that commented that the book requires a BS in Computer Science in order to read it. I teach Java at the college level and found the book to be too complex and tied up with too many details for anyone who wants to be a true student of beginning Java programming. The book is nice overall but at times difficult to read and follow.

This book was born out of business seminars and this fact is imprinted throughout the book. The most striking aspect of this is a lack of rigor and fluidity with what should be precise concepts. This approach is highlighted in a footnote on page 62 of the 4th edition: "One could argue for the precision of such convoluted statements, but I think my approach simplifies the understanding of the concept..." In programming, it pays to be precise about the language you are studying. It may require non-trivial discussions, but programming languages as large as Java are non-trivial. Trying to paper over details by providing imprecise explanations only hurts the student down the road.

The examples in the book also exhibit a similar carelessness. In the chapter "Initialization & Cleanup" constructors are introduced in the section "Guaranteed initialization with the constructor". However, neither of the two examples in the section actually initialize anything.

Overall, a reasonable book if you've already mastered another language (like C++, which is referred to constantly in the early part of the book). But if you are learning programming for the first time, this book will only confuse and teach simplified concepts which you will have to relearn at a later date.

Thinking and Java might seem contradictory because so many people who are too lazy to read books or learn C++ etc., flourish in Java. But this book applies thinking to understanding Java and shows that there is some logic to it. So, Bruce Eckel tells us why something is how and how it could be otherwise. And he gets away without any of the 90% filling windows images, which make up other "modern" computer books. Bruce Eckel actually thinks!

Intro:
First and for most, back when I first started programming, I grabbed the first few editions from Bruce Eckel off his website and used those books as a reference guide, jumping all over the place confused out of my mind. Now I have a very mature understanding, and 7 years of software development under my belt. I decided to borrow the 4th edition from a friend who received this book as a gift. After blowing the dust off the covers, I am reminded at how detailed Bruce can be in his explanations.

Pet Peeves:
The problem when learning something is time. If you want to read this book from front to back, be prepared to go through an extremely (emphasis on extremely) slow pace. In fact, it takes nearly 100 pages to begin discussing if else conditions. Personally, I think most of the content that is intertwined with the actual learning of the language should have been "appendixed". He talks heavily about concepts that are involved in the underlying structure of java, something more useful to the programmers at sun microsystem than the actual programmer trying to figure out why he/she should get into java. This is the kind of information that "you don't need to know, but if you're interested, keep going" kind of thing. For example, after skimming through the first 400 pages, he got into extensive discussions about garbage collection, heap allocation, naming conventions,.. in fact, around the 100th page you'd find 6 pages of nothing but lists of operators you can use (again, something that should have been as an appendix).

Oh and one more thing I have to mention, you will encounter something where he starts talking about a topic, and after you finish like 2 pages of reading, he mentions "you will seldomly encounter this when your programming". This does happen often throughout his 1080 page brick.. I mean book.

Conclusion:
This book is certainly not a pragmatic approach to understanding a language. If you are pressed for time on a project, and you need to know the bare minimum to get the job done, look elsewhere. If you are writing a thesis, your internet is slow or not working, or you need to brush up on the advanced concepts (cut the book in half, and keep the latter half).

Two Cents:
Its just crazy that each chapter can be ~100 pages long. Atleast put some pictures or diagrams, those are worth a thousand words you know.

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.

Already know how to program? Understand a little about Object-Oriented programming concepts? Don't want to waste your time reading three or four Java books to find a good one? Try 'Thinking in Java'. I just graduated from college and have very little programming experience. I found the book 's concepts easy to understand (except inner classes). Most importantly it provides a closer look at the Java programming language than other texts and you will get a better understanding of how Java works. Each chapter is filled with lots of useful information (not wordy, like other books). Some of the later chapters provide a great primer to understanding advanced topics. This is NOT a 'how to program' book. It is book for those who want to understand 'how Java works' behind your program.

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.

Already know how to program? Understand a little about Object-Oriented programming concepts? Don't want to waste your time reading three or four Java books to find a good one? Try 'Thinking in Java'. I just graduated from college and have very little programming experience. I found the book 's concepts easy to understand (except inner classes). Most importantly it provides a closer look at the Java programming language than other texts and you will get a better understanding of how Java works. Each chapter is filled with lots of useful information (not wordy, like other books). Some of the later chapters provide a great primer to understanding advanced topics. This is NOT a 'how to program' book. It is book for those who want to understand 'how Java works' behind your program.

Bruce Eckel proves both in his writing style, and coding style to be thoughtful, open to readers feedback, and constantly striving for an excellent product.
This is shown by placing the draft/final version on the internet free to review. It has been viewed by novice and expert readers, and improved by their suggestions. The book also servers a good jumping off point to other books as Bruce freely acknowledges other authors and books that have been of help to him in learning Java.
Best of all the book retains a single voice in telling the story of Java.

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.

In terms of writing syle, this is certainly one of the best text books of any kind I have read. All of the core concepts are explained clearly, usually from first principles. The author explains how things were before Java, thus providing necessary context.
Most importantly, he has his own voice. His enthusiasm for Java is not evangelical; it is based on what it can actually do. He does not jump on the bandwagon, looking down on those who don't "get it". The audience for this book is the intelligent artisan who has developed code before in some form. He certainly writes in a robust manner that assumes that his readers have thought about programming problems and issues.
A great book for those who want a more complete understanding of Java in particular and modern programming in general.

There are many sources of Java literature and learning. Some in the form of books, some in the form online tutorials.
After writing technical articles for IBM, reviewing many of the online resources, and buying dozens of Java books, Bruce's 'Thinking in Java' is still my top resource.
Bruce not only presents the information in a readable style, but gives context to specific subjects, giving greater depth and meaning to what your reading.
If you are looking for Java language specifications, go to the java.sun.com site and download the specs. If you never programmed before, go take a programming course. If you want to start your career in Java, except the Java mindset, and buy the book. Java is very deep and wide, TIJ is just the beginning of a long and wonderful journey.

This is an excellent book for experienced programmers. If you don't have experience programming in some high level programming language (like C++, C#, VB.NET,... etc.) then this book is not for you. However, if you have done some programming with a high level language then you will enjoy this book.

Although the book includes the main Java features and libraries (which is positive), I found it a bit boring and way too long. I think that for that amount of pages the reader should get much more insight. I would recommend instead "Effective Java".

Thinking in Java has the same preciseness as Eckel's "thinking in c++". Bruce amazes me with his insight into the language. The AWT 1.0 part is the most painful part of the book; but then AWT 1.0 was a disaster in design. This is a brilliant reference you wish to have on your desk when confronted with a fine lines issue.

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.

I felt obligated to thank you for you countless writing, specifically "Thinking in Java, Second Edition". Amazingly comprehensive book for newbies to coding and those who have experience but have never touched Java before. I myself have been poking around the programming and web development field (C, C++, Php and the such, but I'm only 16, your experience in these obviously dwarfs mine lol) and I find this to be one of the best books I have ever read. It's allowed me to pole vault over classes in a mere two weeks that would have taken my school a year-long course to cover.
Thank you again for you generous free web-published version of "Thinking in Java".

I am a Technical Architect at a consulting company in New York. I knew C++ and Java when I bought that book and went through it without any problems. On the other hand, if you don't know OOP well, you will get totally lost in the first chapter, which ironically is called "Introduction to objects". I teach OOP classes at my company and when I gave this book to my less experienced students they didn't understand a thing from the first chapter! Bruce talks about OOP like everything was obvious and doesn't care to explain it in more detail.
To summarize: a great book if you have a lot of experience with C++ / Java -- nice examples, tech vocabulary, good to learn some tricks, great reference. Beginners will not benefit from this book though. The word "introduction" is very misleading.

I have gone through the book 2 times. I constantly refer to it and it lies at the side of my table with the Java Developers's Alamanac. This is the bible of Java. One star less due to it's sheer size. Looks intimidating at first glance. Eckel has tried to explain too many things. Probably should divide it into two parts.