Crear Java beans

Los Java beans son la respuesta de Sun a los controles ActiveX de Microsoft. Los
beans son componentes de código reutilizables escritos en Java que se pueden usar
en distintos entornos de programación. De hecho, funcionan de un modo muy similar a
los controles ActiveX, pues contienen propiedades, métodos y eventos para otros
componentes de código. Utilizando los beans, puede crear sus propios "controles"
Java personalizados, como botones que cambian de color cuando se hace clic sobre
ellos o paneles de cotizaciones de bolsa (stock tickers) que obtienen información de
Internet.

Los Java beans están diseñados para ser utilizados en herramientas de

preparación de aplicaciones, que son entornos de programación que permiten
configurar beans. Una de tales herramientas, el beanbox, se proporciona con en Sun
Bean Development Kit (BDK, o Kit de desarrollo de beans de Sun), que puede
descargarse desde www.java.sun.com e instalarse.
Utilizaremos BDK para diseñar y utilizar beans. Los beans permiten al usuario
crear sus propias aplicaciones partiendo de componentes preescritos, añadiendo sólo
lo que se necesita, y nada más.

Sun soporta Java beans en el paquete java.beans. Observe las interfaces de dicho
paquete:

* AppletInitializer-- Inicializa applets y está diseñado para funcionar con

java.beans.Beans.instantiate.
* BeanInfo—Esta interfaz proporciona información explícita sobre los métodos,
propiedades, eventos, etc. de un bean.
*Customizer—Una clase customizer class facilita una completa GUI predefinida
para personalizar un Java bean.
* DesignMode—Esta interfaz está destinada a la implementación o delegación
de instancias de java.beans.BeanContext con el fin de determinar si un bean está
diseñado mediante la propiedad designTime.
* PropertyChangeListener—Administra eventos PropertyChange si un bean
cambia una propiedad dependiente.
* PropertyEditor—Proporciona soporte para GUIs que permiten a los usuarios
editar el valor de una propiedad de un tipo dado.
* VetoableChangeListener—Administra eventos rechazados cuando un bean
modifica una propiedad de limitación.
* Visibility—Indica si un bean es visible (en algunas circunstancias, un bean
puede ejecutarse en servidores donde no hay disponible un GUI).

Y éstas son las clases en java.beans:

 * BeanDescriptor—Proporciona información global sobre un bean, incluyendo
sus clases Java, su nombre, etc.
* Beans—Proporciona algunos métodos de control de beans de propósito
general.
* EventSetDescriptor—Describe un grupo de eventos activado por un Java
bean.
*FeatureDescriptor—La clase base para PropertyDescriptor,
EventSetDescriptor, y MethodDescriptor.
* IndexedPropertyDescriptor—Describe una propiedad que actúa como una
selección.
* Introspector—Facilita un modo estándar.
* MethodDescriptor—Describe un método específico para obtener información
acerca de las propiedades, los eventos y los métodos soportados por un Java bean.
* ParameterDescriptor—Facilita información de cada uno de los parámetros de
los métodos, además de la información de bajo nivel proporcionada por la clase
java.lang.reflect.Method.
* PropertyChangeEvent—Busca eventos PropertyChange ejecutados cuando
un bean cambia una propiedad vinculada.
* PropertyChangeSupport—Una clase de utilidad que pueden usar los beans
que soportan propiedades de vinculación.
* PropertyDescriptor—Describe una propiedad que exporta un Java bean.
*PropertyEditorManager—Puede utilizarse para localizar un editor de
propiedades para cualquier nombre dado.
* PropertyEditorSupport—Una clase de soporte que ayuda a configurar editores
de propiedades.
* SimpleBeanInfo—Una clase que hace más fácil a los usuarios proporcionar
datos BeanInfo.
* VetoableChangeSupport—Una clase de utilidad que puede usarse por los
beans que soportan propiedades de vinculación.

A continuación, veremos cómo crear Java beans, desde los más sencillos hasta
los que soportan propiedades y métodos y permiten a los usuarios incrustar otros
controles dentro de ellos.

Diseñar programas utilizando Java beans

"¿Cómo utilizo Java Beans?" quiere saber el programador novato.
"Utilícelos en herramientas de desarrollo de aplicaciones" le recomiendan, "como
la herramienta beanbox que se proporciona con el Bean Development Kit”.
"Muéstreme cómo" dice el programador novato.

Después de haber descargado e instalado Bean Development Kit (BDK), puede

trabajar con los beans del beanbox de BDK. Asumiendo que ha instalado BDK en su
ruta de acceso predeterminada (C:\BDK), puede abrir el beanbox con el archivo
run.bat de la ruta C:\BDK\beanbox. Al ejecutar el archivo bat, se abre el beanbox.
En la caja de herramientas (toolbox) puede ver los beans disponibles. Cuando
añade beans a una aplicación, aparecerán en la ventana del beanbox situados junto a
la toolbox. También puede utilizar la ventana Properties (propiedades) para definir las
propiedades que hayan sido diseñadas en un bean, y puede utilizar la ventana
Method Tracer para administrar la ejecución del método. Se puede dibujar un bean en
el beanbox arrastrando el ratón.

También puede conectar los beans de un beanbox, con el fin de crear una única
aplicación utilizando varios beans. Por ejemplo, podría conectar un botón al bean
Juggler para que cuando haga clic sobre este botón, el juggler deje de ejecutarse.

Primero, haga clic sobre el bean Button en el beanbox. La ventana Properties

mostrará las propiedades que puede establecer para este bean, incluyendo su etiqueta
(si desea añadir una nueva etiqueta para este botón, puede hacerlo en la ventana
Properties).
Para conseguir que el botón realice una acción cuando haga clic sobre él,
seleccione el elemento de menú Edit|Events|action|actionPerformed. Una vez lo haga,
aparece una línea roja entre la ubicación del ratón y el botón. Extienda esa línea hacia
el bean Juggler y haga clic sobre él. Así se conecta el botón y el bean Juggler.

Cuando hace clic sobre el bean Juggler, aparece el cuadro de diálogo Event
target, ofreciendo los métodos disponibles a los que se puede llamar en el bean
Juggler cuando se hace clic sobre el botón. Para este ejemplo, seleccione el método
stopJuggling para que el juggler deje de ejecutarse; después, haga clic sobre el
botón OK para cerrar el cuadro de diálogo Event Target.

Eso es todo. Ahora, cuando hace clic sobre el botón del beanbox, el juggler dejará
de ejecutarse.
¡Enhorabuena! Ya ha conectado dos beans, y por lo tanto, ha creado un nuevo
programa.

Cómo puede ejecutar este programa fuera del beanbox? Lea detenidamente la
sección siguiente.

Crear applets que utilizan Java beans

"De acuerdo" dice el programador novato. "He diseñado un applet con varios
beans y ahora quiero crear un archivo JAR que pretendo pueda utilizar quien lo
necesite. ¿Cómo puedo hacerlo?".
"Es muy fácil" respondo.
"Veamos cómo".

Una vez ha diseñado un applet utilizando el beanbox, puede usar el elemento

MakeApplet del menú File para crear un archivo JAR que contenga su nuevo applet y
todos los bean que necesite. Cuando seleccione este comando de menú, se abre el
cuadro de diálogo Make an Applet. En él hay que fijar el nombre de archivo JAR
predeterminado, myApplet.jar, con a clase applet MyApplet. Al hacer clic sobre el
botón OK, se crea el archivo myApplet.jar.

Nota: si desea utilizar cualquiera de los bean que proporciona BDK en un archivo
applet JAR, tendrá que compilarlos primero y asegurarse de que el compilador Java
puede localizar sus archivos de clase. Encontrará estos bean en
C:\BDK\demo\sunw\demo. Además, necesitará compilar el archivo AppletSupport.java
en C:\BDK\beanbox\sunw\beanbox y asegurarse de nuevo de que el compilador Java
localiza los archivos de clase resultantes.

El archivo myApplet.jar puede utilizarse en navegadores Web y en Sun

appletviewer. Observe un ejemplo de página HTML que utilizaré en myApplet.jar:

<HTML>

<HEAD>
<TITLE>Ejemplo de applet beans</TITLE>
</HEAD>

<BODY>
<APPLET
CODE=MyApplet.class
WIDTH=200
HEIGHT=200>
<PARAM NAME=archive VALUE="myApplet.jar">
</APPLET>
</BODY>

</HTML>

Ahora ya sabe cómo utilizar Java beans en applets.

Crear un Java bean

Ahora, el programador novato aparece y dice:

"Ya he utilizado Java beans, pero ahora quiero crear mis propios bean".
A lo que le responde "Bueno, no es muy difícil, pero lleva un poco de trabajo".
"¿Sí? ¡vamos a comprobarlo!".

Crearemos un sencillo Java bean para ver cómo funciona. Este bean se limitará a
cambiar para mostrarse en color rojo, y mostrará una cuenta del número de veces que
se ha hecho clic sobre él.
Situaremos este bean en los directorios de demostración de BDK, de modo que
hay que crear un directorio llamado bean (C:\BDK\demo\sunw\demo\bean) y
guardaremos los archivos de clase de ese bean en ese directorio. Ejecute el código,
bean.java, indicando que este bean forma parte de un paquete llamado
sunw.demo.bean:

package sunw.demo.bean;
import java.awt.*;
import java.awt.event.*;
.
.
.

Mientras permanece activa la clase actual del bean, utilice la clase Canvas para
dibujar el propio bean (también puede usar otras clases, como la clase Panel). El resto
del código es bastane sencillo y se utiliza de manera ordinaria; se añade un
controlador de ratón para registrar los clic del ratón, y se define el tamaño del lienzo ( y
por lo tanto, en tamaño del bean):

package sunw.demo.bean;
import java.awt.*;
import java.awt.event.*;

public class bean extends Canvas

{
int count;

public bean()
{
addMouseListener(new MouseAdapter() {
public void mousePressed(MouseEvent me) {
clicked();
}
});
count = 0;
setSize(200, 100);
}
.
.
.
}

Finalmente, es necesario implementar el método que administra los clic del ratón,
y dibujar el bean, incluyendo el registro de clics, en el método paint:

package sunw.demo.bean;
import java.awt.*;
import java.awt.event.*;

public class bean extends Canvas

{
int count;

public bean()
{
addMouseListener(new MouseAdapter() {
public void mousePressed(MouseEvent me) {
clicked();
}
});
count = 0;
setSize(200, 100);
}

public void clicked()

{
count++;
repaint();
}

public void paint(Graphics g)

{
Dimension dimension = getSize();
int height = dimension.height;
int width = dimension.width;

g.setColor(new Color(255, 0, 0));

g.fillRect(0, 0, --width, --height);

g.setColor(new Color(0, 0, 0));

g.drawString("Click count = " + count, 50, 50);
}
}

Crear un archivo de manifiesto bean

El programador novato sigue queriendo aprender:

"De acuerdo, he escrito el código para mi nuevo Java bean, ¿pero ahora qué?".
Sonríes y dices: "Tienes que empaquetar el bean en un archivo JAR y especificar
que se trata de un bean del archivo de manifiesto del archivo JAR".
"¡Cuéntame más!" dice el programador novato.
Para convertir un bean en lo que es, debe almacenar los archivos de clase a
utilizar en el archivo JAR, y utilizar un manifiesto para especificar qué clases son
beans. Para ver cómo funciona esto, utilizaremos el bean desarrollado en la sección
anterior y crearemos un archivo de manifiesto, bean.mft. Situaremos este archivo de
manifiesto en C:\BDK\demo para crear de un modo más sencillo el archivo JAR (ver la
sección siguiente).

Para especificar que una clase de un archivo JAR es un Java bean, tiene que
pasar sus atributos Java-Bean a True. El archivo de clase se encuentra en el paquete
sunw.demo.bean, lo que significa que se almacenará en el archivo JAR como
sunw/demo/bean/bean (al igual que UNIX, los archivos JAR utilizan barras inclinadas
como separaciones de directorio). Para especificar que este archivo de clase es un
bean, observe cómo queda el archivo de manifiesto, bean.mft:

Name: sunw/demo/bean/bean.class
Java-Bean: True

En la sección siguiente creará el archivo JAR para este bean.

Crear un archivo Jar para bean

Ahora, el programador novato dice:

"De acuerdo, ya tengo los archivos de clase para mi nuevo bean, y el archivo de
manifiesto que deseo utilizar. ¿Ahora qué?";
A lo que le contestas "Ahora, ya estás preparado para utilizar una herramienta
jar".

A continuación, creará el archivo JAR para el bean que ha venido desarrollando

en las dos secciones anteriores. Primero, compile bean.java, que creará dos archivos
de clase: bean.class y bean$1.class. Copie esos archivos a
C:\BDK\demo\sunw\demo\bean. A continuación, sitúe el archivo de manifiesto
desarrollado en la sección anterior, bean.mft, en C:\BDK\demo. Ya está listo.
Asegúrese que se encuentra en el directorio C:\BDK\demo y utilice la herramienta jar
de este modo:

C:\BDK\demo>jar cfm ..\jars\bean.jar bean.mft sunw\demo\bean\*.class

Esto sirve para crear el Nuevo archivo JAR para este bean, bean.jar, y lo
almacena en el directorio C:\BDK\demo\jars, que es donde el beanbox lo buscará. Así
es como se instala un bean (situando su archivo JAR en ese directorio).

Utilizar un nuevo bean

 Hasta aquí se ha desarrollado un nuevo Java bean y se ha instalado en el
directorio C:\BDK\demo\jars. Cuando abra el beanbox, verá este bean en la lista
toolbox.
Este nuevo Java bean es un buen comienzo, pero ahora podría intentar algo más,
como añadirle otros controles Java.

Añadir controles a los bean

"No pretendo reinventar la rueda", dice el programador novato.

"¿Qué quieres decir?" insistimos.
"Bueno, si quiero añadir un botón a mi nuevo Java bean, ¿por qué tengo que
dibujarlo y desarrollarlo por mí mismo? ¿Por qué no puedo usar simplemente un botón
Java estándar? “
"Sí que puedes..."

Puede añadir controles Java como botones a sus bean (sólo tiene que asegurarse
en relacionar su bean en una clase que sea un contenedor, como la clase Panel).
Vea un ejemplo en el que se ha añadido un botón a un bean para que éste
muestre el número de veces que se ha hecho clic sobre él. Comience ubicando este
bean, que en este ejemplo llamaremos botón, a la clase Panel y añádalo al paquete
sunw.demo.button (lo que significa que guardará sus archivos de clase en
C:\BDK\demo\sunw\button). Observe cómo crear el panel, modificar su tamaño y
añadir un botón:

package sunw.demo.button;
import java.awt.*;
import java.awt.event.*;

public class button extends Panel implements ActionListener

{
int count;
Button button1;

public button()
{
count = 0;
setSize(200, 100);

button1 = new Button("Click me");

button1.addActionListener(this);

add(button1);
}
 Se trata de activar el botón incrementando el contador de clics, rediseñando el
bean para que muestre el contador y creando el método paint:

package sunw.demo.button;
import java.awt.*;
import java.awt.event.*;

public class button extends Panel implements ActionListener

{
int count;
Button button1;

public button()
{
count = 0;
setSize(200, 100);

button1 = new Button("Click me");

button1.addActionListener(this);

add(button1);
}

public void actionPerformed(ActionEvent e)

{
count++;
repaint();
}

public void paint(Graphics g)

{
Dimension dimension = getSize();
int height = dimension.height;
int w = d.width;
g.setColor(new Color(255, 0, 0));
g.fillRect(0, 0, w-1, h-1);

g.setColor(new Color(0, 0, 0));

g.drawString("Click count = " + count, 50, 50);
}
}

Como puede ver, es bastante sencillo añadir controles Java a un bean.

 Asignar propiedades a un bean
"Observo que se pueden ajustar las propiedades de un bean en el beanbox desde
la ventana Properties" dice el programador novato.
"Así es" le respondes.

Las propiedades de un bean le permiten configurarlo, ajustar su tamaño, color y

cualquier otro aspecto del bean ajustable mediante las propiedades. Existe un
procedimiento formal que debería seguirse para informar a la programación Java de
las propiedades de los beans: implementarla interfaz BeanInfo. Los campos de esta
interfaz se muestran en la tabla B.1 , y sus métodos en la tabla B.2.

Tabla B.1 . Campos de la interfaz BeanInfo

Campo Hace esto

static int ICON_COLOR_16x16 Indica un icono en color de 16 x 16.
static int ICON_COLOR_32x32 Indica un icono en color de 32 x 32.
static int ICON_MONO_16x16 Indica un icono monocromo de 16 x 16.
static int ICON_MONO_32x32 Indica un icono monocromo de 32 x 32

Tabla B.2 . Métodos de la interfaz BeanInfo

Método Hace esto

BeanInfo[ ] getAdditionalBeanInfo( ) Devuelve una colección arbitraria de otros
objetos BeanInfo.
BeanDescriptor getBeanDescriptor( ) Devuelve el BeanDescriptor del bean.
int getDefaultEventIndex( ) Obtiene el evento predeterminado. Un bean
puede tener un evento predeterminado que
será el que se utilice con más asiduidad.
int getDefaultPropertyIndex( ) Obtiene el índice de la propiedad
predeterminada. Un bean puede tener una
propiedad predeterminada que será la más
utilizada para las actualizaciones.
EventSetDescriptor[ ] Obtiene EventSetDescriptors del bean.
getEventSetDescriptors( )
Image getIcon(int iconKind) Devuelve un objeto de imagen que puede
utilizarse para representar al bean en
cuadros de herramientas, barras de
herramientas, etc.
MethodDescriptor[ ] getMethodDescriptors( Obtiene MethodDescriptors del bean.
)
PropertyDescriptor[ ] Genera PropertyDescriptors del bean.
getPropertyDescriptors( )
 De hecho, la mayoría de los beans no implementan la interfaz BeanInfo
directamente. En su lugar, extienden la clase SimpleBeanInfo, que implementa
BeanInfo. Este es el árbol de herencia de SimpleBeanInfo:

java.lang.Object
|____java.beans. SimpleBeanInfo

Encontrará el constructor de la clase SimpleBeanInfo en la tabla B.3. y sus

métodos en la B.4.

Para describir una propiedad, utilice la clase PropertyDescriptor, derivada de la

clase FeatureDescriptor. Este es el árbol de herencia de la clase FeatureDescriptor:

java.lang.Object
|____java.beans. FeatureDescriptor

Encontrará el constructor de la clase FeatureDescriptor en la tabla B.5. y sus

métodos en la B.6.

Tabla B.3. Constructor de la clase SimpleBeanInfo

Constructor Descripción
SimpleBeanInfo( ) Construye un objeto BeanInfo.

Tabla B.4 . Métodos de la clase SimpleBeanInfo

Método Descripción
BeanInfo[ ] getAdditionalBeanInfo( ) Implementado para indicar que n hay otros
objetos BeanInfo relevantes.
BeanDescriptor getBeanDescriptor( ) Implementado para indicar que no existe
descriptor.
int getDefaultEventIndex( ) Implementado para ocultar la existencia de
un evento predeterminado.
int getDefaultPropertyIndex( ) Implementado para ocultar la existencia de
una propiedad predeterminada.
EventSetDescriptor[ ] Implementado para ocultar la existencia de
getEventSetDescriptors( ) conjuntos de eventos.
Image getIcon(int iconKind) Implementado para negar que no existen
iconos disponibles.
MethodDescriptor[ ] getMethodDescriptors( Implementado para negar la existencia de
) métodos.
PropertyDescriptor[ ] Implementado para negar la existencia de
getPropertyDescriptors( ) propiedades.
Image loadImage(String resourceName) Método usado para ayudar en la carga de
imagines de iconos.
 Tabla B. 5 . Constructor de la clase FeatureDescriptor

Constructor Descripción
FeatureDescriptor( ) Construye un FeatureDescriptor.

Tabla B. 6 . Métodos de la clase FeatureDescriptor

Método Descripción
Enumeration attributeNames( ) Obtiene un detalle de los nombres
predeterminados de este atributo.
String getDisplayName( ) Visualiza el nombre personalizado de este
atributo.
String getName( ) Devuelve el nombre programático de este
elemento.
String getShortDescription( ) Obtiene la descripción breve de este
elemento.
Object getValue(String attributeName) Recupera un nombre de atributo mediante
esta utilidad.
boolean isExpert( ) Devuelve el valor True en elementos
pensados par usuarios expertos.
boolean isHidden( ) Devuelve el valor True en elementos
pensados para ser usados como una
herramienta.
boolean isPreferred( ) Devuelve el valor True en elementos
particularmente importantes para ser
presentados a otros usuarios.
void setDisplayName(String displayName) Define el nombre visualizado y localizado de
este elemento.
void setExpert(boolean expert) Define a un elemento como "de uso por
expertos".
void setHidden(boolean hidden) Define a un elemento como "de uso sólo
como herramienta".
void setName(String name) Establece el nombre de este elemento.
void setPreferred(boolean preferred) Marca elementos especialmente importantes
para mostrárselos a otros usuarios.
void setShortDescription(String text) Se puede asociar una breve cadena a modo
de descripción.
void setValue(String attributeName, Object Se puede asociar un atributo.
value)
 Este es el árbol de herencia de la clase PropertyDescriptor:

java.lang.Object
|____java.beans.FeatureDescriptor
|____java.beans.PropertyDescriptor

Encontrará los constructores de la clase PropertyDescriptor en la tabla B.7. y

sus métodos en la tabla B. 8.

Tabla B. 7 . Constructores de la clase PropertyDescriptor

Constructor Descripción
PropertyDescriptor(String propertyName, Construye un PropertyDescriptor.
Class beanClass)
PropertyDescriptor(String propertyName, Toma el nombre de una propiedad sencilla
Class beanClass, String getterName, además de nombres de método para leer y
String setterName)ç escribir la propiedad.
PropertyDescriptor(String propertyName, Toma el nombre de una propiedad sencilla
Method getter, Method setter) además de objetos Method para leer y
escribir la propiedad.

Tabla B. 8 . Métodos de la clase PropertyDescriptor

Método Descripción
Class getPropertyEditorClass( ) Genera una clase PropertyEditor explícita
que ha sido registrada para esta propiedad.
Class getPropertyType( ) Obtiene el objeto Class de la propiedad.
Method getReadMethod( ) Obtiene el método que debería utilizarse
para leer el valor de la propiedad.
Method getWriteMethod( ) Obtiene el método que debería utilizarse
para escribir el valor de la propiedad.
boolean isBound( ) Actualiza las propiedades que activen el
evento PropertyChange.
boolean isConstrained( ) Intenta actualizar las propiedades que
activen el evento VetoableChange.
void setBound(boolean bound) Intenta actualizar las propiedades que
activen el evento PropertyChange.
void setConstrained(boolean constrained) Intenta actualizar las propiedades que
activen el evento VetoableChange.
void setPropertyEditorClass(Class Normalmente, PropertyEditors será
propertyEditorClass) localizado mediante
PropertyEditorManager.
void setReadMethod(Method getter) Establece el método que debería utilizarse
para leer el valor de la propiedad.
void setWriteMethod(Method setter) Establece el método que debería utilizarse
para escribir el valor de la propiedad.

Ahora, eche un vistazo a un ejemplo donde se implementa una propiedad en un

Java bean. En este caso, se añadirá una propiedad llamada filled a la operación de
registro de clics del ratón desarrollada anteriormente. Se trata de una propiedad
booleana que, cuando está definida en True, asegura que el bean será rellenado de
color. A este nuevo bean le llamaremos Bean2.

Para mantener un registro de la nueva propiedad filled, añadirá una variable

privada booleana de dicho nombre a la clase Bean2:

package sunw.demo.bean2;
import java.awt.*;
import java.awt.event.*;

public class Bean2 extends Canvas

{
private boolean filled;
.
.
.

Inicialice esta propiedad al valor False cuando cree el bean:

package sunw.demo.bean2;
import java.awt.*;
import java.awt.event.*;

public class Bean2 extends Canvas

{
private boolean filled;
int count;

public Bean2()
{
addMouseListener(new MouseAdapter() {
public void mousePressed(MouseEvent me)
{
clicked();
}
 });

count = 0;
filled = false;
setSize(200, 100);
}
.
.
.
}

Al implementar una propiedad, Java buscará dos métodos: getPropertyName y

setPropertyName, donde PropertyName es el nombre de la propiedad. El método
get devuelve el valor actual de la propiedad, que puede ser de cualquier tipo
soportado, mientras el método set toma un argumento de ese tipo, al quie se supne
vamos a vincular dicha propiedad. Así es como se implementan los métodos gtfilled y
setfilled:

package sunw.demo.bean2;
import java.awt.*;
import java.awt.event.*;

public class Bean2 extends Canvas

{
private boolean filled;
int count;

public Bean2()
{
addMouseListener(new MouseAdapter() {
public void mousePressed(MouseEvent me)
{
clicked();
}
});

count = 0;
filled = false;
setSize(200, 100);
}

public void clicked()

{
count++;
repaint();
}
 public boolean getfilled()
{
return filled;
}

public void setfilled(boolean flag)

{
this.filled = flag;
repaint();
}
.
.
.
}

Y lo que queda es activar la propiedad filled. Si está en True, el bean debería

rellenarse de color, de modo que este es el código a añadir al método paint:

public void paint(Graphics g)

{
Dimension dimension = getSize();
int height = dimension.height;
int width = dimension.width;

if(filled){
g.setColor(new Color(255, 0, 0));
g.fillRect(0, 0, --width, --height);
}

g.setColor(new Color(0, 0, 0));

g.drawString("Click count = " + count, 50, 50);
}

Ahora es necesario crear una nueva clase, Bean2BeanInfo, que devolverá

información sobre esta nueva propiedad del bean. Esta clase estará en el mismo
paquete que el propio bean, pero está basada en la clase SimpleBeanInfo:

package sunw.demo.bean2;
import java.beans.*;

public class Bean2BeanInfo extends SimpleBeanInfo

{
.
.
.
}
 Para que Java reconozca las propiedades, implemente el método
getPropertyDescriptors, que devuelve una cadena de objetos PropertyDescriptor.
Cada objeto PropertyDescriptor contiene el nombre de una propiedad y apunta hacia
la clase que soporta dicha propiedad. Así es como crearemos un objeto
PropertyDescriptor para la propiedad filled:

package sunw.demo.bean2;
import java.beans.*;

public class Bean2BeanInfo extends SimpleBeanInfo

{
public PropertyDescriptor[] getPropertyDescriptors()
{
try {
PropertyDescriptor filled = new
PropertyDescriptor("filled", Bean2.class);
.
.
.
}
catch(Exception e) {}

return null;
}
}

Ésta es la única propiedad de Bean2, de modo que añadimos el nuevo objeto

PropertyDescriptor a una secuencia de este modo:

package sunw.demo.bean2;
import java.beans.*;

public class Bean2BeanInfo extends SimpleBeanInfo

{
public PropertyDescriptor[] getPropertyDescriptors()
{
try {
PropertyDescriptor filled = new
PropertyDescriptor("filled", Bean2.class);
PropertyDescriptor propertydescriptor[] = {filled};
return propertydescriptor;
}
catch(Exception e) {}

return null;
}
}
 Una vez compilada esta nueva clase, (Bean2BeanInfo.java), se sitúa
Bean2BeanInfo.class en C:\BDK\demo\sunw\demo\bean2, junto con las clases que se
creqron al compilar Bean2.java. Ahora es necesario un nuevo archivo de manifiesto
que incluya la clase Bean2BeanInfo. Este es el aspecto de bean2.mft:

Name: sunw/demo/bean2/Bean2BeanInfo.class
Name: sunw/demo/bean2/Bean2.class
Java-Bean: True

A continuación, sitúe este nuevo manifiesto en C:\BDK\demo. Finalmente, así es

como se ha creado el nuevo archivo Bean2.jar y se ha instalado:

C:\BDK\demo>jar cfm ..\jars\bean2.jar bean2.mft sunw\demo\bean2\*.class

Ahora, al iniciar el beanbox y añadir un Nuevo Bean2 al beanbox, la nueva

propiedad filled aparecerá en la ventana Properties. Si activa el valor True para filled,
el bean será rellenado de color.

Asignar un icono a un bean

Es posible que haya observado que algunos beans muestran iconos en el beanbox.
Puede añadir sus propios iconos a los beans (todo lo que tiene que hacer es agregar
un método getIcon a la clase BeanInfo). Observe cómo implementar este método y de
qué manera administrar todas las posibilidades (iconos monocromo o en color, y de
16x16 ó 32x32 píxels):

public java.awt.Image getIcon(int iconKind)

{
if (iconKind == BeanInfo.ICON_MONO_16x16 ||
iconKind == BeanInfo.ICON_COLOR_16x16 ) {
java.awt.Image image = loadImage("Icon16.gif");
return image;
}

if (iconKind == BeanInfo.ICON_MONO_32x32 ||
iconKind == BeanInfo.ICON_COLOR_32x32 ) {
java.awt.Image image = loadImage("Icon32.gif");
return image;
}

return null;
}