Rating: 
Summary: The book is an Express Reference.
Review: Great book, but not perfect. The subjects are arranged in a weird order and some parts of the API are left out entirely (on purpose). I used this book to replace my 1.1 reference and I haven't been disappointed, the main problem I have with the book is the order in which the information has been presented. The book is arranged by topic and then by alpha. I just need everything in alphabetical order. When I want to look up Robot, I'm want to flip to the R's and start looking. With this book, I have to remember what package the Robot class is in, flip to that section, then start looking. I'm sure no matter what order the author chose, someone would have a problem with it, but alphabetical would be my preference. Don't let the arrangement scare you away though, there's still an index and TOC. The reference is up to date (covers 1.3) and has enough sample code to get the point across when necessary. In other words, the book has most of the information you need. I also like the size of the book. It's thick but not wide. The other problem I have with the book is more a fear that has not been realized, than a real problem. This book doesn't cover the entire Java API. I've had books like this before, and they meet my needs 95% of the time. It's that 5% that scares me. I don't know how they choose which parts of the API to leave out, but they seem to have done a good job with this one, I haven't been left out in the cold yet. If you're looking for an timely reference on Java, this is the book for you. If you're looking for a one stop reference to every part of the Java API, this book is not for you.
Rating: 
Summary: I wouldn't rate this so highly...
Review: Here is the text of an email I sent to the feedback at Wrox which explains my position (will probably wrap wrongly but hopefully comprehensible nonetheless): I'd like to express my disappointment with this book. For a book which is meant to be used as a reference it has the following deficiencies: 1. Not only have classes been left out according to the author's priorities (which I will dispute later), but methods that use these classes are then omitted. e.g.. ClassLoader is omitted and then also getClassLoader() is omitted. If you are using the book as a reference for a given class, you can never be sure that there are not other methods that the author has not seen fit to mention. This is _really_ bad for a reference book. 2. In a reference, it would be much easier simply for the classes to be organised alphabetically within package. Instead, the author makes an effort to organise the classes topically, which is just confusing in a reference book. The same applies to the methods. Instead, it would be useful to have a brief topical index of classes at the start of each package and of methods at the start of each class. 3. The omissions are supposedly to save space. Instead, why not leave out the pointless examples. I can simply flick through the book to find pages and pages of examples that for a book supposedly aimed at experienced programmers are wasted space. Here's just one where the book has fallen open. The program on pages 424-425 could be eliminated and simply the example line of output shown. Further, where people need examples on a particular topic, e.g. java.net, they will normally have bought a book for this purpose anyway. 4. And while I am looking at these pages, why are pages 413-434 headed "6.2.1 Button Class" when they should be headed "6.1 Component Class"? "6.2.1 Button Class" doesn't start until page 436. This just seems typical of this book. 5. The layout I also find hard to use. Simply, my eye doesn't go to what I need which need. For instance, for each class I want to see: - Constructors - Class (static) variables - Class (static) methods - Instance Methods I did wonder if 2-colour printing would help but actually I don't think that's necessary. It's simply a bad layout and could be vastly improved with better design and typography. For example: The class names are in quite a weak font, whereas their subheadings - constructors, methods are in a strong, bold font. This should be the other way round. 6. Finally, contents. Inevitably this will be contentious but I have found (too late) that vast tracts of stuff that I use is not there. My preference would have been to: - eliminate all the examples to make space - complete coverage of java.* packages - move javax.* to a supplement. But what I feel most strongly on this topic is that packages should be included or omitted in their entirety, as noted in my first comment.
Rating: 
Summary: Very Handy Book
Review: I really like this book and find it very useful. This book doesn't claim to be a tutorial, but it's actually a pretty good one. I'm still learning Java, and this book has helped me to learn things that weren't covered in my courses. Unlike many Java books out there, the writing style is very clear. The examples (and there are lots of them) are short enough so you don't get lost when going through them, and yet they are all standalone code so you can run them yourselves. It's a good way to get a feel for what the classes and methods do. The chapter on Java Beans is very good. I thought a Bean was some mysterious thing, but this book explains them very clearly.
Rating:
Summary: Very Handy Book
Review: I really like this book and find it very useful. This book doesn't claim to be a tutorial, but it's actually a pretty good one. I'm still learning Java, and this book has helped me to learn things that weren't covered in my courses. Unlike many Java books out there, the writing style is very clear. The examples (and there are lots of them) are short enough so you don't get lost when going through them, and yet they are all standalone code so you can run them yourselves. It's a good way to get a feel for what the classes and methods do. The chapter on Java Beans is very good. I thought a Bean was some mysterious thing, but this book explains them very clearly.
Rating:
Summary: Rock Solid and Concentrated
Review: I selected this book out of interest, and out of a need for a recent (JDK v1.3) reference for the classes, interfaces, and contents of the JDK and its libraries. I like the feel of a book in hand while I'm working, and I typically have three to six books open around me as I go. Wrox Press (www.wrox.com) advertises their works as "Programmer to Programmer ™" and they are spot on! This book is incredibly focused, and presumes you've got a solid working knowledge of Java as a professional developer, but need a reminder on some of the classes, packages and examples of how to use or call the methods. If you need a reference book on Java's huge packages, you need this book. I've read several other works covering much of the Java packages. Although this book is physically larger (best clear a good 3 inches of shelf space) it is much "denser". My overall reaction: focused, a good read, and very clear in presentation. Chapter 1, the Java Fundamentals, is just 70 pages long. In this section, I found extremely clear, tight, and readable code and descriptions. I found single paragraph descriptions that took pages in other works. From there, you drop straight into java.lang, and work through the most popular packages including javax.swing, border, table and tree, and wrap up with the java.beans package. Every page is packed with examples, code snippets, and very terse descriptions of how the class, method, or interface works. My key for any good reference book is the index. I want the information, easily located, and NOW. Wrox and Grant have done well here. Indexes include by class name, interface (and classes implementing the interface), and a general index, which picks up the method names. Method entries in the index include page references to the individual classes implementing the method. The author claims (accurately) that this book is "essential rather than exhaustive". It's squarely aimed at the heads-down, professional developer, who stays "in the flow" for most of the day. Grant introduces each class briefly, provides an inheritance hierarchy, gives an overview of the methods, and drops into a functional example of using the material. No "terminally cute" examples, just easily read code that demonstrates "how to" in as clear a manner as possible. The chapters on AWT and Swing classes provide minimalist screenshots showing the results of the examples; only one item is demonstrated at a time, removing any guesswork. Got a question? In one or two pages, you'll have an answer. I would recommend this book as a supplement to other, introductory books for a beginner to the language, or to someone taking classes in Java. I strongly recommend begging, borrowing, or (best of all) buying your own copy as you ramp up for the Certification exams. The first chapter will supplement the other study guides very nicely, and the book remains useful far longer than the certification guides. I've got a bookshelf reserved for what I use on a daily basis; Java Programmer's Reference goes on it and will stay there. I expect this book to remain useful for years. Rating: 4 out of possible 5. (Scale: 1: read in an airport, when there's nothing better to do. 3: solid, useful, buy whichever one fits your thought process. 5: drop everything, go buy this book now, read it tonight, carry it with you.)
Rating: 
Summary: What's missing?
Review: I was very disappointed with this book. For someone quite experienced with Java it might serve as a good tool for jogging the memory. When you are in the process of discovery it is a very difficult book to use. The index and the table of contents center around classes, not topics. If you don't already know the classes count on wading endlessly back and forth through this book. For the programming I was doing the reference was very incomplete, even regarding the basics. I found references on the Internet to be much more helpful than this book.
Rating:
Summary: What's missing?
Review: This book by Grant Palmer is by far very VERY useful...i repeat...VERY useful if you can't figure out how to work with a specific class. The short examples give a good idea on how to implement something. It makes understanding things much easier since he has code and what the program will execute and what the output will be. He goes through the very basics, such as access modifiers and variable sizes, etc. He moves from the standard packages and moves gradually to file IO, then towards the AWT/Swing packages. The author isn't able to demonstrate ALL of the classes but by far, he covers close to 100% of what are mostly used in real-world applications. It is by far, one of the best reference manuals that I know of. Keep in mind his title: Programmer's REFERENCE. The way I see it, he fulfilled the book's purpose and definitley deserves those 5 stars.
Rating:
Summary: Great book to begin and intermediate programmer
Review: This book sits on my desk and I use it all the time. I looked at "Java in a Nutshell" but now you have to buy three books. This book covers JDK 1.3, the javax.swing package, and has hundreds of short examples. The java.io package examples are especially good. The book also has a very good chapter on Java Beans. The index is outstanding. It is 60 pages long and is divided into two parts, a general index and one for classes. Because its only one book, it doesn't cover everything in the J2SE JDK 1.3, but as a reference book that covers the core Java it's great
Rating:
Summary: A Valuable Resource
Review: This book sits on my desk and I use it all the time. I looked at "Java in a Nutshell" but now you have to buy three books. This book covers JDK 1.3, the javax.swing package, and has hundreds of short examples. The java.io package examples are especially good. The book also has a very good chapter on Java Beans. The index is outstanding. It is 60 pages long and is divided into two parts, a general index and one for classes. Because its only one book, it doesn't cover everything in the J2SE JDK 1.3, but as a reference book that covers the core Java it's great
Rating:
Summary: Great Java Reference
Review: This is the best Java reference book on the market today. It's not perfect, but it's closer than any other Java reference out there. I like the way the information is presented in a structured manner. Classes and methods of a certain type are grouped and explained together. The book is very readable and gives a lot of helpful hints to avoid gotchas that aren't usually explained by reference books. The examples are great and there are lots of them. A lot of times when I'm stuck I won't even have to read the text. I can just look at the appropriate example and it tells me what I need to know. This book is not for neophyte Java programmer's. It doesn't spend a lot of time on object oriented theory or other real basic stuff, but for intermediate or advanced programmer's it's great.
|
