Customer Reviews

Thinking in Java (2nd Edition)

5 star:		(188)
4 star:		(51)
3 star:		(31)
2 star:		(23)
1 star:		(18)

 

 

rating 4.5.
First of all this book was freely available online. That was how it was written I believe: posted, public review, correction. A novel approach.

This books is plain inside. His prose and explanations were ostly good, but a time just a little too verbose for me (no criticism but it just didn't do it for me: I prefer succint explanation + example: he can wax lyrical just a little bit, which lends some warmth to the work, but also for busy people uneeded....so it's a personal judgement). The code examples in the book are probably the ugliest I've ever seen in a while (font wise...the code is presented as pages and pages and pages of monospace...ah the humanity! Very intimidating for the novice! Compare to deitel: colored!)

Seriously, given the process this book went through: continual public online review, editing and criticism, means the errors are minimal and the content focused on what you need to know as guaranteed by peer-reivew (not a bunch of superfluous, repitition nonsense that pad out Deitel books)...This is a really great book that was diminished a little through corner cutting by a publisher. If you can get beyond the mediocre presentation, then you find an excellent book for the above novice programmer. It's quite a philosophical journey through the heart of Java at times. And coverage of most topics is quite strong (if a little weirdly ordered at times...but then that's a personal thing: eg. the introduction that the beginning is quite deep and intrduces some heavy-ish concecpts straight off the bat...but again this is a personal judgement: objects first or basics first? its 50-50 either way?)

Actually I should clarify that: if you're a beginner: This book is not for you I don't think. I tutor a student who is just starting out in Java programming and he managed to get about 20 pages into this brick and then quit -> he said it was too hard. He opened it, looked at the code and his jaw dropped!

Having read this book I can understand why. The presentation is not conducive to the beginner who needs more guidance through concepts rather than just slabs of text. That's the problem with writing a book this way (publically post-review-correct): the only people who interact are people who already know some Java or a lot of Java so this skews the process toward producing a book for them. Most beginners probably have never heard of Bruce Eckel and thereby didn't contribute to the making of this book. Hence they have been somehwat excluded from the process.

I can wade through pages of monspace Java code because I am not a beginner. But this is probably too overwhelming for one new to the language (it just hits them too hard I think). I recommend Kathy Sierra's Headfirst Java (foremost for the beginner!). FOr everybody else...what they hey why not! It's pretty good value and not a insipid and dumb as Deitel. And it's more concrete that Van Der Linden. It and Ivor Horton's Beginning Java are on about par I feel, for different reasons: Bruce, the language coverage (depth far exceeds Ivor!). Ivor: for breadth and succinctness. I feel Bruce is wanting you to understand backward-forwards-upwards-downwards-inside-out the language. Not dazzle you with simple Swing stuff (which only works for novices anyway). When you're finished Kathy Sierra, come back and try this. YOu'll be ready by then!

Hopefully version 4 they'll put a bit more effort into the graphical arrangement of the book: a few diagrams here and there wouldn't hurt...just to break the monotony. Seriously I think Bruce should get a new publisher...one who will fulfill his vision, not impede it with their cheapness.

COntent wise: VERY good. Doesn't wallow in the cheap ooh-ahh factor of Swing that much, but does the langauge very well (I wasn't overly fussed on treatment of inner classes...but that's a personal thing I guess). Still this is one of the benchmark books for begining/intermediate programmers and that didn't happen by accident!

And as one of the benchmark books
Thinking in Java: Bruce Eckel
Beginning Java: Ivor Horton
Just Java 2: Peter Van Der Linden
How to Program Java: Deitel & Deitel
Core Java 2: Horstmann

I would rate them as such (in order):
For beginners: Horton, Eckel, Deitel, Horstmann, Van Der Linden
For Intermediate: Eckel, Van Der Linden, Horton, Horstmann, Deitel
Best all round: Eckel, Horton, van Der Linden, horstmann, Deitel
best visual layout/ quality of publication: deitel, Van Der Linden, Horton, Horstmann, Eckel
broadest view: van der linden, eckel, Horton, Deitel, Horstmann
most useful code: horstmann, deitel = eckel = horton, van der linden
value for money: eckel, horton, van der linden, horstmann, deitel

The book is great! I particularly enjoyed the following chapters:

- inner classes (this chapter kicks serious butts; far better than even Core Java 4th edition's chapter on them)

- the Class class and its usage (same stands for reflection)

- discussing the Collection classes just kicks ass - Just Java 1.2, the only book Ive read that contains SOME info on these classes is far less comprehensive. Bruce kicks ass!

- I also loved the chapter on threads - this book is the only one (I've read several Java2 books) to discuss WHY suspend/resume/ stop are deprecated in Java2 (actually, the reason for deprecating stop() is a bit misleading - the author should have stressed that it's exiting run() from _inside_ an atomic operation that causes the problem here). Just Java 1.2 doesn't even try to discuss the problem of these three methods.

- I really liked it that Bruce Eckel always prefers experimenting to repeating what the Language Specification says

- the remarks scattered in the book are particularly cool. Even Core Java 4th ed lacks the number and depth of remarks, not to speak of other books (Just Java 1.2 is even worse in this respect) <hr>

The bad points of the book:

- the Swing chapter sucks... it needs REAL update. There are no other JFC libs, either - there is no Java2D, accessibility, drag-and-drop etc.

- the discussion of sing the clipboard is far worse than that of Core Java 3rd ed. vol.2.

- the same stands for 1.1/1.2 security - both Core Java 3rd ed. vol.2. (1.1) and Just Java 1.2 (1.2) are better in this respect

- the same stands for i18n

- the introduction to CORBA was particularly weak (not that other Java-books are good in this respect)

- the author pays too much attention to the 1.0 event model - it's unnecessary. Most widgets are presented first using the 1.0 even model - do NOT teach your students 1.0 event model. At least, we at Sun Microsystems do NOT teach it any more - why would we confuse our students? So, all widget presentations should be rewritten to use the 1.1 event model.

- nextToken()'s return value when there are no more tokens is NOT an empty String but a NoSuchElementException

- there is no GridBagLayout in the book (not that I use it.. I dont even teach it at our courses).

- PipedOutputStream's constructor param is NOT an PipedInputStream instance (only the other way round) <hr>

I still LOVE the book and recommend it to my students. You should get Core Java Foundation Classes and Core Java in addition to this book, though.

If your are new to Java or just the whole OOP programming concept, this is the book for you.

Here is my story:

In the beginning of Sept. of 1999 I started read Bruce's Thinking in Java with only a structured programming background. I had previously done some programming in a language called CSP (a Cobal generator) on the mainframe and had some experience with VB and C. A friend and I made a commitment to get java certified by January of 2000 or around then because if we were going to learn java, might as well do it the right way. So, through five month of reading and doing almost every example in the book, I was java certified on January 14. The point I am trying to make is 1. use this book as a launch pad into the java and OOP world, 2. I would recommend learning Java with a friend because it is easier for you to stay focused on the true goal, and 3. do all of the examples in the book. This, obiously is not the only way to learn, however, it was a way that helped me.

Note: I was working full time.

So, I would recommend "Thinking in Java" for beginners and intermediates programmers

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.

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 covers the most important parts of the standard libraries to illustrate 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.

In my review of the first edition, I complained that the examples weren't always as realistic as I would have liked to have seen, and that the writing was occasionally not as clear as it might have been. I think that the writing has gotten clearer in most places, but the examples still sometimes leave me thinking "That's really fascinating, but when, why, and how would I use this in an actual development project?" Nevertheless, I have learned to love even the code examples for their authoritative demonstrations of object-oriented coding techniques that even most expert Java developers probably don't know, and probably should know.

As a programmer, I often get depressed when I see how much really atrocious code is being pumped out. After a ten-hour day of wading through swamps full of incomprehensible spaghetti, it is like a breath of fresh air to open Bruce Eckel's masterpiece and realize that there are others out there who care about the quality of the software being developed today.

Do yourself and the programming profession a favor and buy this book, or at least download it. You must then devote yourself diligently to following along with each chapter, typing the examples out and experimenting with them, and then doing the excercises at the end of each chapter. Even if you consider yourself an expert Java programmer I think you'll quickly discover, even in the early chapters of the book, that there is an awful lot that you didn't really understand about Java! It will probably take you more than one time through before you really have it down, and you should allow a good three months of evenings and weekends for each time through. There are no shortcuts to a deep understanding of OOP in Java, I'm afraid. The acid test is that if you can't do all the excercises with aplomb then you don't really know the material. It's a long journey, but it's worth the trip. Good luck!

--Erik

I found Thinking in Java to be an extremely readable book. I read the book pretty much cover to cover and by the time I'd finished I found myself quite comfortable with the concepts in Java. A couple of years of programming in it and I've never felt that I was disillusioned by that (as often turns out when you start actually using something that you think you know).

Learning the syntax of a language is the easy part -- the hard part is understanding why things are done in certain ways and how to best utilize the language features, and I felt this book did a great job of explaining that.

I'm amazed looking through the vastly differing opinions on this book -- so perhaps the best advice is to flip through the pages at a bookstore and see if you like the writing style or not. Or, perhaps look through the table of contents and see if the chapter titles are the types of things you're looking for. My guess is that perhaps this isn't a good book for people who have never programmed before. A few notes from the book's prerequisite section on this:

"This book assumes that you have some programming familiarity: you understand that a program is a collection of statements, the idea of a subroutine/function/macro, control statements such as 'if' and looping constructs such as 'while,' etc... As long as you've programmed to the point where you feel comfortable with the basic ideas of programming, you'll be able to work through this book. Of course, the book will be easier for the C programmers and more so for the C++ programmers, but don't count yourself out if you're not experienced with those languages (but come willing to work hard)."

(Wouldn't it be nice if amazon could list prerequisite sections for all of their technical books??)

If you're new to Java or Objected Oriented Programming buy the Teach Yourself in 21 Days book first. If you want a deeper understanding than any other Java book I've seen buy this one. Most Java books spend way too much time on Applets which is very little what Java is used for now. Java is a full application development language and this book is one of the few that actually gets past the Java Applet stuff. Companies such as Novell and Oracle are now writing their applications (not cute web applets) using Java. Very few books teach Java as a language but rather only teach how to make cute web applets. If you really want to learn Java you need this book. Plus he offers electronic versions in PDF, RTF, HTML, and Word formats. What more can you ask? I read this book cover to cover (much of it twice) and found it to be excellent. Again however you need a basic understanding of OOP first. (C++ and Java syntax are not enough, this book really goes into the OOP stuff pretty detailed and it would do you well to get the basics down first. This book is rather in depth and I thank the writer for a very well written book.)

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

This book is uncomparable when rating its writing style and dense detail that cannot be discovered in any other Java book. The only knock on this book is the damn freakn'font selection for all code examples.

The code examples font is faint, and dizzying to the eye. The coding style Eckel uses is not very textbook, in fact despite his good intention and respect that he has throughout the industry even from his comrades on the C++ Standards commitee, with the likes of C++ inventor Stroustrup, C++ masters Meyer, Coplien, and Koenig, Eckels implementation style would make them vomit with disgust. This is the only complaint on the book, the font style. This may seem minor, but believe me the font style of the book has to be warm and appealing to the eye. It helps to read faster and have a better visual flow from page to page without dreading to reach the code examples when you get there. I emailed Bruce Eckel when he began writing the 2nd Edition and complained about this matter, but apparently one complaint out of his thousands of followers, did not help.

With OOA and OOD, this book is simultaneously the best in mastering your thought process to instinctively think Abstractions, Objects, Family of Objects[ Inheritance ], and relational modeling among classes in a system, not to mention his superior explanation of Java I/O and his dense lectures, but interesting, with class access idioms.

If there are two books on Java that are a must have in your library, you keep it simple and you get:

1. The Java Programming Language 3rd Edition Author: James Gosling, Ken Arnold

2. Thinking in Java 2nd Edition Author: Bruce Eckel

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.