| Subcategories |
 |
Computers & Internet |
|
|
|
|
 |
 |
| |
|
|
|
|
|
Thinking in Java
written by Bruce Eckel
Studio : Prentice Hall PTR
by Prentice Hall PTR
Publisher : Prentice Hall PTR
Released : 1998-02-19
Availability : Usually ships in 1-2 business days
Number of Items : 1
EAN : 9780136597230
UPC : 076092003250
Avg. Customer Rating: (based on 300 reviews)
List Price : $39.95
Our Price : $4.07
|
|
| |
|
Product Description |
|
The legendary author Bruce Eckel brings Java to life with this extraordinarily insightful, opinionated and downright funny introduction. Thinking in Java introduces all of the language's fundamentals, one step at a time, using to-the-point code examples. More than virtually any other book, Thinking in Java helps you understand not just what to do -- but why. Eckel introduces all the basics of objects as Java uses them; then walks carefully through the fundamental concepts underlying all Java programming -- including program flow, initialization and cleanup, hiding implementations, reusing classes and polymorphism. Using extensive, to-the-point examples, he introduces error handling, exceptions, Java I/O, run-time type identification, and passing and returning objects. He covers the Java AWT, multithreading, network programming with Java -- even design patterns. The best way to understand the real value of this book is to hear what readers of the online version have been saying about it: "much better than any other Java book I've seen, by an order of magnitude..." "mature, consistent, intellectually honest, well-written and precise..." "a thoughtful, penetrating analytical tutorial which doesn't kowtow to the manufacturers..." "Thank you again for your awesome book. I was really floundering, but your book has brought me up to speed as quickly as I could read it!"For both beginner and experienced C and C++ programmers who want to learn Java. * From the basics of object development, all the way to design patterns and other advanced topics. * By the author of the best-selling Thinking in C++ -- winner of the 1995 Jolt Cola Award! * On-line version has already received tens of thousands of hits -- there's a huge built-in demand for this book! |
| |
|
Americancivilwar.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. |
| |
|
| |
|
Call me superficial, but.. |
.. 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. |
| |
|
Seems specifically designed to confuse beginners. |
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.
|
| |
|
Thinking in Java |
|
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. |
| |
|
Thinking in Java, 4th edition |
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! |
| |
|
Comprehesive Java Tutorial |
|
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. |
| |
|
|
|
