Thinking in Java (Paperback)

~ (Author)

Editorial Reviews

Amazon.com Review

Thinking in Java is a printed version of Bruce Eckel's online materials that provides a useful perspective on mastering Java for those with previous programming experience. The author's take on the essence of Java as a new programming language and the thorough introduction to Java's features make this a worthwhile tutorial.

Thinking in Java begins a little esoterically, with the author's reflections on why Java is new and better. (This book's choice of font for chapter headings is remarkably hard on the eyes.) The author outlines his thoughts on why Java will make you a better programmer, without all the complexity. The book is better when he presents actual language features. There's a tutorial to basic Java types, keywords, and operators. The guide includes extensive source code that is sometimes daunting (as with the author's sample code for all the Java operators in one listing.) As such, this text will be most useful for the experienced developer.

The text then moves on to class design issues, when to use inheritance and composition, and related topics of information hiding and polymorphism. (The treatment of inner classes and scoping will likely seem a bit overdone for most readers.) The chapter on Java collection classes for both Java Developer's Kit (JDK) 1.1 and the new classes, such as sets, lists, and maps, are much better. There's material in this chapter that you are unlikely to find anywhere else.

Chapters on exception handling and programming with type information are also worthwhile, as are the chapters on the new Swing interface classes and network programming. Although it adopts somewhat of a mixed-bag approach, Thinking in Java contains some excellent material for the object-oriented developer who wants to see what all the fuss is about with Java.

Review

"This book is a tremendous achievement. You owe it to yourself to have a copy on your shelf. The chapter on iostreams is the most comprehensive and understandable treatment of that subject Ive seen to date." - Al Stevens Contributing Editor, Doctor Dobbs Journal" Eckels book is the only one to so clearly explain how to rethink program construction for object orientation. That the book is also an excellent tutorial on the ins and outs of C++ is an added bonus." - Andrew Binstock Editor, Unix Review"Bruce continues to amaze me with his insight into C++, and Thinking in C++ is his best collection of ideas yet. If you want clear answers to difficult questions about C++, buy this outstanding book." - Gary Entsminger Author, The Tao of Objects"Thinking in C++ patiently and methodically explores the issues of when and how to use inlines, references, operator overloading, inheritance, and dynamic objects, as well as advanced topics such as the proper use of templates, exceptions and multiple inheritance. The entire effort is woven in a fabric that includes Eckels own philosophy of object and program design. A must for every C++ developers bookshelf, Thinking in C++ is the one C++ you must have if youre doing serious development with C++." - Richard Hale Shaw Contributing Editor, PC Magazine --This text refers to an alternate Paperback edition.

See all Editorial Reviews

Product Details

• Paperback: 1098 pages
• Publisher: Prentice Hall PTR (February 19, 1998)
• Language: English
• ISBN-10: 0136597238
• ISBN-13: 978-0136597230
• Product Dimensions: 9.2 x 6.8 x 1.7 inches
• Shipping Weight: 3.4 pounds
• Average Customer Review: 4.2 out of 5 stars  See all reviews (300 customer reviews)
• Amazon.com Sales Rank: #550,903 in Books (See Bestsellers in Books)

Customer Reviews

Most Helpful Customer Reviews

139 of 147 people found the following review helpful:

4.0 out of 5 stars *Excellent content *Dour presentation *hard for novice, January 14, 2004

By	Patrick Thompson (Sydney, NSW Australia) - See all my reviews (REAL NAME)

This review is from: Thinking in Java (3rd Edition) (One-Off) (Paperback)

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

107 of 112 people found the following review helpful:

5.0 out of 5 stars Great book as far as basic language goes; poor Swing, March 20, 1999

By A Customer

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.

152 of 165 people found the following review helpful:

5.0 out of 5 stars Thinking in Java, June 8, 2000

By	NetMediaServer "tnuzzi" (Austin, TX) - See all my reviews

This review is from: Thinking in Java (2nd Edition) (Paperback)

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