Customer Reviews

The JFC Swing Tutorial: A Guide to Constructing GUIs

5 star:		(7)
4 star:		(8)
3 star:		(4)
2 star:		(2)
1 star:		(3)

 

 

If you know Java, that is, Java without the GUI, and you want to write applets or programs that use GUI components (buttons, menues, text boxes, etc), pick up this book and you'll be writing your own GUI applications in under an hour. Don't bother with the "Differential Equations For Dummies" or with the Web Programming in 21 Days type of books -- Many of them use the older GUI and others, even though they do use Swing, use the older event handling model. If you want to program GUI, then do it right: The book is systematic and accurate and has plenty of examples of code. Use this book for textbook and/or reference.

It is clear to me that tutorial (i.e. an aide to "tutor") is what defines this book's purpose. While I agree with the other reviewer's comments about what this book lacks, I would like to complement the authors on what I believe is the greatest benefit of "The JFC Swing Tutorial". This is it seems that no matter problem I'm having with a particular aspect of Swing, this book gives me a "place to start" (isn't this what a tutor is for?). Yes, there are some gaps in its explanation of the Abstract/Default Table and TableColumn Model classes and some of the Event Handling material is too terse, etc.

However, time and time again, I've been in able to jump into this book "mid-trail" and wind up "on course" for solving a Swing-related problem. Some times the journey leads me to the constituent WEB Pages. Other times it's a trip into a JAVA IDE Debugger and/or a look at the javax.swing class soruce files. In any case this book has been the tutor I needed to learn Swing fundamentals and has led me to discover some advanced Swing features as well.

Target Audience
Java developers who want to learn to develop graphical applications using the Swing classes

Contents
This book is part of the Sun tutorial series, and concentrates on the Swing classes of the language.

The book is divided into the following chapters: Before You Start; Learning Swing By Example; Using Swing Components; Laying Out Components within a Container; Writing Event Listeners; Performing Custom Painting; Component Reference; Layout Manager Reference; Other Swing Features Reference; Event Listeners References; Troubleshooting Reference; Index

Review
Most of the coding I do in Java involves background agents that don't involve any sort of a user interface. But that's not to say that I haven't wanted to put a front end on some of my routines and allow for some user interaction. In order to do that, I need to learn more about how to use the Java GUI classes. This book, The JFC Swing Tutorial, is definitely what I need.

The book is a nice blend of tutorial and reference guide. The first six chapters are definitely tutorial in nature, with a number of examples and things you are asked to try and work through. At the end of each of those chapters, you'll find a series of questions and exercises that will allow you to assess your understanding of the material. Starting in chapter seven, the book moves more towards a reference manual, but not in the typical "here's the documentation" format. Each reference section has a series of "How To..." topics that give you more detailed information and examples about that feature. For instance, the formatted text field section has a demo of that feature, instructions on how to work with features in the JFormattedTextField class, and an API chart of the related classes and specific methods in JFormattedTextField. The blend of information and examples helps you to bridge the gap between theoretical and practical use.

The only "complaint" that one might have about this book is that much of the information can be found online at the Sun Java site. To that I say, "so what?" When I'm looking up a quick answer to something and I don't have my library available to me, online references are great. But when I'm learning a new skill, give me a book that I can carry around, mark up, and have open in front of me at the keyboard. It's how I work best.

Conclusion
This is a very complete and well-written volume on how to use the Swing GUI classes. If you need to learn how to move your Java programming in a graphical direction, you'll like this book.

The JFC Swing Tutorial is a guide to designing applications that use the Swing graphical components of the Java 2 Platform, and also Swing for JDK1.1. The authors do a fine job of guiding the reader through the basics concepts of Swing, and the new graphical components. For developers with little AWT experience, the new AWT event-delegation model is described in detail - you'll learn how to write event handlers that respond to GUI component actions.

I'm impressed by the clarity of this guide to Swing. Most Swing books presume a high level of experience with constructing GUIs in Java. However, I feel that the book could have gone much further, and provided some moderate-to-large scale applications as examples of what can be done with Swing. Many books devote a chapter or two towards the end to a Do-It-Yourself project, and offer step-by-step assistance. This is lacking from the book, and would have really added to its appeal. I also found the layout of the book distracting - it has been converted from a hypertext document, and all the links are still underlined.  

The JFC Swing Tutorial is a good general guide to learning about the Swing components. I feel that beginners will get more out of this book though than experienced AWT programmers, who may wish to consider other Swing titles. The book also includes a CD, with copies of Swing, JDK1.1 and the Java 2 SDK.  -- David Reilly, for the Java Coffee Break

This tutorial is well laid out and thorough. It looks suitable for learning Swing (I'm already fairly proficient) except for beginners to GUIs. It's also well organized as a reference work. It's much easier to understand than "Java Swing" from O'Reilly.

Of course the "down side" is that all the material is available online for free. So as an individual you can judge -- if the free online version is suitable for you then go for it. If you want something for your bookshelf or something you can write on and add bookmarks, well then shell out the money for the book. A CD in the back contains all the examples, so you won't need to go online for anything.

Ironically, unlike some earlier reviews (of the first edition) I feel the book is now better organized than the website.

This book provides an acceptable introduction to Swing components, but falls short in a couple of crucial areas.

First, coverage is very superficial, and as a result the book does nothing to impart an understanding of Swing component design. For example, the table component offers two model classes: AbstractTableModel and DefaultTableModel. If you want to know the differences between the two models, and when is it preferable to use one over the other, this book offers no guidance whatsoever. Twenty pages are devoted to the table component (Swing's most complex component, about which an entire book could be written) which is not nearly enough to understand or effectively use the component.

Second, the book's organization is abysmal, due to its origins as an online book. It appears that the book was printed exactly as it appears online -- underlined links and all -- which may have been the easy way out for the authors, but puts a terrible strain on readers. Following links by clicking the mouse is one thing, but following links by flipping pages is horrible. Also, the material is not presented in a logical manner; for example, handling events, which is a basic concept that should be discussed before individual components, appears somewhere in the middle of the book.

If you need a superficial overview of how to perform basic functions with Swing components, then you may benefit from this book. If you want to understand how Swing components are designed, how to perform intermediate-advanced techniques, and how to get the most out of Swing, look elsewhere.

When I started building GUIs in Java, I found this book to be invaluable. However, most -- if not all -- of the content of this book appears to be available online at java.sun.com. If you are new to Java and developing in an environment where you can't get to the Internet or you prefer hardcopy material then this is a great buy.

Be aware that the material in this book is a cut-and-paste of Sun's Java Tutorial, which is available free from java.sun.com.

The swing docs as well as the tutorial alone, are insufficient to learn Swing. The material is very skimpy, and does not explain the event handling and update interactions.

A few of the examples in the Tutorial were useful, but most were trivial. The book is pages and pages of generally simple code. If you do not have a fast connection and would rather have a book handy, I would still download the Java DOCs from Sun and install them on my local disk instead.

What I found useful were the demo examples that come with the JDK. I am still looking for a good swing book.

The JFC Swing Tutorial Second Edition is among the very best how-to-do it programming books I've read---and I've read scores! For this reason, I felt compelled to write a review of the book, admiring its organization, applauding its authors and encouraging progammers who need to to write Java GUIs to hurry up and by it. But then I read Thomas Duff's review; I became redundant. My recommendation is to read Mr. Duff's excellent review---knowing that I agree with every word of it.

3.5 stars

Having used the book a number of times I find it an excellent first reference for doing most relatively simple to intermediate things with swing. It has excellent organization and index so finding what you need is quite easier and fast. There are many code samples- snippets, not full listings- showing how are use the major and most heavily used features of most components. It is also written in an approachable and helpful manner. It disavows exhaustive coverage of every single feature ( Try Swing by Robinson and Vorobiev- ISBN 193011088X for that)

This book is not a tutorial on java. There is no overview of the language. There is a disc with code listing. The style is generally of a bunch of small, self contained lessons on how to use a component- hence the usefulness as a first reference (at the cost of cohesiveness and an overriding arch). Where it falls down is when you progress beyond beginner-intermediate level with swing and want major coverage of obscure features. This probably isn't a problem for most of us not needing to attain guru level swing-skill. I think a solid example on how to use the MVC pattern (Model View Controller where Swing addresses the View) would have been a nice (and appreciated!) addition. From personal experience there is a tendency to put too much Model in the View rather than separate them out so changes/updating through versions is simpler. Learning this lesson is a must for anybody working with GUI's.

At times too there is the annoyance of not including things you would consider necessary, for example an explicit example of a combo box model and so forth. This devalues the work to some extent. A brief reminder of annoymous inner classes (as event handlers of choice) should also be included as too perhaps some mention of threads and thread safety. Thus the book requires a certain level and certain approach. Just remember it isn't a step-by-step, "let's build an application" tutorial through Swing.

So overall: a good book to start with and keep handy as more of a easy reference than a tutorial (I like paper references rather than online ones so I maybe baised in this respect). It's light on some areas, particuarly higher level and greater depth stuff. It starts at a reasonable level if you have some experience with Java (a typical book like Core Java by Horstmann covers easily up to and enough Swing to get you to the point where this book is a reference rather than a how-to). As a how-to for a novice I think it may be beyond many of them. Swing: A Beginner's Guide by Herbert Schildt may be better in this regard. If you don't mind the short, sharp discrete (disjointed) approach to concepts than you might not mind this. Otherwise it may be frustrating.