Free PDF Graphic Java 2: Mastering the Jfc, By Geary, 3Rd Edition, Volume 2: SwingBy David Geary
This is what you could draw from this publication. By soft file forms, you can be offered to read it in the device when you remain in your means home in cars and truck or bus and even train. It is your time also to read it when you are being in a waiting listing. And how you can read Graphic Java 2: Mastering The Jfc, By Geary, 3Rd Edition, Volume 2: SwingBy David Geary in your home could make use of the moment before sleeping as well as functioning.
Graphic Java 2: Mastering the Jfc, By Geary, 3Rd Edition, Volume 2: SwingBy David Geary
Free PDF Graphic Java 2: Mastering the Jfc, By Geary, 3Rd Edition, Volume 2: SwingBy David Geary
When a brand-new decision ends up being a new manufacturer of much better living, why should be sorry for of it? Something old have to be changed and also renewed with something brand-new, if the brand-new thing is better. As the additional task that we will suggest, if you have no concept to enjoy your downtime, reading could aid you to kill time wisely. Yeah, passing the times completely can be done by everyone. However, be wisely in investing the time is really unusual. So, do you want to be one of the wise individuals?
Sometimes, people could assume that analysis will certainly be so awesome as well as amazing. In addition, people that are reading are considered as a very creative individuals. Is that right? Maybe! One that can be kept in mind is that checking out habit does not just do by the clever people. Most of creative individuals also feel lazy to read, in addition to read Graphic Java 2: Mastering The Jfc, By Geary, 3Rd Edition, Volume 2: SwingBy David Geary It's seemly that individuals who have analysis routine have various personality.
Based on that case, it's clear that your time to read this publication will certainly not invest wasted. You could start to conquer this soft documents book to favor much better reading material. Yeah, locating this publication as reviewing book will supply you distinctive experience. The interesting subject, easy words to understand, as well as attractive improvement make you feel comfy to only read this Graphic Java 2: Mastering The Jfc, By Geary, 3Rd Edition, Volume 2: SwingBy David Geary
When you really feel that you're interested enough in this publication, you can get it by clicking the link to attach straight to the book. Graphic Java 2: Mastering The Jfc, By Geary, 3Rd Edition, Volume 2: SwingBy David Geary is given in the soft data kinds, so you could conserve and review it in various tool. We mean that it is suitable and also available to read each time you want. Even it remains in the train or every where you are, you can utilize the extra time for reading.
Master the Java Foundation Classes with Graphic Java 2, the most complete and comprehensive guide to the AWT, Swing, and the 2D API VOLUME 2: SWING Swing gives Java application programmers world-class tools for building professional, customizable cross-platform GUIs. This comprehensive reference by former Sun engineer David Geary shows experienced programmers how to take full advantage of Swing's power. Practical explanations and robust code examples provide the resources you need to build Java applications with sophisticated graphical user interfaces. Graphic Java is the one exhaustive reference that contains everything you need to know about Swing. In depth explanations are coupled with class diagrams and code examples for all of the key components, including: * Buttons and labels * Progress bars and sliders * Frames, windows, and dialogs * Internal frames and desktop panes * Color and file choosers * Menus and toolbars * Lists and combo boxes * Text components * Tables and trees You'll discover the key design considerations associated with Swing development, including Swing's object-oriented idioms and design patterns, and the pluggable look and feel architecture. You will under
- Amazon Sales Rank: #1308028 in Books
- Brand: Prentice Hall
- Published on: 1999-03-22
- Original language: German
- Number of items: 1
- Dimensions: 9.00" h x 3.30" w x 7.00" l, 5.46 pounds
- Binding: Paperback
- 1622 pages
- Great product!
Amazon.com Review If you're developing software that will be used by a large group of people, you need to give it a good-looking front-end--in Java 2, that means you have to use Swing. An excellent resource, Graphic Java 2: Mastering the JFC, Third Edition (Volume 2: Swing) takes on the Swing components one at a time and shows you how to incorporate them into attractive, efficient programs.
In many ways, Graphic Java 2 is a cookbook. You search the table of contents or index for a reference to the kind of problem you want to solve, then examine the author's examples for the solution (or at least some clues to it). This is the book to turn to if you're wondering how to implement the JComboBox.KeySelectionManager interface (which enables users to select items in a combo box) or compare the various ways of making the JTree component into a file browser. Those are just two of hundreds of examples in David Geary's book.
While most examples don't serve any practical purpose by themselves, they do clearly illustrate how a specific aspect of Swing works. It's easy to adapt the details presented here into your own programs. Geary shows consideration for the reader by presenting all his examples as programs that can be compiled and including them on the enclosed CD-ROM. --David Wall
Review "At over 1500 pages, Graphic Java 2 is a monolith, heavy with details and weighted with valuable information for all Java UI developers. The coverage is meticulous and fluid, instructive in countless ways, unveiling things you won't find anywhere else. Yet it remains accessible to even a novice Swing developer. The net effect is that the price tag seems trivial given the value you can get from this book...
The coverage is not just impressive in its sheer volume; it's also an easy read with clear, concise explanations and useful examples...
All the fundamentals--in eloquent prose and incredible detail--are laid out before the reader in logical chapters that build on each other to unveil the most complete picture I've seen in print. I can hardly wait to read Volume III." -- DevX Book Reviews, July 29, 1999"Thinking about making that jump from the AWT to Swing? Not sure where to start or how to go about it? Your search stops with David Geary's Graphic Java 2: Mastering the JFC...
Part 2 covers all the Swing components and their properties in detail; each component allocated a chapter. Two of the most complex components--Table and Tree--are covered in great detail and Chapters 19 and 20, respectively. These two chapters alone are worth the price of the book for serious Swing developers...
All in all, Geary has done such a thorough job in Graphic Java 2 that it can truly be considered the Swing bible. Don't let the size of the book intimidate you, it provides a top-level view as well as microscopic details on all Swing components. It will definitely prove to be an asset in the Swing developer's arsenal." -- Dr. Dobbs Journal, September, 1999
From the Inside Flap
Preface
This book has been my full-time passion for more than a year. After Sun closed its office in Colorado Springs in August of 1997, I decided to forego traditional employment to give the Graphic Java series my complete attention. I was determined that the Swing volume would be the definitive guide to Swing, which meant that it had to be the most comprehensive, accurate and insightful Swing book available. I believe that to be the case, but of course, you will be the final judge.
Before I began writing, I spent a considerable amount of effort designing a book that would be beneficial to Swing novices in addition to developers with some Swing experience. As a software developer who has used numerous object oriented GUI frameworks, I realized that the fastest way to climb a framework's learning curve is to study code examples that illustrate specific concepts. As a result, code examples are the foundation upon which this book is built; nearly 300 code examples are discussed in detail--an average of approximately one code example every 5 pages.
However, code examples in and of themselves, cannot suffice as a reference for developers who have advanced along the Swing learning curve. As a result, every Swing component discussion is accompanied by a component summary that includes class diagrams, an examination of the component's properties and events and a class summary that discusses the public and protected methods implemented by the component.
The first part of this book explores fundamental aspects of Swing including:
Swing applets and applications
Swing and multithreading
Swing's Model-View-Controller architecture
Pluggable Look And Feel
The JComponent class
Borders, icons and actions
Miscellaneous features including timers and Swing utilities
The second part of the book examines Swing's components in detail. Numerous code examples are discussed for every Swing component, from labels and buttons to tables, trees and the text package. For example, more than 150 pages containing 25 code examples are dedicated to the table component, and 120 pages and 20 code examples illustrate how to get the most out of the tree component.
Audience
This book assumes that the reader has a good grasp of the Java language including recent additions to the language such as inner classes. This book also assumes a rudimentary understanding of the AWT; specifically, the delegation event model and the Component and Container classes upon which all Swing components are based. See "Graphic Java 2 Mastering the JFC Volume I: AWT" for a thorough investigation of AWT infrastructure and components.
How To Use This Book
Before diving into the Swing components, it is useful to have an understanding of fundamental concepts such as Swing's Model-View-Controller (MVC) design and pluggable look and feel. The former is discussed in "Swing Component Architecture" on page 71 and the latter is covered in the "Pluggable Look and Feel" on page 317. It is also important to understand the services provided by the JComponent class, which is the ultimate superclass of all lightweight Swing components. The JComponent class is examined in "The JComponent Class" on page 123.
Component Summaries
Each Swing component is introduced with numerous code examples that illustrate various component features. Code examples are followed by component summaries, such as the JScrollPane component summary that is partially listed below.
Component summaries begin with a listing of the component's model, UI delegate, renderer and editor, in addition to the events fired by the component. If a component is a replacement for an AWT component, the AWT component is also listed.
JScrollPane
----
javax.swing.plaf.basic.BasicScrollPaneUI
----
----
PropertyChangeEvent
java.awt.ScrollPane
The static relationships that a component maintains with other objects are illustrated with a class diagram, such as the class diagram for the JScrollPane class shown above. Class diagrams are introduced in Appendix A, Class Diagrams .
Properties
Property tables, such as the property table for the JScrollPane class shown below, are used to communicate a component's properties. Property tables include property names, the property's data type and whether a property is boolean, bound (a property change event is fired when the property is changed), simple (no events are fired when the property is changed), constrained (changes to the property can be vetoed), or indexed (a parameter, usually an integer , is used to access the property).
Some properties can be specified when a component is instantiated, and a component may provide setter and getter methods for a property. The manner in which a property can be specified is listed in the Access column of a property table.
Property tables also include a column for property default values.
Property tables are followed by a short description of each of the properties listed in the table.
JScrollPane Properties
Property Name
Data Type
Property Type
Access
Default
columnHeader
JViewport
B
SG
null
columnHeaderView
Component
B
S
null
corner
Component
IB
SG
null
horizontalScrollbar
JScrollBar
B
SG
----
horizontalScrollbarPolicy
int
B
CSG
As needed
rowHeader
JViewport
B
SG
null
rowHeaderView
Component
B
S
null
verticalScrollbar
JScrollBar
B
SG
----
verticalScrollbarPolicy
int
B
CSG
As needed
viewport
JViewport
B
SG
JViewport
viewportBorder
Border
B
SG
null
viewportView
Component
B
CSG
null
columnHeader
-- An instance of JViewport for the column header.
columnHeaderView
-- An instance of Component used as the column header viewport's view.
corner
-- A component that is displayed in one of the
scrollpane's corners. The corner is specified by one of the following strings:
ScrollPaneConstants.UPPER_LEFT_CORNER
ScrollPaneConstants.LOWER_LEFT_CORNER
ScrollPaneConstants.UPPER_RIGHT_CORNER
ScrollPaneConstants.LOWER_RIGHT_CORNER
horizontalScrollbar
-- The horizontal scrollbar used by the
scrollpane. The scrollbar is an instance of JScrollPane.ScrollBar , an extension of JScrollBar that takes into account whether the view contained in the scrollpane implements the Scrollable interface.
The remaining property descriptions for the JScrollPane class are omitted.
Events
Code examples are presented that illustrate event handling for a component. For example, the Tree chapter provides five code examples that illustrate handling of tree mouse, editing, selection, and expansion events.
Class Summaries
Each component summary concludes with a class summary that provides descriptions of the component's constructors and methods, such as the class summary for the JScrollPane class listed below.
JScrollPane
JComponent
ScrollPaneConstants, javax.accessibility.Accessible
public JScrollPane()
public JScrollPane(int vsbPolicy, int hsbPolicy)
public JScrollPane(Component view)
public JScrollPane(Component view, int vsbPolicy, int hsbPolicy)
JScrollPane provides four constructors. The integer values passed to JScrollPane
constructors represent the vertical and horizontal scrollbar display policies, in that order. The component passed to the constructors is used as the viewport's view, meaning it is the component that is scrolled by the
scrollpane.
The no-argument constructor constructs a scrollpane with a null component for the viewport's view, and scrollbar display policies that display both the horizontal and vertical scrollbars as needed.
Creation Methods
public JScrollBar createHorizontalScrollBar()
public JScrollBar createVerticalScrollBar()
protected JViewport createViewport()
Like most Swing components, JScrollPane
provides create... methods that create its subcomponents. Unlike most Swing components however, JScrollPane implements the methods that create its scrollbars as public instead of protected because the methods are invoked from the scrollpane's UI delegate.
The createHorizontalScrollBar and createVerticalScrollBar methods both return instances of JScrollPane.ScrollBar , which is an extension of JScrollBar that takes into account whether the scrollpane's view implements the Scrollable
interface. See Interface Summary 13-2 on page 779 for more information on the Scrollable interface.
The createViewport method returns an instance of JViewport that is used as the
scrollpane's default viewport.
As with all Swing components that implement create... methods, the methods can be overridden in extension classes to replace the default sub-components with custom versions.
The remaining method descriptions for the JScrollPane class are omitted.
Swing Bugs
Swing has come a long way in terms of quality. The early beta releases contained numerous bugs, many of which have subsequently been fixed. However, like any software, Swing still has its share of bugs. Throughout this book, I have tried to point out as many bugs as possible so that developers can avoid the frustration of debugging code only to discover that a problem is due to a Swing bug.
It is also important to keep in mind that this book is based on Swing 1.1 FCS. As we went to press, a 1.1.1 version of Swing was released that was mostly a bug fix release. Therefore, it is a certainty that some of the bugs cited in this book will have been fixed by the time this book is on the shelves.
Using the CD-ROM
The CD in the back of the book contains the following:
1.1.7 JDK and Swing 1.1.1
1.2 JDK and Swing 1.1 FCS
Code examples from this book
Swing and the JDK
As mentioned previously, Swing 1.1.1 is mostly a bug fix release. Swing 1.1.1 does not work with the 1.2 JDK, and therefore the 1.1.7 JDK is included on the CD. Swing 1.1 FCS works with both the 1.1.7 and 1.2 versions of the JDK.
Code Examples from the Book
All of the code examples in this book that are accompanied by a CD-ROM icon are included on the CD in the back of the book. Figure P-1 shows the directory structure for the code examples. A directory exists for every chapter in the book, and subdirectories are included for each example, which should make it trivial to locate examples. For instance, Example 3-1 on page 91 can be found in the chapters/3/1 directory.
Every example is compiled and ready to run. Some of the directories representing code examples contain a README.txt file if the examples exhibit bugs or have been modified from their listing in the book.
The CD also contains two versions of the GridBagLab application that comes with "Graphic Java 2 Mastering the JFC Volume I: AWT." One version uses external windows and another uses Swing internal frames. The application provides an example of a fairly complete Swing application and illustrates the use of Swing internal frames. Additionally, the application can be used to explore the intricacies of the GridBagLayout layout manager.
Applets Vs. Applications
Most of the code examples discussed in this book are applets, but a fair percentage of examples are applications. Applications are typically implemented instead of applets either because files are manipulated or dialogs are shown--applets have restricted access to files, and under JDK 1.2 dialogs displayed from an applet contain a warning string. Sometimes applications are implemented instead of applets simply for the sake of variety. Nearly all of the applications discussed in this book that do not manipulate files can easily be rewritten as applets.
Conventions Used in This Book
Table P-1 shows the coding conventions used in this book. Coding Conventions
Convention
Example
Class names have initial capital letters.
public class ClassName
Method names have initial lower case and the rest of the words have an initial capital letter.
getLength()
Variable names have initial lower case and the rest of the words have an initial capital letter.
private int length
private int bufferLength
Note that, for the most part, methods are referred to without their arguments; however, arguments are included when the discussion warrants them.
Table P-2 shows the typographic conventions used in this book.
Typographic Conventions
Typeface or Symbol
Description
Indicates that the accompanying code, command, or file is available on the CD that accompanies this book.
courier
Indicates a command, file name, class name, method, argument, Java keyword, HTML tag, file content, or code excerpt.
bold courier
Indicates a sample command-line entry.
italics
Indicates definitions, emphasis, a book title, or a variable that should be replaced with a valid value.
Graphic Java 2: Mastering the Jfc, By Geary, 3Rd Edition, Volume 2: SwingBy David Geary PDF
Graphic Java 2: Mastering the Jfc, By Geary, 3Rd Edition, Volume 2: SwingBy David Geary EPub
Graphic Java 2: Mastering the Jfc, By Geary, 3Rd Edition, Volume 2: SwingBy David Geary Doc
Graphic Java 2: Mastering the Jfc, By Geary, 3Rd Edition, Volume 2: SwingBy David Geary iBooks
Graphic Java 2: Mastering the Jfc, By Geary, 3Rd Edition, Volume 2: SwingBy David Geary rtf
Graphic Java 2: Mastering the Jfc, By Geary, 3Rd Edition, Volume 2: SwingBy David Geary Mobipocket
Graphic Java 2: Mastering the Jfc, By Geary, 3Rd Edition, Volume 2: SwingBy David Geary Kindle
