لطفا منتظر باشید ...
15.1 Bean Basics
We begin our discussion of beans with some
basic concepts and terminology. Any object that conforms to certain
basic rules and naming conventions can be a bean; there is no
Bean class that all beans are required to
subclass. Many beans are Swing or AWT components, but it is also
quite possible, and often useful, to write
"invisible" beans that
don't have an onscreen appearance. ( Just because a
bean doesn't have an onscreen appearance in a
finished application doesn't mean that it
can't be visually manipulated by a beanbox tool,
however.)A bean exports properties, events, and
methods. A property is a piece of the
bean's internal state that can be programmatically
set and queried, usually through a standard pair of
get and set accessor methods. A
bean may generate events in the same way that a
GUI component, such as a JButton, generates
ActionEvent events. The JavaBeans API uses the
same event model (in fact, it defines the event model) used by Swing
and AWT GUIs in Java 1.1 and later. See Chapter 11
for a full discussion of this model. A bean defines an event by
providing methods for adding and removing event listener objects from
a list of interested listeners for that event. Finally, the
methods exported by a bean are simply any
public methods defined by the bean, excluding
those methods used to get and set property values and register and
remove event listeners.In
addition to the regular sort of properties just described, the
JavaBeans API also provides support for indexed properties, bound
properties, and constrained properties. An indexed
property is any property that has an array value and for
which the bean provides methods to get and set individual elements of
the array, as well as methods to get and set the entire array. A
bound property is one that sends out a
notification event when its value changes, while a
constrained property is one that sends out a
notification event when its value changes and allows the change to be
vetoed by listeners.Because Java allows dynamic loading
of classes, beanbox programs can load arbitrary beans. The beanbox
tool determines the properties, events, and methods a bean supports
with an introspection mechanism that is based on the
java.lang.reflect reflection mechanism for
obtaining information about the members of a class. A bean can also
provide an auxiliary BeanInfo class that supplies
additional information about the bean. The
BeanInfo class provides this additional
information in the form of a number of
FeatureDescriptor objects, each of which describes
a single feature of the bean. FeatureDescriptor
has a number of subclasses: BeanDescriptor,
PropertyDescriptor,
IndexedPropertyDescriptor,
EventSetDescriptor,
MethodDescriptor, and
ParameterDescriptor.A primary task of a beanbox
application is to allow the user to customize a bean by setting
property values. A beanbox defines property
editors for commonly used property types, such as numbers, strings,
fonts, and colors. If a bean has a property of a more complicated
type, however, it may need to define a
PropertyEditor class that enables the beanbox to
let the user set values for that property.In addition, a complex bean may not be
satisfied with the property-by-property customization mechanism
provided by most beanboxes. Such a bean may want to define a
Customizer class, which creates a graphical
interface that allows the user to configure a bean in some useful
way. A particularly complex bean may even define customizers that
serve as "wizards" that guide the
user step-by-step through the customization process.
