Rating:  Summary: Excellent resource for students Review: This is one java book that beginner to intermediate java programmers can look at. Easy to read, with loads of excellent examples. Also, very up to date, with great coverage of new features like Swing.Used by all staff and postgraduate students at the University of Natal (Durban, South Africa)
Rating:  Summary: It is a good book among the lot. Review: It is a very Good Book and much better than Core Java, which many people say is good but i think Thinking in Java is better than Core Java.
Rating:  Summary: The ultimate Java book for the intermediate to advanced Review: The binding on my copy has finally given way and I can't bring myself to replace it! It is hard to "love" a technical book, but this is one that you will grow to love. Why? Well Eckel seems to have a truly special writing style. You can say I'm a loyal pupal of his -- he thought me C++ as well (Thinking in C++ 2nd. Edition). He starts with the basics (objects), then goes into the syntax, fills in the gory details (API), and finally he closes it off with some important principles used in good Java design. In between he provides so much *clear* detail that this book will also grow with you. All I have to say is don't even think about another Java book!
Rating:  Summary: Very good book to learn the Java language. Review: This is a very good book to learn the Java language. If you are a beginner, however, you may get a little lost as there isn't a single graphical illustrations.
Rating:  Summary: Some chapters are GREAT; book is more of a Java 1.1 one Review: This is a preview of my forthcoming review. IGNORE MY PREVIOUS POSTING BELOW, IT'S USELESS WITHOUT THE TABLE! I've written a comparative review of the following books: Ralph Steyer: Java 1.2 Kompendium (Markt und Technik; ISBN: 3827253179) (German!) Cay S. Horstmann, Gary Cornell : Core Java 2, Volume 1: Fundamentals, 4/e (Prentice Hall; ISBN: 0130819336) Peter van der Linden: Just Java 1.2 (4th ed, Core series, Sunpress/ Prentice Hall; ISBN: 0130105341) Bruce Eckel: Thinking in Java (Prentice Hall Computer Books; ISBN: 0136597238; with the new chapter on Collections). Aaron Walsh: Java 1.2 Bible (IDG Books Worldwide; ISBN: 0764580302). Look up the review of the five books from Amazon - I had to remove all the columns of the other 5 books from the table below b/c Amazon's HTML parser doesn't understand table tags. In order to get a clear, (hopefully) objective view of all the books, I've also read Jamie Jaworski's Java 1.2 Unleashed (Sams.Net, 1998; ISBN: 1575213893) book before the test, but, as the book is only intended for experienced programmers interested in additional and enterprise APIs and not for beginners, I dropped it from the test entirely. It would have been unfair to test such an expert-only book in a review of beginners' books. Bruce Eckel: Thinking in Java The only one book in the test that can be downloaded straight from the Net. This also has a positive impact of this book's great success. And this book is exceptionally good for being free! The book has a lot of references and notes about both C++ and the earlier Java versions. The latter is painfully missing from the latest Core Java. Eckel's OOP explanation is not as comprehensive as that of Linden. You aren't guaranteed to understand OOP only from this book, unfortunately. As a second book, though, Eckel's book is great as it adds a lot of additional information on OOP. His was the only book to explain how and why the implicit/explicit super() method invocations take place; same stands for the explanation of why signatures don't contain the return value (overloading). As far as basic language constructs are concerned, Eckel wrote a far more comprehensive chapter (see the remarks below the table - I especially loved the easy-to-understand examples of how labeled break/continue work.). Chapter 4 is where the real work starts (OOP, distinguishing overloaded methods, this, static, constructors, static initialization, arrays). Introducing constructors is one of the best explanations I've ever read - unfortunately, not many OOP primer books emphasize constructors' being 'only' methods to initialize an object's variables. A perfect introduction should also emphasize why constructors were chosen to be tied tightly with the class they belong to (not to forget to call the method that previously were in charge of initializing the instance variables). Most other books reviewed lack this kind of an introduction, they start off by telling the reader 'constructors are for initialization' and don't even try to emphasize they're just a convenience invention. The section on arrays was pretty short and lacked the explanation of multidimensional arrays' memory map. It was the only book to mention that not only the last one, but the last n indices of multidimensional arrays can be left empty when creating an array. Chapter 7 is almost entirely devoted to polymorphism and inner classes. The discussion of inner classes rocks, it's by far the most comprehensive introduction I've ever read. It's only Just Java's explanation that is as comprehensive as this one because it systematically groups the different types of inner classes and explains them separately. The other books also try to group the different kinds of inner classes, but mostly without any success. Authors of future Java books should learn a lot from both early C++ books and Linden's being utterly systematic. The section on OOP, as I've already said, lacked the comprehensibility of Just Java. If the author (as Linden himself or the authors of most C++ intro books) had chosen to show how an OOP structure could be implemented in a non-OOP language, the reader would understand the basics of OOP much easier. This is a lethal flaw in all books reviewed, except for Just Java. Chapter 8 discusses Java's collection classes. It introduces the old classes, but, fortunately, the new Collection classes aren't forgotten - they're discussed at the end of the chapter. Eckel's explanation of the Collection classes are extremely easy-to-understand; a magnitude better than Linden's. The other books under review don't discuss these, new classes. Chapter 10 is devoted to streams. This chapters is pretty well written (there is a small mistake in discussing StringTokenizer: nextToken() returns a NoSuchElementException when there are no more tokens, and not an empty String), I especially loved the part on serialization. The author's example on showing whether a serialized objects can be restored without actually having the corresponding .class is really unique - I love the author's experimenting and actually making the readers experiment and not just check out the API docs or the (sometimes faulty, especially in this case - most books don't even discuss object serialization) literature. Versioning, on the other hand, isn't discussed, only mentioned. Chapter 11 is entirely devoted to RTTI. A great chapter, a must read for advanced Java programmers. Beginners won't profit much from this subject, anyway, so the weighting of this subject is made 2 (quite small) in the table below. The author makes useful remarks about C++, especially when it comes to discussing instanceof and downcasting. He should have shown the reader why it is dangerous to access a superclass object as a subclass object, though, in order to make the readers understand why explicit cast and Java's additional checking is needed to avoid cases when there can be memory corruption if the additional methods defined in the subclass overwrite the memory area after the object. Most quality C++ books also show examples of this - in my practice (teaching Java at Sun Microsystems Hungary's Java courses and Technical Univ. of Budapest) I found it essential to show such memory maps of the objects in order to make the students understand the need for the explicit cast (and, on the other hand, why implicit type conversion is enough in the opposite direction). Nevertheless, this chapter is by far better than Core Java's sections of the same subject. Chapter 12 discusses passing and returning objects - a very important subject for a C++ programmer. The subject isn't as important for a Java-programmer, as we don't have to write our copy constructor when passing objects to a method, so this chapter is more of a 'let's rewrite our C++ book to cover Java'. Nevertheless, interesting and important subjects are discussed - equals(), clone() etc. It's Chapter 13 that starts discussing AWT. Unfortunately, the discussion here is flawed - all AWT components are introduced by using the old event model. The author later rewrites all the examples to use the new event model too - but it'd be far better not to use the old event model at all. What is more, there is not a single screen shot in the entire book. The section of layout managers is pretty badly written -no BorderLayout constants are mentioned; there're sentences like 'The BorderLayout is the default manager for applications and dialog' etc. GridBagLayout isn't discussed at all (I don't consider this a lethal flaw - I don't teach it either and find it easily replaceable by using subpanels with Border/FlowLayout). The recommended coding approaches, on the other hand, are worth reading - the discussion of creating lightweight components (still existing in Core Java 3rd ed Vol1 but NOT in the most recent edition) and using the AWT event queue is great. Basic clipboard operations (Core Java 3rd ed Vol2 discussed the subject much more thoroughly) and JavaBeans are also discussed here. Basics of Swing are introduced - this section is one of the worst in the book. There is no MVC and the author doesn't even describe panes in a JFrame. This chapter is one of the chapters in the book that need complete rewrite. Chapter 14 discusses multithreading. It also describes why suspend/resume/stop are deprecated - it's also the only book to discuss this subject. Compared to SL-276, the first explanation of the deprecated stop() methods is a bit problematic, albeit the later use (and explanation) of a stop flag is OK. Explanation (and emulation) of suspend/resume isn't misleading either. Chapter 15: java.net. Both TCP sockets and UDP datagrams are thoroughly presented (with presenting the usual multithreaded server application too). JDBC is also quite thoroughly (8 pages) discussed in the chapter, which closes with RMI (also a thorough description - it should have presented a working, large example, though, just like Core Java vol2). Later chapters discuss design patterns at a high level (unique with a Java book! The other general Java book that discusses this subject I've read is Wiley's Programming Mobile Objects with Java
Rating:  Summary: THE BEST book out of 12 Java books i have purchased so far. Review: i have bought many books in search of understanding inheritance and polymorphism. this book so clearly explains these concepts which are not adequately explained in other books. this is one book that you don't want to miss.
Rating:  Summary: An excellent introduction and a good reference for Java Review: While I attempted to learn Java from other books, only after I read this, could I say I really understood the language. I still refer to this frequently when I need to clarify concepts not adequately explained elsewhere. All important concepts are clearly explained with more depth than I've seen elsewhere. It has some of the best coding examples I've seen, that can be used for the beginnings of working Java programs. I wouldn't design/code in Java without it.
Rating:  Summary: Great book as far as basic language goes; poor Swing Review: 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.
Rating:  Summary: The best book on Java Review: I found Bruce Eckel's book to be the best I have ever read on a Programming Language, his clear and readable text is well augmented by examples, this book is first technical manual I have been unable to put down. I have only just ordered it, having read it in the free downloadable pdf format and it is worth buying just to reward his courage - which is well founded.
Rating:  Summary: A very nice book for me as a student Review: When will there be an upgrade of the book "Thinking in Java" to JAVA 1.2? Thanks.
|