Customer Reviews

Java Swing

5 star:		(20)
4 star:		(24)
3 star:		(12)
2 star:		(10)
1 star:		(10)

 

 

Pavel Vorobiev and I are currently finishing up an 'advanced' Swing book consisting mainly of examples ("Swing", Manning publications). We have referenced the Swing source code nonstop. Apart from this, we feel that Java Swing is the best Swing reference money can buy. This book is not an API docs dump. It is a high quality reference book for GUI developers who are prepared to do their job professionaly, not blindly. If you are looking for a hand-holding tutorial this book is not for you (for this I would suggest Up to Speed With Swing).

Java Swing is very well organized and full of original explanation. I encourage potential readers to disregard other comments claiming that this book is API repetitive or doesn't explain enough. No book can cover every possible situation that can arise in the creation of a GUI, and no book will fully explain all of the inner workings of each Swing component and UI delegate. Swing is a very complex and extensive library with some very interesting and powerful mechanisms working behind the scenes. Without a doubt, Java Swing is the most informative and rich reference available. I recommend it highly.

Matthew Robinson
"Swing", Manning publications
Swing "Tips and Tricks", The Swing Connection

"Java Swing" is an in-depth look at the features and components of Java's popular Swing API. The much-anticipated second edition of O'Reilly's classic brings the book up-to-date with the changes made in SDKs 1.3 and 1.4. Each Swing component is covered in detail, providing information on constructors, methods, and properties. There is of course a plethora of example code clearly demonstrating how to use the various components and features.

While "Java Swing" is quite a hefty book, it does not cover the Java event model introduced in JDK 1.1, the AWT layout managers, or relevant AWT components such as Component that are subclassed by Swing components. Instead references are given to pdf files containing chapters of O'Reilly's out-of-print AWT book. While this may have been an acceptable omission for the first edition in 1998, where it might be assumed that developers had some experience with AWT, I do not feel this is a valid assumption today.

If you can look past the book's omissions, or if you have a companion reference covering those features, "Java Swing" has much to offer and will serve as a treasured reference. If you are unfamiliar with AWT and looking to learn how to develop user interfaces in Java, you may wish to look elsewhere first.

There is a lot to know about Swing -- a ton. It's a hazard in writing about it to render so much information in a tedious way, and this book fell victim to it. Every stone of Swing the authors could think to turn is, I am sure, turned. For Pete's sake, this book is longer than Unix Power Tools, and that book represents two decades of Unix experiences!

I've had this book for six months and I'm still trying to pick through all the method, class, and interface descriptions to find the kernels of real insight. The book does have them, but you have to wade in deep to get one. I would rather have a well-organized collection of insights to guide exploration, and a separate reference section; this book mostly lists and explains. I can't stay awake for it.

The concepts are important. Plenty of examples are important. With those things firmly in hand, you can point out exceptions or substantive variations on rules, focussing on major ideas.

I have no doubt this book was an exhausting effort; the style reflects it.

This book has been well reviewed by others, but for once I actually read a programming book cover to cover (on vacation), so I wanted to comment.

This is the first book on Swing that I have read, though perhaps the 10th on Java, and I have been using Swing since the first beta was available.

I think the authors should be commended for really examining each class that is presented, and the sample programs to exercise the "little" classes really show good preparation. I think the size of the sample code is perfect to explain a concept without getting bogged down in the details of a toy application.

The book is organized in a "bottom up" fashion, so the TableColumn class is explained before JTable (for example). This provides consistant explanations, but it does mean deferring the motivation for learning something until the end.

The biggest problem is with the Text/Editor classes. Here there are 200 pages of preliminary information before you get to JEditorPane, and then the authors stop and say the class is too buggy to explain. I can't blame the authors for JDK problems, but I think a "top down" explanation might work better with this very complex set of classes. On the other hand, if we ever do get a version of JEditorPane that can display HTML without throwing exceptions, these chapters will provide good background material.

I learned things from almost every chapter, it is a very good reference.

I've read a large number of technical computer books, and I've found that the quality of writing varies enormously from book to book (Wrox). And so, too, does the overall comprehensibility.

This book, however, really made my life easy. In the project I was working on, I knew pretty much what I needed to do, and this book facilitated my understanding of Swing greatly. The text is filled with examples and thoroughly documents each of the Swing components. I found it very helpful as a supplement to the official Java documentation.

I hadn't read an O'Reilly book until this one and I have to say that I'm impressed. I'll be trying out some of their other books in the hopes that the quality carries over.

This is for people who have a working knowledge of Swing and who want a comprehensive reference on their desks. I am preparing for the java Developer exam and thought this would help me get up to speed with Swing. But this is an over kill. Trying to learn Swing with this book is like trying to open a can of Coke with a bulldozer. It would have been more helpful if the Title was something like 'Swing Reference'. If you want to learn some Swing to get some work done very quickly stay away. If you are in the Guru class then go for it. 4 stars because it is indeed a well written reference (Juding from Chapter 1 and 3 and some skimming) But not 5 stars because the Title is misleading

OK but there are lots of better books on swing. The *book* is Geary's Graphic Java but at 1600 pages it is more of a reference then something you'll want to read-it's just *too* big. On the other hand, I just got Zukowski's Swing book and it seems really excellent - much more manageable then Geary and more up to date then Eckstein. Of course, the best situation would be if there was a new edition of Core JFC -none of the code runs in that anymore although the changes needed aren't hard-I learned swing from that book!

For visual programming, Swing is a vast improvement over the AWT. Using Swing you can create virtually any user interface. At the same time, Swing is much more complex and contains far more components than the AWT. This book provides an in-depth introduction into the complexities of Swing. The authors start with a discussion of some of the features of Swing and the Model-View-Controller architecture which helps to make Swing so much more powerful than the AWT. The authors then discuss some of the simpler Swing objects (JLabel, JButton) leading us into a deeper understanding of the Swing architecture and preparing us for the more complex objects that follow. Each Swing class (JLabel, JInternalFrame, JDialog, JTree, and more) is explained in detail with numerous examples for each class. As the topics become more complex, the authors spend more time on the topic and provide more examples. The authors spend 6 chapters explaining the Swing text framework and make this complex topic almost simple to understand. The authors are not content to merely explain how to use the Swing classes but they spend time showing us how to create our own objects derived from the Swing classes. Java Swing is a huge book (more than 1,200 pages), especially by O'Reilly standards, but there are no pages wasted on a "quick reference". The authors have provided us with a well written, complete, easy to understand, and ultimately indispensable guide to Java Swing.

This extremely hefty book on Swing has just about everything in it. However, it is intended to be a reference on Swing, not a tutorial. The problem with the Java Swing API is that it is so large and unwieldy itself that it is difficult to write a complete and useful reference that does not reflect that fact. If you need a good tutorial on Java Swing, you might want to look at the Core Java books by Cornell and read the chapters that apply to Swing. Cornell manages to carve out the basics of writing a Swing application very clearly without getting wrapped around the axle in details you do not need if you are a beginner. Then, come back to this book when you need to write an application to get the details you need. Since everything in Swing is a JavaBean, much of each component's behavior is controlled by a set of properties that are manipulated by accessor methods. Thus, this book has a table for each class that presents the class properties, the data type for each property, the accessor methods, and the default values. In addition, the book has plenty of demonstration code that shows how to use just about all of the various Swing components. The book even has chapters dedicated to changing the look and feel of components and also repainting issues, which loom large in Swing. You can download all of the book's code from the book's website at O'Reilly and Associates. I highly recommend this book to anyone who already knows the bare basics of writing applications with Swing and needs a useful reference. There is no better one out there in publication of which I am aware.

Man, has Swing grown; no wonder it took 5 authors to write this book! Anyway, they do a good job describing a very complex subject. The text is definitely more of a reference than a tutorial, but if that's what you're looking for then definitely check out this book...
*IF* you have another source for layout managers. Other reviewers have pointed this out as well. In my opinion, this topic deserves its own chapter because every time you put a component in a container you have to be aware of its layout manager. And when a dialog box gets complicated, as they are wont to do, you have layout managers dealing with each other ad infinitum - and that is precisely when you really need to understand how they work so you can make sense of what is going on when you resize something.