Reusable
components add standardized interfaces and object introspection mechanisms to
widgets, allowing builder tools to query components about their properties and
behavior.
Keep
in mind, too, that software components need not be visible in a running
application; they only need to be visible when the application is constructed.
For
example, the builder tool above shows a calculator component that is built from
16 button components, a text field component, and a panel with buttons and a
text display are placed. Because you are looking at the component in a builder
tool, you can see five additional components (NewCalcFlag,
zeroInteger, Accumulator, EnteredString, and opcharHolder) which are normally invisible when an application displays the
calculator. These additional components hold values or strings used by the
calculator for intermediate calculations, operation codes, and display strings.
A
programmer can move, query, or visually hook together components while operating
a builder tool. Often, such components do their work while the application is
running, though they are invisible to the user.
You
can purchase custom JavaBean components from third party vendors. You can also
purchase builder tools or application construction programs that support
JavaBeans. Application construction tools let you build Java applications using
the mouse as your primary input mechanism. You select components (from pallets,
panels, or menus) and drop them into a form, or client window. You can change
the behavior and look of these components by editing their properties, and you
can link the actions of one component to another via events and event handlers.
Components
can be nested and arbitrarily complex. For example, a calculator built from
components becomes, itself, a component to another application. Custom-built
components are easily added to builder tool palettes. More complex components
include barcharts, graphical diagram editors, and word processors.