Clases contra Interfaces
¿Qué signigfica implements ActionListener?
Cuando escribimos implements ActionListener en nuestra declaración de clase, nos comprometemos a implementar, o proporcionar el código, para cualquier método declarado en el interface ActionListener. En otras palabras, cualquier método declarado en ActionListener tiene que ser definido en nuestra clase, la clase que implementa ActionListener. Todo esto se explica abajo.
Classes contra Interfaces
Las clases son plantillas de objetos. Definen el tipo de objetos que datos que contendrá y los métodos para operar con esos datos. Un ejemplar de esa clase es la plantilla rellena con los datos y las llamadas a los métodos-- el ejemplar es el objeto.
Podemos crear muchos ejemplares de la misma clase, creando mucho objetos de ese tipo. Cada objeto tiene sus propios datos, y algunos objetos comparten datos específicos, dependiendo de si han sido declarados datos static o instance.
No tenemos que escribir una clase desde el principio. Si ya existe una clase que tiene características similares a la que queremos crear, podemos Usar la palabra clave extends para heredar campos y métodos desde otra clase. Luego añadimos mas campos y métodos para crear una clase más rica que la clase padre. Pero no tenemos que conformarnos con los campos o métodos heredados. Podemos sobreescribir métodos, u ocultar datos de las clase padre para cumplir con nuestras necesidades.
Esto es cierto para clases concretas, pero no para los interfaces.
Los interfaces declaran métodos, y posiblemente campos estáticos, pero no definen métodos. En su lugar, los interfaces sólo declaran los métodos sin ninguna instrucción dentro de ellos. En otras palabras, los interfaces son como plantillas que siempre serán plantillas. No podemos ejemplarizar un interface para crear un objeto. Son como clases sin implementación. ¿Entonces por qué existen?
Sirven para un propósito: para forzar al desarrollador a proporcionar esos métodos, con detalles, en la clase que implements el interface. En otras palabras, implementar un interface significa que estamos haciendo la promesa de usar ciertos métodos, pero nosotros, los desarrolladores, definimos los detalles de esos métodos.
¿Por qué es esto útil o necesario?
Supongamos que tenemos un equipo de desarrolladores que están creando clases para hacer diferentes tipos de objetos animales.Todos esos animales van a tener dos cosas en común:
- Usan alguna foma de locomoción.
- Comen alguna clase de comida.
La diferencia entre los animales está en cómo se mueven y qué y cómo comen. En otras palabras, cada uno necesita tener los métodos locomotion() y eat(), pero cada individuo, cada clase animal, define los detalles de esos métodos separadametne basándose en las necesidades de las especies de animales.
Diseñamos un interface para asegurarnos de que cada objeto animal hace ciertas cosas, y nuestro equipo desarrolla clases como ésta:
En el interface Animal, los métodos están declarados, pero no definidos. Observa que esos métodos (en azul) están definidos en clases concretas Shark y Dog. En el ejemplo de arriba, cada método imprime una línea de texto, indicando lo que come el animal y como se mueve desde un lugar a otro. La última clase es una aplicación que inicializa las dos clases concretas Shark y Dog, y llama a los métodos de esas clases, usando el operador punto.
Cuando compilamos y ejecutamos AnimalTest, obtenemos el siguiente resultado:
I swim.
I hunt for seals.
I run on four legs.
I eat kibble.
Los juegos son otro ejemplo de cómo podríamos implementar interfaces. Por ejemplo, podríamos diseñar los siguientes juegos: Water
Pistol Wars, Asteroid Archery, Rubberband Rally, y Cannon Craze. Todos implican armas de fuego, pero las armas y lo que disparan son diferentes. Un interface se podría asegurar de que todo juego implemente un método fire(), pero es cosa de cada diseñador del juego la forma de disparar y el tipo de munición utilizada.
Manejo de Eventos Básico
El API Java tiene muchos interfaces que podemos implementar. Para programación GUI, un interface se asegura de que proporcionamos alguna funcionalidad en un método específico. Para hacer el Dive Log interactivo y hacer algo con el texto introducido en los campos de texto, necesitamos implementar el interface ActionListener y manejar los eventos.
Antes de entrar en detalles sobre el interface ActionListener y alguna de sus subclases, necesitamos entender lo básico sobre el manejo de eventos.
Los eventos son objetos que un usuario inicia, como un texto introducido, un botón pulsado, o un movimiento del ratón sobre un componente. El componente listen (escucha) un evento si quiere handle (manejar) el evento con una acción, como mostar el texto o escribir en una base de datos. Crear una clase dirigida por eventos tiene tres pasos:
- Decidir qué tipo de eventos dispara un componente, e implementar el interface correcto.
- Registrar el componente como un un oyente para ese tipo de evento.
- Implementar los métodos manejadores del interface.
Cuando un usuario dispara un evento a través de un componente GUI, se hace una llamada a un método de cualquier objeto que haya sido registrado con el componente como oyente del tipo de evento que tuvo lugar. Un oyente de eventos es un objeto al que se le notifica cuando ocurre un evento. Diez categorías de eventos GUI representan una clase diferente.
Para crear la clase Diver, sólo necesitamos conocer los siguientes oyentes de eventos e interfaces:
| Event Class |
Interface Listener |
Handler Methods |
| ActionEvent |
ActionListener |
actionPerformed(ActionEvent) |
| ItemEvent |
ItemListener |
itemStateChanged(ItemEvent) |
Los interfaces listener y las clases event están en el paquete java.awt.AWTEvent, por eso debemos importar este paquete para usarlos.
| Sigue estos pasos... |
- Abre el fichero Diver.java en tu editor de texto.
- Añade la siguiente sentencia import en la parte superior del fichero:
import java.awt.event.*;
- Graba el fichero.
|
Los eventos generados por botones y campos de texto necesitan que la clase implemente el interface ActionListener, lo que hemos hecho para la clase Diver. Luego, necesitamos registrar los componentes que queremos que escuchen estos eventos con el método addActionListener, que toma un objeto evento como un argumento. Los métodos de registro se llaman addxxxListener, donde xxx es el tipo de interface implementado. Por ejemplo, para registrar un campo de texto para escuchar eventos, usamos lo siguiente:
JTextfield textfield1 = new JTextfield();
textfield1.addActionListener( this );
La palabra clave this se refiere a esta clase, siendo la clase Diver, la que implements el interface apropiado. Una vez que la clase implementa un ActionListener, y hemos llamado al método addxxxListener sobre el objeto de entrada del que queremos escuchar eventos, podemos definir el método que debemos implementar del interface ActionListener.
Recuerda que como ActionListener es un interface, nos hemos comprometido a implementar sus métodos. La documentación revela sólo un método que necesitamos definir:
public void actionPerformed(ActionEvent e)
Este método es invocado cuando ocurre un evento, como una pulsación de ratón o de la tecla return. Definimos lo que queremos que suceda dentro de este método, si se muestra el texto, se escriben ficheros, o alguna otra acción.
La imagen de arriba muestra el proceso de manejo de eventos para un campo de texto.
| Sigue estos pasos... |
- Abre el fichero Diver.java en tu editor de texto.
- Registra los componentes de campo de texto como oyentes del método addActionListener. Pasa la palabra clave this como un parámetro para que el compilador sepa como buscar en esta clase el método que maneja estos eventos. Añade lo siguiente al método buildAddressPanel, justo antes del corchete de cierre:
//Listeners for each text field in the
name.addActionListener( this );
street.addActionListener( this );
city.addActionListener( this );
statezip.addActionListener( this );
- Graba el fichero.
Tu fichero Diver.java se debería parecer a este ejemplo
|
Luego, escribimos el método que construye el panel emerg. Construirmos este método buildEmergencyPanel como lo hemos hecho con los otros dos:
| Sigue estos pasos... |
- Crea un ejemplar de un JPanel:
emerg = new JPanel();
- Selecciona el controlador de distribución y el color de fondo:
emerg.setLayout( new GridLayout(2, 4, 20, 0) );
emerg.setBackground(Color.white);
- añade todos los objetos (labels, text fields, y buttons) al panel:
emerg.add(lnname);
emerg.add(nname);
emerg.add(lphone);
emerg.add(phone);
emerg.add(lrel);
emerg.add(rel);
emerg.add(enter);
emerg.add(edit);
- Crea un borde para cada botón en el panel:
emerg.setBorder(BorderFactory.createTitledBorder("Emergency"));
edit.setBorder(BorderFactory.createRaisedBevelBorder());
- Registra los campos de texto con los oyentes apropiados:
nname.addActionListener( this );
phone.addActionListener( this );
rel.addActionListener( this );
- Registra los botones con los oyentes apropiados:
enter.addActionListener( this );
edit.addActionListener( this );
Tu método buildEmergencyPanel se debería parecer a este ejemplo
|
El método buildTrainingPanel que necesitamos construir luego usa check boxes en lugar de campos de texto. Cada check box se contruye con texto, por eso necesitamos crear etiquetas.
La distribución de este panel hace uso de una simple parrilla que consta de 1 columna y 6 filas. Este ejemplo también suministra una separación de 10 y 20 respectivamente.
El manejo de eventos de los Check box requiere que implementemos el interface ItemListener. Por eso para reistar los check boxes como fuentes de eventos, añadimos un oyente llamando la método addItemListener.
En lugar de usar la palabra clave this como parámetro en el método addItemListener para decirle que busque en esta clase las instrucciones para ver cómo manejar estos eventos, le decimos que busque en la referencia de variable handler.
Recuerda añadir este trozo de código en la parte superior de la clase Diver:
// Class to handle functionality of check boxes
ItemListener handler = new CheckBoxHandler();
Cuando crees otra clase que maneje la funcionalidad de los objetos, nombra la clase como parámetro en el método addItemListener. Aprenderemos más sobre las clases internas más adelante.
Para registrar un oyente con el objeto ow, escribimos lo siguiente:
ow.addItemListener(handler);
Cuando especificamos que la instrucción está en esta(this) clase, o proporcionmos el nombre de una clase, revelamos donde está localizado el método prometido. Recuerda, para la funcionalidad del manejo de eventos, implementamos ciertos interfaces. Haciendo esto, nos comprometemos a proporcionar la implementación, o los detalles, de los métodos declarados en ese interface. Las instrucciones están especificamente encerradas en esos métodos que prometimos proporcionar.
La clase Diver implementa el interface ActionListener. Por lo tanto, la clase this debe implementar el método actionPerformed(ActionEvent e). Cuando ocurre un evento, se llama automáticamente a actionPerformed porque registramos el objeto llamando a addTypeListener.
La clase Diver no implementa el interface ItemListener. En su lugar, la clase interna implementa el interface ItemListener y su implementación de método requerida.
| Sigue estos pasos... |
- Completa el buildTrainingPanel en el fichero Diver.java:
- Crea un ejemplar de un JPanel:
training = new JPanel();
- Selecciona el controlador de distribución y el color de fondo, usando el controlador GridLayout:
training.setBackground(Color.white);
training.setLayout(new GridLayout(5, 1, 10, 20 ) );
- Añade todos los objetos check box al panel, y selecciona el color de fondo a blanco:
training.add(ow).setBackground(Color.white);
training.add(a).setBackground(Color.white);
training.add(un).setBackground(Color.white);
training.add(res).setBackground(Color.white);
training.add(w).setBackground(Color.white);
- Crea un borde para el panel:
training.setBorder(
BorderFactory.createTitledBorder("Training"));
- Registra los objetos check box con el método oyente apropiado, suministrando la referencia a variable handler como parámetro:
ow.addItemListener(handler);
a.addItemListener(handler);
un.addItemListener(handler);
res.addItemListener(handler);
w.addItemListener(handler);
Tu clase Diver se debería parecer a este ejemplo.
|
Hasta ahora hemos hecho esto en la clase Diver:
- Implementado el interface ActionListener.
- Declarado variables para objetos.
- Ejemplarizado esos objetos en el constructor de la clase.
- Escrito métodos para crear panales que contienen los objetos GUI.
- Registrado algunos de esos objetos como fuentes de eventos.
Ahora, necesitamos proporcionar la instrucción para que suceda algo cuando un usuario pulsa Return o pulsa el botón Enter dentro del método que prometimos implementar.
| ¿Qué método define los detalles de la funcionalidad de la pulsación de Return o del botón Enter? |
|
|
Tutoriales
