|Jamaica 6.1 release 1|
|PREV PACKAGE NEXT PACKAGE||FRAMES NO FRAMES|
|AppletInitializer||This interface is designed to work in collusion with java.beans.Beans.instantiate.|
|BeanInfo||A bean implementor who wishes to provide explicit information about their bean may provide a BeanInfo class that implements this BeanInfo interface and provides explicit information about the methods, properties, events, etc, of their bean.|
|Customizer||A customizer class provides a complete custom GUI for customizing a target Java Bean.|
|DesignMode||This interface is intended to be implemented by, or delegated from, instances of java.beans.beancontext.BeanContext, in order to propagate to its nested hierarchy of java.beans.beancontext.BeanContextChild instances, the current "designTime" property.|
|ExceptionListener||An ExceptionListener is notified of internal exceptions.|
|PropertyChangeListener||A "PropertyChange" event gets fired whenever a bean changes a "bound" property.|
|PropertyEditor||A PropertyEditor class provides support for GUIs that want to allow users to edit a property value of a given type.|
|VetoableChangeListener||A VetoableChange event gets fired whenever a bean changes a "constrained" property.|
|Visibility||Under some circumstances a bean may be run on servers where a GUI is not available.|
|BeanDescriptor||A BeanDescriptor provides global information about a "bean", including its Java class, its displayName, etc.|
|Beans||This class provides some general purpose beans control methods.|
|EventSetDescriptor||An EventSetDescriptor describes a group of events that a given Java bean fires.|
|FeatureDescriptor||The FeatureDescriptor class is the common baseclass for PropertyDescriptor, EventSetDescriptor, and MethodDescriptor, etc.|
|IndexedPropertyChangeEvent||An "IndexedPropertyChange" event gets delivered whenever a component that
conforms to the JavaBeans
|IndexedPropertyDescriptor||An IndexedPropertyDescriptor describes a property that acts like an array and has an indexed read and/or indexed write method to access specific elements of the array.|
|Introspector||The Introspector class provides a standard way for tools to learn about the properties, events, and methods supported by a target Java Bean.|
|MethodDescriptor||A MethodDescriptor describes a particular method that a Java Bean supports for external access from other components.|
|ParameterDescriptor||The ParameterDescriptor class allows bean implementors to provide additional information on each of their parameters, beyond the low level type information provided by the java.lang.reflect.Method class.|
|PersistenceDelegate||The PersistenceDelegate class takes the responsibility for expressing the state of an instance of a given class in terms of the methods in the class's public API.|
|PropertyChangeEvent||A "PropertyChange" event gets delivered whenever a bean changes a "bound" or "constrained" property.|
|PropertyChangeListenerProxy||A class which extends the
|PropertyChangeSupport||This is a utility class that can be used by beans that support bound properties.|
|PropertyDescriptor||A PropertyDescriptor describes one property that a Java Bean exports via a pair of accessor methods.|
|PropertyEditorManager||The PropertyEditorManager can be used to locate a property editor for any given type name.|
|PropertyEditorSupport||This is a support class to help build property editors.|
|SimpleBeanInfo||This is a support class to make it easier for people to provide BeanInfo classes.|
|VetoableChangeListenerProxy||A class which extends the
|VetoableChangeSupport||This is a utility class that can be used by beans that support constrained properties.|
|IntrospectionException||Thrown when an exception happens during Introspection.|
|PropertyVetoException||A PropertyVetoException is thrown when a proposed change to a property represents an unacceptable value.|
|Annotation Types Summary|
|ConstructorProperties||An annotation on a constructor that shows how the parameters of that constructor correspond to the constructed object's getter methods.|
|Transient||Indicates that an attribute called "transient"
should be declared with the given
Contains classes related to developing
beans -- components
based on the JavaBeansTM architecture.
A few of the
classes are used by beans while they run in an application.
For example, the event classes are
used by beans that fire property and vetoable change
PropertyChangeEvent). However, most of the classes in this
package are meant to be used by a bean editor (that is, a development environment
for customizing and putting together beans to create an application). In
particular, these classes help the bean editor create a user
interface that the user can use to customize the bean. For example, a bean may
contain a property of a special type that a bean editor may not know how to handle.
By using the
PropertyEditor interface, a bean developer can
provide an editor for this special type.
To minimize the resources used by a bean, the classes used by bean editors are loaded only
when the bean is being edited. They are not needed while the bean is running in an application
and therefore not loaded. This information is kept in what's called a bean-info (see
Unless explicitly stated, null values or empty Strings are not valid parameters for the methods in this package. You may expect to see exceptions if these parameters are used.
java.beanspackage provides support for long-term persistence -- reading and writing a bean as a textual representation of its property values. The property values are treated as beans, and are recursively read or written to capture their publicly available state. This approach is suitable for long-term storage because it relies only on public API, rather than the likely-to-change private implementation.
Note: The persistence scheme cannot automatically instantiate custom inner classes, such as you might use for event handlers. By using the
EventHandlerclass instead of inner classes for custom event handlers, you can avoid this problem.
You read and write beans in XML format using the
One notable feature of the persistence scheme is that
reading in a bean requires no special knowledge of the bean.
Writing out a bean, on the other hand,
sometimes requires special knowledge of the bean's type.
If the bean's state can be
expressed using only the no-argument constructor and
public getter and setter methods for properties,
no special knowledge is required.
Otherwise, the bean requires a custom persistence delegate --
an object that is in charge of writing out beans of a particular type.
All classes provided in the JDK that descend
as well as all their properties,
automatically have persistence delegates.
If you need (or choose) to provide a persistence delegate for a bean,
you can do so either by using a
or by creating your own subclass of
If the only reason a bean needs a persistence delegate
is because you want to invoke the bean's constructor with
property values as arguments,
you can create the bean's persistence delegate
with the one-argument
you need to implement your own persistence delegate,
for which you're likely to need the following classes:
Expressions are necessary to create the bean and restore its state.
Statementused for methods that return a value.
Once you create a persistence delegate,
you register it using the
setPersistenceDelegate method of
|Jamaica 6.1 release 1|
|PREV PACKAGE NEXT PACKAGE||FRAMES NO FRAMES|