Customer Reviews

Pure JFC Swing

5 star:		(12)
4 star:		(4)
3 star:		(1)
2 star:		(7)
1 star:		(6)

 

 

I have 10 years C++ and OOD, but am new to Java. In the last 3 weeks, I have gotten the language down pretty well, but am still climbing the learning curve on Swing. I found the index confusing at first, but now I realize that it is quite powerful. It took me about 5 minutes of dedicated effort to figure the index and appendices out, but now I find it very useful (the confusion derives from the index's redundancy, but once you figure this out the redundancy can be used to advantage). Appendix A (JFC Swing Quick Reference) is really poorly laid out. It is 261 pages with nothing but "Appendix A" listed at the top of each page. I believe it is laid out by package. As such, the least they could do is put the package name at the top of each page or dictionary-style black markings along the edges of pages as in several O'Reilly texts. I recommend not starting with Appendix A; look to the index and let it tell you what page to jump to in Appendix A. I have 8 Java books that I purchased in the last 3 weeks; this one does something very helpful. The text descriptions of code samples are described with reference to specific code blocks, i.e., "snippet 1 does...", "snippet 2 does...". This is VERY helpful because if you scan a code sample, you are likely familiar with 90% of the code sample. With this text's format you can rapidly skip past the text descriptions for the code you already understand. I have found this EXTREMELY helpful (I waste a lot of time in a lot of books reading the same information over and over again). This is the first book outside of the O'Reilly series that I have found useful in my effort to learn Java. In sum, the value of this book (for me) derives from its presentation of the big picture on Swing. I don't need a book that goes into endless detail about specific methods and classes (I can get this from numerous reference sources...and I can learn this over time while developing). The value of this book comes from its ability to give you the big picture and train you on Swing-based design patterns and methodologies. I already know A LOT about GUI development, OOD, using foundation classes, etc...what I needed to learn was the "Swing way" of doing things. So, if you share my background, this book will be very useful.

This is a good book if you are looking for short, clear examples of how to use the major JFC classes in Java2/Swing. It doesn't go into detail for every minute aspect of JFC, but on the other hand, that makes all the important data on JFC that much easier to find...less arcane fluff to wade through!

If you are an experienced Java programmer and you want to quickly get up to speed with JFC, then this book is for you. If you are looking for a hand-holding tutorial for learning the Java language, look elsewhere. This book is for those with some Java language experience under their belt. (Put another way, if this book were a ski run, it would have a blue square sign. :-)

I recommend this book mostly for its 350-page JFC quick-start overview with examples. The low price makes it a good value too. The last half (API overview) is not quite as useful as the first half, but overall, I give it 4/5 stars.

While this book has a very good price, it is very lean on actual knowledge. The first part of the book goes through the Swing components and does a decent job reviewing the main features of each. This reading is extremely dry but focused.

It does include a discussion of the Swing delegate-UI model and some thoughts on MVC. A pleasant suprise, considering the javadoc nature of the book's reading.

The second half (400 pages!) of the book is just plain worthless. The javadoc generated information that comes with the Swing APIs is more useful.

Although "Pure JFC Swing" is 800 pages, more than half the book is a reference to the Swing API. As a reference it is mostly useless. The pages are not labeled and the classes are listed by package so it is almost impossible to find a class without using the index. Each class contains only the signature of each method with no explanation as to how the method might be used which limits its usefulness. The Sun online API is a much better reference. The first half of the book is an introduction to Swing and this is what makes the book worth its very reasonable price. The book starts off with a nice introduction to Swing and the MVC architecture. The author then discusses some of the basic Swing classes. This section of the book features a good discussion of panes but like most of this section it leaves you wanting more. The author has an excellent writing style and gives good, clear examples for each of the classes but each topic ends too soon. Also, too many topics are not included in this book. This book could have been an excellent book. If the publisher had abandoned the idea of supplying a reference and had let Dr. Pantham have the entire 800 pages, this would have been a much better book. If you plan on doing a little work with Swing and you're looking for a light introduction, this book may serve that purpose.

This would be a difficult book for beginners, but does supply a lot of advanced information about using the Swing package. The general stuff at the beginning would be better served if replaced by a reference to the online tutorial at java.sun.com site. I recomend this text to anyone who needs or wants to use Swing.

This book has good code samples and covers a lot of Swing. Unfortunately instead of really covering all the detail of a very complex framework, the book stops halfway both figuratively and literally. Of the 806 pages, only 356 are really any use. The last half of the book is composed of poorly presented synopses of the packages. These 450 pages (except for a workable index) are a waste and should have been used to convey the detail missing in the first half. They contain no navigational aids; instead class and interface descriptions appear seemingly randomly according to obscure (to me)organizational principles.

The book also lacks a stylistic or pattern-based overview; instead we are left to infer these from the code samples.

This book has good code samples and covers a lot of Swing. Unfortunately instead of really covering all the detail of a very complex framework, the book stops halfway both figuratively and literally. Of the 806 pages, only 356 are really any use. The last half of the book is composed of poorly presented synopses of the packages. These 450 pages (except for a workable index) are a waste and should have been used to convey the detail missing in the first half. They contain no navigational aids; instead class and interface descriptions appear seemingly randomly according to obscure (to me) organizational principles.

The book also lacks any guidance on style and patterns to use in constructing a Swing application; instead we are left to infer this from the code samples. This is a major oversight in my view because the packages have been designed with specific patterns in mind. It would have been a great service to include some material on that.

I do not think the author put the same effort into this book as he did for Pure Java.

The first part of the book, up to page 350, provides some good background on Swing plus some usable examples. The last half (pages 350 - 800) is close to useless. The reference provides no descriptions, not even one sentence, about each member. Classes are hard to find since the page header does not give you any indication of where you are. The index is one of the worst I have seen. This was the only book on Swing in my local bookstore when I needed one fast.

There is a 180 page index cross-listing 300 pages of method listings which are less informative than the API docs. The examples don't compare to David Geary's book. I thought this would be a unique reference but it isn't very useful. Don't believe the hype.

I've read several books on Swing, in my quest to master its intricacies. Books like 'Java Swing' by O'Reilly are good as references, but contain limited examples (and their tree section is terrible). That's why you need a book like 'Pure JFC Swing' - to give you examples and code snippets for real world applications. You can learn a lot by looking at example code - or just take it an put it in your own applications for impressive results.

My one complaint, and it is small, is that there is no CD. This means you have to download the code from the publisher's site (it is there - be persistent). Despite this, once you have the code, you can try all the examples form the book or cut and paste it into your own Swing apps. Its packed full of great examples, covering most (if not all) of the Swing components. They also happen to be far superior to those offered by other titles.