Un componente software es una clase creada para ser reutilizada y que puede ser manipulada por una herramienta de desarrollo de aplicaciones visual. Se define por su estado que se almacena en un conjunto de propiedades, las cuales pueden ser modificadas para adaptar el componente al programa en el que se inserte. También tiene un comportamiento que se define por los eventos ante los que responde y los métodos que ejecuta ante dichos eventos.

Los eventos son las acciones que los usuarios van a provocar sobre los componentes.

Un subconjunto de los atributos y los métodos forman la interfaz del componente.

Para que pueda ser distribuida, se empaqueta con todo lo necesario para su correcto funcionamiento, quedando independiente de otras bibliotecas o componentes.

Para que una clase sea considerada un componente debe cumplir ciertas normas:

• Debe poder modificarse para adaptarse a la aplicación en la que se integra.
• Debe tener persistencia, es decir, debe poder guardar el estado de sus propiedades cuando han sido modificadas.
• Debe tener introspección, es decir, debe permitir a un IDE que pueda reconocer ciertos elementos de diseño como los nombres de las funciones miembros o métodos y definiciones de las clases, y devolver esa información.
• Debe poder gestionar eventos.

El desarrollo basado en componentes tiene, además, las siguientes ventajas:

• Es mucho más sencillo, se realiza en menos tiempo y con un coste inferior.
• Se disminuyen los errores en el software ya que los componentes se deben someter a un riguroso control de calidad antes de ser utilizados.

Como en cualquier clase, un componente tendrá definido un estado a partir de un conjunto de atributos. Los atributos son variables definidas por su nombre y su tipo de datos que toman valores concretos. Normalmente los atributos son privados y no se ven desde fuera de la clase que implementa el componente, se usan sólo a nivel de programación.

Las propiedades de un componente pueden examinarse y modificarse mediante métodos o funciones miembro, que acceden a dicha propiedad, y pueden ser de dos tipos:

• getter: permiten leer el valor de la propiedad. Tienen la estructura:

public <TipoPropiedad> get<NombrePropiedad>( )

Si la propiedad es booleana el método getter se implementa así:

public boolean is<NombrePropiedad>()

• setter: permiten establecer el valor de la propiedad. Tiene la estructura:

public void set<NombrePropiedad>(<TipoPropiedad> valor)

Si una propiedad no incluye el método set entonces es una propiedad de sólo lectura.

Por ejemplo, si estamos generando un componente para crear un botón circular con sombra, podemos tener, entre otras, una propiedad de ese botón que sea color, que tendría asociados los siguientes métodos:

public void setColor(String color)
            public String getColor()

Una de las principales características de un componente es que, una vez instalado en un entorno de desarrollo, éste debe ser capaz de identificar sus propiedades simplemente detectando parejas de operaciones get/set, mediante la capacidad denominada introspección. Recuerda que los métodos get/set se utilizan para obtener los valores de una clase.

El entorno de desarrollo podrá editar automáticamente cualquier propiedad de los tipos básicos o de las clases Color y Font. Aunque no podrá hacerlo si el tipo de datos de la propiedad es algo más complejo, por ejemplo, si usamos otra clase, como Cliente. Para poder hacerlo tendremos que crear nuestro propio editor de propiedades, por ejemplo, en la primera imagen puedes ver un editor programado para un componente que almacena información de personas, el nombre o el teléfono son cadenas de caracteres que se editan fácilmente, pero la dirección es una propiedad compuesta que precisa del siguiente editor. En la segunda imagen aparece el editor de una propiedad de tipo Color.

La creación de un editor de propiedades usando tecnología Java supone programar una clase que implemente la interfaz PropertyEditor, que proporciona métodos para especificar cómo se debe mostrar una propiedad en la hoja de propiedades. Su nombre debe ser el nombre de la propiedad seguido de la palabra Editor:

public <Propiedad>Editor implements PropertyEditor {…}

Por defecto la clase PropertyEditorSupport que implementa PropertyEditor proporciona los editores más comúnmente empleados, incluyendo los mencionados tipos básicos, Color y Font.

Una vez que tengamos todos los editores, tendremos que empaquetar las clases con el componente para que use el editor que hemos creado cada vez que necesite editar la propiedad. Así, conseguimos que cuando se añada un componente en un panel y lo seleccionemos, aparezca una hoja de propiedades, con la lista de las propiedades del componente y sus editores asociados para cada una de ellas. El IDE llama a los métodos getters, para mostrar en los editores los valores de las propiedades. Si se cambia el valor de una propiedad, se llama al método setter, para actualizar el valor de dicha propiedad, lo que puede o no afectar al aspecto visual del componente en el momento del diseño.

Los editores de propiedades tienen dos propósitos fundamentalmente:

• Convertir el valor de las cadenas para ser mostrados adecuadamente conforme a las características de la propiedad, y
• Validar los datos nuevos cuando son introducidos por el usuario.

Los pasos básicos para crear un editor de propiedades consisten en:

1. Crear una clase que extienda a PropertyEditorSupport.
2. Añadir los métodos getAsText y setAstext, que transformarán el tipo de dato de la propiedad en cadena de caracteres o viceversa.
3. Añadir el resto de métodos necesarios para la clase.
4. Asociar el editor de propiedades a la propiedad en cuestión.

Para ilustrar cómo se implementa un componente con una herramienta cómo NetBeans, adaptaremos un campo de texto de manera que podamos modificar mediante propiedades el ancho que ocupa en el formulario (número de columnas), el color del texto y la fuente. De esta manera veremos cómo modificar desde NetBeans propiedades sencillas que no necesitan un editor.  Tendremos las siguientes propiedades:

• El ancho que se puede representar cómo una propiedad de tipo entero.
• El color que será una propiedad de tipo Color, que cómo hemos dicho cuenta con su propio editor.
• La fuente será de tipo Font, y también cuenta con su propio editor.

Veamos cómo crear este ejemplo.

• Una propiedad simple representa un único valor, un número, verdadero o falso o un texto, por ejemplo. Por lo tanto, tomará valores dentro de un tipo de datos.

  Tiene asociados los métodos getter y setter para establecer y rescatar ese valor. Por ejemplo, si un componente de software tiene una propiedad llamada peso de tipo real susceptible de ser leída o escrita, deberá tener los siguientes métodos de acceso:

public real getPeso()
            public void setPeso(real nuevoPeso)

Una propiedad simple es de sólo lectura o sólo escritura si falta uno de los mencionados métodos de acceso.

• Una propiedad indexada representa un conjunto de elementos, que suelen representarse mediante un vector y se identifica mediante los siguientes patrones de operaciones para leer o escribir elementos individuales del vector o el vector entero (fíjate en los corchetes del vector):

  

public <TipoProp>[] get<NombreProp>()
public void set<NombreProp> (<TipoProp>[] p)
public <TipoProp> get<NombreProp>(int posicion)
public void set<NombreProp> (int posicion, <TipoProp> p)

Aquí tienes un ejemplo de propiedad indexada que resuelve el problema de Juan. El componente tiene una propiedad indexada que almacena los contenidos del menú, de este modo es sencillo crear diferentes menús de distintos tamaños. Para acceder a él solo tienes que definir dos tipos de setter y getter.

A continuación, puedes descargar el código asociado para que lo estudies:

Los objetos de una clase que tiene una propiedad compartida o ligada notifican a otros objetos oyentes interesados, cuando el valor de dicha propiedad cambia, permitiendo a estos objetos realizar alguna acción. Cuando la propiedad cambia, se crea un objeto (de una clase que hereda de ObjectEvent) que contiene información acerca de la propiedad (su nombre, el valor previo y el nuevo valor), y lo pasa a los otros objetos oyentes interesados en el cambio.

La notificación del cambio se realiza a través de la generación de un PropertyChangeEvent. Los objetos que deseen ser notificados del cambio de una propiedad limitada deberán registrarse cómo auditores. Así, el componente de software que esté implementando la propiedad limitada suministrará métodos de esta forma:

public void addPropertyChangeListener (PropertyChangeListener l)
            public void removePropertyChangeListener (PropertyChangeListener l)

Los métodos precedentes del registro de auditores no identifican propiedades limitadas específicas. Para registrar auditores en el PropertyChangeEvent de una propiedad específica, se deben proporcionar los métodos siguientes:

public void addPropertyNameListener (PropertyChangeListener l)
            public void removePropertyNameListener (PropertyChangeListener l)

En los métodos precedentes, PropertyName se sustituye por el nombre de la propiedad limitada. Los objetos que implementan la interfaz PropertyChangeListener deben implementar el método propertyChange(). Este método lo invoca el componente de software para todos sus auditores registrados, con el fin de informarles de un cambio de una propiedad.

Los métodos que se utilizan con propiedades simples e indexadas que veíamos anteriormente se aplican también a las propiedades restringidas. Además, se ofrecen los siguientes métodos de registro de eventos:

public void addPropertyVetoableListener (VetoableChangeListener l)
            public void removePropertyVetoableListener (VetoableChangeListener l)
            public void addPropertyNameListener (VetoableChangeListener l)
            public void removePropertyNameListener (VetoableChangeListener l)

Los objetos que implementa la interfaz VetoableChangeListener deben implementar el método vetoableChange(). Este método lo invoca el componente de software para todos sus auditores registrados con el fin de informarles del cambio en una propiedad.

Todo objeto que no apruebe el cambio en una propiedad puede arrojar una PropertyVetoException dentro del método vetoableChange() para informar al componente cuya propiedad restringida hubiera cambiado de que el cambio no se ha aprobado.

Juan tiene razón, la funcionalidad de un componente viene definida por las acciones que puede realizar definidas en sus métodos y no solo eso, también se puede programar un componente para que reaccione ante determinadas acciones del usuario, como un clic del ratón o la pulsación de una tecla del teclado. Cuando estas acciones se producen, se genera un evento que el componente puede capturar y procesar ejecutando alguna función. Pero no solo eso, un componente puede también lanzar un evento cuando sea necesario y que su tratamiento se realice en otro objeto.

Los eventos que lanza un componente, se reconocen en las herramientas de desarrollo y se pueden usar para programar la realización de acciones.

Para que el componente pueda reconocer el evento y responder ante el tendrás que hacer lo siguiente:

• Crear una clase para los eventos que se lancen.
• Definir una interfaz que represente el oyente (listener) asociado al evento. Debe incluir una operación para el procesamiento del evento.
• Definir dos operaciones, para añadir y eliminar oyentes. Si queremos tener más de un oyente para el evento tendremos que almacenar internamente estos oyentes en una estructura de datos como ArrayList o LinkedList:

public void add<Nombre>Listener(<Nombre>Listener l)
            public void remove<Nombre>Listener(<Nombre>Listener l)

• Finalmente, recorrer la estructura de datos interna llamando a la operación de procesamiento del evento de todos los oyentes registrados.

En resumen:

La introspección es una característica que permite a las herramientas de programación visual arrastrar y soltar un componente en la zona de diseño de una aplicación y determinar dinámicamente qué métodos de interfaz, propiedades y eventos del componente están disponibles.

Esto se puede conseguir de diferentes formas, pero en el nivel más bajo se encuentra una característica denominada reflexión que busca aquellos métodos definidos como públicos que empiezan por get o set, es decir, se basa en el uso de patrones de diseño, o sea, en establecer reglas en la construcción de la clase de forma que mediante el uso de una nomenclatura específica se permita a la herramienta encontrar la interfaz de un componente.

También se puede hacer uso de una clase asociada de información del componente (BeanInfo) que describe explícitamente sus características para que puedan ser reconocidas.

A veces, necesitamos almacenar el estado de una clase para que perdure a través del tiempo. A esta característica se le llama persistencia. Para implementar esto, es necesario que pueda ser almacenada en un archivo y recuperado posteriormente.

El mecanismo que implementa la persistencia se llama serialización.

Al proceso de almacenar el estado de una clase en un archivo se le llama serializar.

Al de recuperarlo después deserializar.

Todos los componentes deben persistir. Para ello, siempre desde el punto de vista Java, deben implementar los interfaces java.io.Serializable o java.io.Externalizable  que te ofrecen la posibilidad de serialización automática o de programarla según necesidad:

• Serialización Automática: el componente implementa la interfaz Serializable que proporciona serialización automática mediante la utilización de las herramientas de Java Object Serialization. Para poder usar la interfaz serializable debemos tener en cuenta lo siguiente:
  • Las clases que implementan Serializable deben tener un constructor sin argumentos que será llamado cuando un objeto sea "reconstituido" desde un fichero .ser.
  • Todos los campos excepto static y transient son serializados. Utilizaremos el modificador transient para especificar los campos que no queremos serializar, y para especificar las clases que no son serializables.
  • Se puede programar una serialización propia si es necesario implementando los siguientes métodos (las definiciones de los métodos deben ser exactas):
    • private void writeObject(java.io.ObjectOutputStream out) throws IOException;
    • private void readObject(java.io.ObjectInputStream in) throws IOExcept;

• Serialización programada: el componente implementa la interfaz Externalizable y sus dos métodos para guardar el componente con un formato específico. Características:

  • Precisa de la implementación de los métodos readExternal() y writeExternal().
  • Las clases Externalizable también deben tener un constructor sin argumentos.

En la actualidad existen diversas tecnologías para la creación de componentes visuales, además de la que hemos visto a lo largo del tema, JavaBeans implementados con NetBeans podemos encontrar otras orientaciones como los estándares COM, COM+ y DCOM de Microsoft y CORBA del Object Management Group.

En general se trata de diversas maneras de ofrecer los servicios de persistencia e introspección, para un modelo orientado a objetos de modo que se puedan crear clases reutilizables de las que se conozca su interfaz quedando oculta su implementación.

JavaBeans de Oracle

Es el estándar para crear componentes proporcionado por Oracle. Sus características más destacadas las hemos visto a lo largo de la unidad, son clases Java que implementan la interfaz Serializable y deben disponer de un constructor sin argumentos. Define como gestionar la persistencia y la introspección y soporta propiedades simples, indexadas, compartidas o restringidas, así como la gestión de eventos.

Con esta tecnología la creación de componentes visuales es realmente sencilla, basta con heredar de un control visual que ya exista, como una imagen, o una etiqueta, implementando la interfaz Serializable al mismo tiempo.

Como toda la tecnología Java es software libre.

El Modelo de Objetos Componentes de Microsoft.

Es la tecnología propuesta por Microsoft para la creación de componentes. Forman parte de ella COM, DCOM, COM+, OLE y ActiveX. Se basa en la creación de objetos que tiene una interfaz bien definida e independiente de la implementación de forma que pueden ser reutilizados sin más que conocer su interfaz en entornos distintos a aquel en el que fue creado. Usando DCOM además pueden estar distribuidos en varias máquinas, y COM+ usa un servidor de componentes denominado MTS.

La principal ventaja de estos componentes es que al estar separado su interfaz de su implementación se pueden usar desde diferentes lenguajes de programación, de hecho Java, Microsoft Visual C++, Microsoft Visual Basic, Delphi, PowerBuilder, y Micro Focus COBOL interactúan perfectamente con DCOM.

Aunque esta tecnología se ha implementado en muchas plataformas se usa fundamentalmente en Microsoft Windows siendo distribuido con licencia propietaria.

CORBA

Es un estándar definido por el Object Management Group (OMG) que permite añadir una "envoltura" a un código escrito en un determinado lenguaje con información de las capacidades que el código contiene y de sus métodos de forma que puedan ser descubiertos. Se programa en un lenguaje específico, IDL, del que existen implementaciones para diferentes lenguajes orientados a objetos, como Ada, C++, Perl, Java, SmallTalk, etc.

Una vez creado el componente, es necesario empaquetarlo para poder distribuirlo y utilizarlo después. Para ello necesitarás el paquete jar que contiene todas las clases que forman el componente:

• El propio componente
• Objetos BeanInfo
• Objetos Customizer
• Clases de utilidad o recursos que requiera el componente, etc.

Puedes incluir varios componentes en un mismo archivo.

El paquete jar debe incluir un fichero de manifiesto (con extensión .mf) que describa su contenido, por ejemplo:

En este documento encontrarás un ejemplo de archivo de manifiesto:

La forma más sencilla de generar el archivo jar es utilizar la herramienta Limpiar y construir del proyecto en NetBeans que deja el fichero .jar en el directorio /dist del proyecto, aunque siempre puedes recurrir a la orden jar y crearlo tu directamente:

jar cfm Componente.jar manifest.mf Componente.class ComponenteBeanInfo.class ClaseAuxiliar.class Imagen.png proyecto.jar

Una vez que tienes un componente Java empaquetado es muy sencillo añadirlo a la paleta de componentes gráficos de NetBeans, basta con abrir el administrador de la paleta, seleccionar la categoría dónde irá el componente (normalmente en Componentes Personalizados) y seleccionar el archivo jar correspondiente. Para acceder al administrador de la paleta, nos situamos encima de la paleta (panel en donde se encuentran definidos los componentes), pulsamos el botón derecho del ratón (menú contextual) y elegimos la opción Administrador de paleta.

Para ilustrar el proceso de elaboración de un componente usando la herramienta NetBeans, vamos a crear uno muy sencillo pero completo, en el sentido de que crea una propiedad, emplea atributos internos y genera un evento.

Se trata de un temporizador gráfico que realiza una cuenta atrás con las siguientes características:

• El componente es una etiqueta que dispone de una propiedad llamada tiempo de tipo int que representa los segundos que van a transcurrir desde que se inicia hasta que la cuenta llega a cero.
• Cada segundo disminuye en uno el valor de tiempo, que visualizamos en el texto de la etiqueta.
• Para programarlo se utiliza un atributo de tipo javax.swing.Timer, que será el que marque cuando se cambia el valor de tiempo.
• Al finalizar la cuenta atrás se lanza un evento de finalización de cuenta que puede ser recogido por la aplicación en la que se incluya el componente.

Este componente se puede utilizar, por ejemplo, en la realización de test en los que el usuario tiene que contestar una serie de preguntas en cierto tiempo.

Comenzamos creando un proyecto NetBeans nuevo de tipo Java Application. Nos aseguramos de desmarcar las opciones Crear clase principal y Configurar como proyecto principal y ponemos de nombre al proyecto ProyectoTemporizador, por ejemplo. Le podemos añadir un paquete con el nombre Temporizador.

Una vez creado el proyecto, le añadimos un archivo nuevo de tipo Componente JavaBeans (si no lo encuentras en la lista que sale en el menú contextual, haz clic en la opción Otros... para acceder al resto de tipos de archivos). Puedes llamar a la clase TemporizadorBean y se ubicará en el paquete Temporizador.

El objetivo de este componente es disponer de una etiqueta con un comportamiento específico. Puesto que ya tenemos un control con parte de la funcionalidad que nos interesa, como un método para pintar el texto con el formato adecuado ya implementado, nos serviremos de él heredando nuestra clase de JLabel, quedando la signatura de la clase así:

public class TemporizadorBean extends JLabel implements Serializable

Obviamente, tendremos que importar el paquete javax.swing.JLabel.

El proyecto cuenta con una propiedad de ejemplo que puedes eliminar (su declaración y los métodos get y set de la propiedad), así como un gestor de escuchadores de cambio de propiedades que no necesitaremos, quedando el siguiente código para empezar:

public class TemporizadorBean extends JLabel implements Serializable {
            private PropertyChangeSupport propertySupport;
            public TemporizadorBean() {
            propertySupport = new PropertyChangeSupport(this);
            }
            }

El temporizador dispone de una propiedad de lectura y escritura en la que se almacena el número de segundos que inicialmente va a durar el temporizador y que irá disminuyendo paulatinamente cada segundo, hasta llegar a cero, momento en el que se lanzará un evento.

Si bien NetBeans proporciona una ayuda especial para realizar esta tarea. Con el cursor posicionado dentro de la clase (puedes reservar una zona para el código de propiedades) haz clic con el botón secundario y selecciona la opción Insertar Código..., en la lista que te saldrá elige Agregar propiedad. Se desplegará el siguiente cuadro de diálogo en el que puedes escribir el nombre de la propiedad y su tipo, e insertar los métodos get y set de manera automática:

Crea la propiedad tiempo, de tipo int. Aunque tenemos un código añadido, será necesario modificar algo el método setTiempo, ya que cada vez que cambiemos el valor de tiempo será necesario reflejar, ese cambio, en el texto de la etiqueta y repintarla para que surta efecto, quedando su código así:

public void setTiempo(int tiempo) {
            this.tiempo = tiempo;
            setText(Integer.toString(tiempo));
            repaint();
            }

Una vez definida la propiedad y su comportamiento, tenemos que programar el comportamiento del componente. Parte de un valor inicial, que irá disminuyendo cada segundo hasta llegar a cero. Para implementar esto, usaremos un Timer, que añadiremos como atributo privado de la clase.

Un Timer se inicializa con un valor de intervalo entre acción y acción que se especifica en milisegundos, nosotros lo inicializamos a 1000 para que ejecute el método actionPerformed cada segundo. También hay que pasarle el objeto actionPerformed con el método a ejecutar, en nuestro caso, como necesitamos acceder a atributos de la etiqueta y a la propiedad tiempo, usaremos el de la propia clase. Para que la clase pueda tener el método actionPerformed tendrá que implementar la interfaz ActionListener.

A nuestra clase le añadiremos los métodos:

public final setActivo(boolean valor): contendrá el código necesario para gestionar si nuestro temporizador, objeto Timer está funcionando o no.

public boolean getActivo(): contendrá el código necesario para que nos devuelva si nuestro temporizador se está ejecutando o no.

  //Activo es en sí mismo una propiedad (sin atributo subyacente)
            //Gestiona si el temporizador está funcionado o no.
            public final void setActivo(boolean valor) {
            if (valor == true)
            t.start();
            else
            t.stop();
            }
            public boolean getActivo() {
            return t.isRunning();
            }
            

Al constructor creado sin argumentos, le vamos a añadir el código necesario para definir un objeto Timer programado cada segundo, es decir, cada 1000 milisegundos. En el constructor, inicializamos nuestro contador con el valor 5. Por lo tanto, la cuenta atrás comenzará en dicho valor. Además activamos temporizador.

El método constructor sin argumentos quedaría definido de la siguiente forma:

      public TemporizadorBean() {
            tiempo = 5; //Para que comience la cuenta atrás a los 5 segundos
            t = new Timer (1000, this); //Inicialización del objeto Timer
            setText(Integer.toString(tiempo));//Método que modifica el texto a visualizar por la etiqueta
            setActivo(true);
            }
            

A continuación, modificaremos el método actionPerformed, para que cada vez que sea invocado se disminuya nuestro contador en una unidad:

public void actionPerformed(ActionEvent e){
            setText(Integer.toString(tiempo)); //Asignamos el valor a mostrar en la
            etiqueta repaint(); //Repintamos la etiqueta tiempo--; //Disminuimos el
            valor de la variable tiempo para que vaya disminuyendo hasta 0. if(tiempo
            == 0){ //Cuando alcancemos el valor cero mostramos un aviso de Terminado.
            setActivo(false);
            JOptionPane.showMessageDialog(null, "Terminado", "Aviso",
            JOptionPane.INFORMATION_MESSAGE); } }

A continuación, puedes descargar el código necesario para definir la clase Temporizador.

Código de la clase Temporizador. (zip - 951 B)

Los componentes Java utilizan el modelo de delegación de eventos para gestionar la comunicación entre objetos como hemos visto. Para poder implementar la gestión de eventos necesitabas varias cosas:

1-. Crearemos una clase que implemente los eventos. Esta clase hereda de java.util.EventObject.

      Para continuar con nuestro ejemplo, vamos a añadir a nuestro proyecto, una nueva clase con el nombre FinCuentaAtrasEvent que herede de la clase java.util.EventObject

      El código de esta clase quedaría de la siguiente manera:

import java.util.EventObject;
            public class FinCuentaAtrasEvent extends EventObject{ public FinCuentaAtrasEvent(Object
            source) {
            super(source);
            } }

2-. Debemos de definir una interfaz que defina los métodos a usar cuando se genere el evento. Implementa java.util.EventListener.

 Para continuar con nuestro ejemplo, procederemos a añadir dentro de la clase TemporizadorBean.java una nueva interfaz con el nombre FinCuentaAtrasEvent. En este caso la gestión del evento se hará a través del método capturarFinCuentaAtras.

El código necesario para la definición de la interface sería el siguiente:

package temporizador; 
            public interface FinCuentaAtrasListener {          
            public void capturarFinCuentaAtras(FinCuentaAtrasEvent ev);            
            }

3-. Añadiremos dos métodos, addEventoListener y removeEventoListener que permitan al componente añadir oyentes y eliminarlos. En principio se deben encargar de que pueda haber varios oyentes. En nuestro caso sólo vamos a tener un oyente, pero se suele implementar para admitir a varios. Estos métodos deben de añadirse dentro de la clase que estemos utilizando para definir el componente.

   Siguiendo con nuestro ejemplo, accedemos a la clase TemporizadorBean.java. Añadiremos los métodos addFinCuentaAtrasListener y  removeFinCuentaAtrasListener. El código que debemos de añadir es el siguiente:

 public void addFinCuentaAtrasListener(FinCuentaAtrasListener receptor){
            this.receptor = receptor;
            }
            public void removeFinCuentaAtrasListener(FinCuentaAtrasListener receptor){
            this.receptor=null;
            }
            

4-. Implementar el método que lanza el evento, asegurándonos de todos los oyentes reciban el aviso. En este caso lo que se ha hecho es lanzar el método que se creó en la interfaz que describe al oyente. 

    En el ejemplo, modificaremos el método actionPerformed de la clase TemporizadorBean.java para que cuando el temporizador llegue a cero, lance el evento. El código de este método una vez que lo modifiquemos quedaría de la siguiente manera:

public void actionPerformed(ActionEvent e) { setText(Integer.toString(tiempo));
            repaint(); tiempo--; if(tiempo == 0){ setActivo(false); receptor.capturarFinCuentaAtras(
            new FinCuentaAtrasEvent(this)); } }

Finalmente el código de la clase componente queda como aparece en el siguiente enlace:

Clase TemporizadorBean.java

Una vez construido el componente es sencillo incorporarlo a la paleta de NetBeans. Podemos hacerlo de diferentes formas:

• Si lo hemos desarrollado nosotros mismos (con NetBeans) basta con utilizar Limpiar y Construir para generar el fichero .jar con el componente. Cuando esté generado desde el inspector de Proyectos basta con buscarlo y con el botón secundario seleccionar Herramientas >> Añadir a la Paleta. Se indica en que sección debe aparecer y ya lo tenemos.
• Si es un componente generado por otras personas, es preciso disponer de la distribución en un fichero .jar. E incorporarlo a la paleta desde el Administrador de la paleta (se accede con el botón secundario sobre la paleta). También en este caso se indica la sección en la que debe aparecer.

Una vez que hayas hecho esto tendrás el componente en la paleta y lo podrás añadir a un proyecto nuevo cómo cualquier otro. Esto incluye el tratamiento de las propiedades, desde el inspector de propiedades tendrás acceso a las propiedades propias de una etiqueta, y también a la propiedad tiempo definida por ti. Si la modificas verás cómo cambia el texto de la etiqueta.

Prueba el uso del temporizador en un proyecto nuevo. La ventaja de usar una herramienta cómo NetBeans es que, gracias al proceso de introspección, es capaz de detectar las propiedades, métodos y eventos del componente, por lo que es muy fácil hacer la gestión del evento de finalización de la cuenta atrás, no tienes más que hacer clic con el botón secundario sobre el componente y seleccionar eventos >> FinCuentaAtras >> CapturarFinCuentaAtras.

Se creará automáticamente una función que implementará la gestión del evento, puedes incluir este código:

private void temporizadorBean1CapturarFinCuentaAtras ( Temporizador.TemporizadorBean.FinCuentaAtrasEvent evt) {
            // TODO add your handling code here:
            JOptionPane.showMessageDialog(null, "La cuenta atrás ha terminado", "Aviso",
            JOptionPane.INFORMATION_MESSAGE);
            }

que simplemente muestra un mensaje, pero puedes gestionar cualquier otro modo de finalizar la cuenta atrás.

Si ejecutas el proyecto verás cómo al finalizar la cuenta atrás salta el mensaje de aviso.