Customer Reviews

Java in a Nutshell : A Desktop Quick Reference (Java Series) (3rd Edition)

5 star:		(49)
4 star:		(29)
3 star:		(10)
2 star:		(6)
1 star:		(7)

 

 

This book is my new favorite Java book. This book is probably my new favorite technical book. It's simply an excellent example of what a technical reference book should be.

The first quarter of the book is a very good introduction to Java, the syntax, as well as object oriented programming (OOP). The syntax and OOP portions of the book are the best I've seen in any book. If you are new to Java, reading through these sections carefully will teach you almost everything you'll need to know about the Java language. The third edition of the book doesn't assume a C/C++ background, so even those with limited or no programming experience will find this section very helpful.

Next you'll find excellent coverage of the Java platform. The bulk of the book is a reference of the different Java classes in JDK 1.0, 1.1, 1.2, and even 1.3Beta. The coverage is excellent. I would have liked to see examples, but I suppose that really is asking too much from one book.

I have a large library of Java books, but this one is #1 for me. Shelf time for this book is going to be very low. The book literally hasn't seen a shelf since it arrived from Amazon.

There are several Java books I find to be far superior to others. For anyone new to the Java language, I believe the following are the very best books to have nearby (ranked in order): Java in a Nutshell, 3rd... Java Examples in a Nutshell... Java Foundation Classes in a Nutshell... Java Enterprise in a Nutshell... The Java Class Libraries, 2nd, Vol 1. by Patrick Chan

Obviously, I'm a fan of David Flanagan's Java books (he wrote the top four). Pick one up to see why. They are all excellent, but my favorite is this one (JavaNut 3rd edition). The set of four Flanagan books easily comprise the best resource on Java available.

There have been three editions of this book, all of them excellent reference books but too condensed to be great tutorials.

The first edition had everything you needed to know about Java 1.0, including AWT (the GUI) descriptions and example programs; but a lot has changed since Java 1.0, which is basically only good for writing applets. Still, many browsers can only handle Java 1.0.

The second edition covered Java 1.1 and the AWT, but the examples were split off into a second book, "Java Examples in a Nutshell." IMHO the second edition is the best single-source reference book.

Much has been added in Java 1.2/1.3, but the Java 1.1 basics have not changed. This third edition further splits off the GUI information (including the new Swing classes) into "Java Foundation Classes in a Nutshell," and as such cannot stand on its own for GUI programming. Enterprise programming is also split off. For what it covers, each edition keeps getting better, but also narrows its coverage.

While the book is an excellent reference, a paper reference is no longer the best programming support. Once you have learned Java basics, the best way to program is with Sun's online documentation open on your desktop--IF you have a fast internet connection or can download the whole thing to your hard drive. You get faster lookup and detailed descriptions of every method, rather than just lists of methods.

Bottom line: a great book, but consider carefully whether its coverage meets your needs.

Imagine going to the awesome javasoft website and compressing it into 500-odd pages. This is Java in a Nutshell.

As a programmer who needs classes and methods at my fingertips, I don't want to be forever logged into the Sun site to get hold of code. For me using VJava, DB2, Lotus Notes etc, to keep Netscape open permanently slows me down. I want to see code in concise paper form for perusing and for adding post-it notes to useful pages.

This book is a good physical size, about the size of a good novel, and thus is refreshingly concise. You genuinely can put it on your desk without it becoming a 'conversation piece'. It doesn't come with code cheats. For that I use and recommend 'The Complete Reference' which is the size of a squashed brick.

Four stars because IMHO, this reference could do without a 'What is Java' introduction (even though it's a small part of the book) - it's better done in any textbook.

This book, like the other Nutshell books is consise and to the point. However I would very strongly suggest that if you are a non Object Orientated Programmer that you bring yourself up to speed on those concepts first. If you do already know OO then this is a good book for you as it takes you into the basics of Java and how use it in a clear and helpfull way. You will need to buy another book to bring you up to speed on Java 1.2, which is what I have done.

In this 3rd edition of his book, Mr. Flanagan has developed a solid, accessible, useful resource for server-side Java developers of all experience levels.

Part 1 of the book has been completely revised so that all references to C and C++ have been summarized into two pages at the end of Chapter 2 and Chapter 3. This makes Chapter 2 ("Java Syntax from the Ground Up") and Chapter 3 ("Object-Oriented Programming in Java") much more accessible to PL/SQL developers who may have an understanding of procedural logic, but no real experience programming in an object-oriented language like C++.

Chapter 4 ("The Java Platform") gives a concise overview of the Java platform. These thirty pages do not answer all questions concerning the Java architecture, but they do introduce many topics that new Java developers will quickly find they'll want to learn more about.

Chapter 5 ("Java Security") is both a good introduction and a useable reference for basic Java security.

Chapter 6 ("JavaBeans") gives a very brief overview of, well, JavaBeans. It is more of an explanation of what they are rather than a real resource for developing "beans". At only ten pages, this chapter is less than half the number of pages dedicated to this chapter in the 2nd edition of this book. This is keeping with the book's focus on server-side Java ( the author suggests that client-side programmers also check out "Java Foundation Classes in a Nutshell").

Chapter 7 is a brief but important chapter as it shows how easily Java code can be formatted and documented. Anyone working on a large development project will quickly become a fan of "javadoc" if the simple doc-comment tags are used properly.

Chapter 8 ("Java Development Tools") covers the variety of command line tools that Sun ships with Java. This chapter could almost be included in Part II of the book as it is a very handy reference chapter.

If Part I of the book is the bare bones of Java, Part II ("API Quick Reference") is the meat. In these 21 chapters, Mr. Flanagan presents what he calls the "essential APIs of the Java platform").

Gone from the 3rd edition are GUI references to AWT and applets. Most of the pages that make up this section of the book could have been cut and pasted from the Java documentation, but his brief comments and explanations are very useful for both deciding which packages and objects to use in developing server-side code as well as understanding the coding decisons made by other programmers on a large development team.

"Java in a Nutshell" is just that. It is not a complete Java reference by itself and is not intended to replace a shelf of other Java books. It is more of an entry point: great for new Java programmers; very handy and manageable for experienced Java programmers.

The changes in the 3rd edition are substantial enough to warrant an upgrade from earlier editions of the book.

If you are looking to learn Java (code), this book will provide a reference but won't teach you much. If you are looking for Java (OO) concepts, this book will leave you looking for more as well. Everything in this book can be found by browsing the Sun website, primarily in the JavaDoc or in the Developer's Connection. If you want to be a Java guru, this book could compliment others, but won't stand on its own by any means.

JAVA IN A NUTSHELL (THIRD EDITION) is one of those computer science books that I had always been told was excellent. Professors, friends and co-workers all recommended it to me so many times that I eventually bought it soon after I began programming in Java. Having used this book as a reference on numerous occasions, I must say that it doesn't quite live up to its hallowed reputation, although it does have a number of positive points in its favour.

The opening few chapters of the book are really good at setting the stage for the beginning Java programmer. While it probably isn't simple enough for someone who is a complete newcomer to the language, it is excellent for people who already know a little bit and require more information. The sections on Java syntax are quite thorough and understandable. The Object Oriented Programming portions are readable and informative, without bogging the reader down with endless detail. The background information on Java (the structure, the way methods/variables work, the flow of programs, etc) is all handled brilliantly. Part One of this book is definitely something you'll want to treasure.

Part Two, the bulk of the book (Chapters 9 though 29, and covering a staggering three hundred, seventy-six out of six hundred, forty-eight pages), is devoted to what is referred to as the "API Quick Reference". It's the self-proclaimed "real heart" of the text. Unfortunately, this is the portion where the book really falls flat. What David Flanagan has done is to go through the most common Java packages/classes/APIs and cut them down to a bare listing of all their methods, exceptions, hierarchies, etc. While this covers a broad amount of information, it does not cover it deeply at all. I agree with his choice of most-used APIs, but he doesn't go in to nearly enough detail about them. Almost all of the methods are given no description; they're just named. If you are using this to look up the precise spelling/capitalization of your favourite methods, then this will do nicely. However, if you're curious as to what each method actually does, you won't find any enlightenment here. When one boils down the Java documentation this far, one finds that there really isn't much left at all. Certainly nothing that's actually useful.

The first part of this book is first rate. It's easy to understand, well-organized and great for beginners learning the language as well as for experienced programmers who require reference material. The second part of the book is not so good. For any detailed information you require, you'll find yourself forced to consult other sources (probably Sun's own API specifications which are available for free on their webpage). Make sure you know what you're buying. The first half of this nutshell is excellent, but you'll need something else to go with it to have a completely worthwhile reference.

I approached this book from the perspective of an experienced software developer who is already expert in several programming languages, including C++, and familiar with object oriented design and development concepts. I wanted a book that would provide me with a quick start with the Java programming language and the class libraries. I wasn't disappointed.

The most serious omission is a discussion of the AWT (abstract window toolkit) and/or Swing libraries which provide capability for programming a user interface.

This book provides a good companion to Sun's on-line documentation. Judging by some of the other reviews, it's probably not appropriate for a complete novice, who perhaps would be better off with Learn Java in 21 days, Java for Complete Idiots, or some other such title.

This is a very good reference book. There's no doubt about that but the concept of "Java in a Nutshell" is certainly becoming strained as the language grows. Now we have "Java in three Nutshells" since the gui and Enterprise sides of the language have been floated off, plus of course the Examples book. (Buying the complete set is becoming an expensive business.)

That being said, this new issue of the book can still be recommended. Generally, it contains a more information than using Sun's own API documentation. Unfortunately, I've yet to find an example of it being more comprehensive than the "core Java" and "graphic Java" books.

Who then would I recommend this books to? Well, probably not a beginner in programming but certainly to a competent programmer who is new to Java. It's probably at it's most useful, though, for intermediate level programmers, since it contains a wealth of background information and advice on how to improve java code from being 'run-of-the-mill' to being 'state-of-the-art'.

Overall, this Nutshell book is probably the best guide to the language to come from outside the Sun camp.

This book will NOT teach you Java. This book is intended for experienced individuals who need to quickly locate information concerning syntax issues or the names of methods in classes. With the exception of the chapters toward the beginning of the book there are no examples. This book assumes you know how to use the classes covered, as such, it is intended for those who have simply not explored all of the class's methods or haven't memorized the available methods and their parameters. Too the first 3rd of the book provides a very concise overview of the language in case you've forgotten some details. Additionally, you get a chapter that details the java tools included with the JDK. Overall it think it is a wonderful book! It gives you a small, usually one paragraph, summary of each class followed by a list of the methods in the class including their access modifiers and any exceptions they may throw. Reaching for this book is a lot easier than going to my computer and bringing up Sun's API documentation. I've used this book so many times that pages are going to start falling out at any time. ********Note that this isn't a replacement for Sun's API documentation as this book only covers some of the packages, not all of them. Be sure to examine the table of contents to decide whether this book is right for you.