Hola, ¿qué tal? En el post anterior lo que hicimos fue
crear una clase oyente que implementaba la interfaz ActionListener,
esta interfaz tiene un método que es actionPerformed y que
estamos obligados a programarla. Para los eventos de las ventanas tenemos que
hacer lo mismo pero en lugar de utilizar la interfaz ActionListener tenemos
que utilizar la interfaz WindowListener.
Así como la interfaz ActionListener implementaba
solo un método actionPerformed, la interfaz WindowListener implementa
estos siete métodos.
·
WindowListener
o
windowActivated(WindowEvent e)
o
windowClosed(WindowEvent e)
o
windowClosing(WindowEvent e)
o
windowDeactivated(WindowEvent e)
o
windowDeiconified(WindowEvent e)
o
windowIconified(WindowEvent e)
o
windowOpened(WindowEvent e)
Estamos obligados a implementar o construir los siete
métodos que tiene esta interfaz, veremos más adelante que Java nos da una
solución para no tener que declarar estos siete métodos, pero de momento
tenemos que construir o declarar estos métodos aunque solo vayamos a utilizar
uno.
En la API de Java podéis consultar estos métodos y
saber lo que hace cada uno.
Creamos una clase con el siguiente código:
package event;
import javax.swing.*;
import java.awt.event.*;
public class EventosVentana
{
public static void main(String[] args) {
MarcoVentana mimarco= new MarcoVentana();
mimarco.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}
class MarcoVentana
extends JFrame{
public MarcoVentana()
{
setTitle("Respondiendo");
setBounds(300, 300, 500, 150);
setVisible(true);
}
}
Este código nos ejecuta una ventana. Lo que queremos
es que produzca un evento al minimizarla.
Lo primero es crearnos una clase que implemente la
interfaz WindowListener
class M_Ventana implements WindowListener{
}
Nos da un error porque tenemos que declarar todos los
métodos de esta interfaz tanto los que vayamos a utilizar como los que no:
class M_Ventana implements WindowListener{
@Override
public void
windowOpened(WindowEvent e) {
// TODO
Auto-generated method stub
}
@Override
public void
windowClosing(WindowEvent e) {
// TODO
Auto-generated method stub
}
@Override
public void
windowClosed(WindowEvent e) {
// TODO
Auto-generated method stub
}
@Override
public void
windowIconified(WindowEvent e) {
// TODO
Auto-generated method stub
}
@Override
public void
windowDeiconified(WindowEvent e) {
// TODO
Auto-generated method stub
}
@Override
public void
windowActivated(WindowEvent e) {
// TODO
Auto-generated method stub
}
@Override
public void
windowDeactivated(WindowEvent e) {
// TODO
Auto-generated method stub
}
}
Solo vamos a utilizar uno:
public void
windowIconified(WindowEvent e)
Cuando se minimice la ventana nos salga una frase en
la consola de Java:
public void windowIconified(WindowEvent
e) {
System.out.println("Ventana
minimizada");
}
Hecho esto tenemos que indicarle al marco que esté
preparado para recibir a la clase oyente o el desencadenante del evento. Dentro
del constructor crearemos una instancia perteneciente a la clase oyente que
vamos a llamar oyente_ventana:
class MarcoVentana
extends JFrame{
public MarcoVentana()
{
setTitle("Respondiendo");
setBounds(300, 300, 500, 150);
setVisible(true);
M_Ventana oyente_ventana = new M_Ventana();
}
}
Llamamos a la clase oyente:
class MarcoVentana
extends JFrame{
public MarcoVentana()
{
setTitle("Respondiendo");
setBounds(300, 300, 500, 150);
setVisible(true);
M_Ventana oyente_ventana = new M_Ventana();
addWindowListener(oyente_ventana);
}
}
Probamos:
Al minimizar la ventana en la consola nos aparece lo
que hemos programado en el método:
Probamos los demás métodos, para cuando la ventana
este activa:
public void
windowActivated(WindowEvent e) {
System.out.println("Ventana
activa");
}
El método windoClosing() que se
ejecuta cuando pulsamos el botón de cerrar de la ventana:
public void
windowClosing(WindowEvent e) {
System.out.println("Cerrando
ventana");
}
El método windowDeactivated() se
ejecuta cuando la ventana esta desactivada, es decir, tenemos varias ventanas y
se activa otra que no es está.
public void
windowDeactivated(WindowEvent e) {
System.out.println("Ventana
desactivada");
}
El método windowDeiconified() cuando
restauramos la ventana:
public void
windowDeiconified(WindowEvent e) {
System.out.println("Ventana
restaurada");
}
Cuando abrimos la ventana utilizamos el método windowOpened():
public void
windowOpened(WindowEvent e) {
System.out.println("Abriendo
ventana");
}
Si probamos la aplicación vemos como nos aparece en la
consola todos los movimientos que hagamos con la ventana, si está activa, si la
cerramos, si la abrimos…
El método windowClosed().
Hasta ahora en todos los marcos que hemos creado le
hemos dicho que por defecto lo que tiene que hacer el programa cuando cerramos
el marco es finalizar el mismo.
mimarco.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
Esto quiere decir que cuando pulsamos la X de la barra
de título del marco se cierra la ventana y deja de ejecutarse. En su día cuando
se explicó la constante de clase EXIT_ON_CLOSE vimos que había
muchas más que podía hacer que el programa no finalizara, esto no se va a
entender bien hasta que no tengamos otro marco creado, para ello vamos a
crearnos otro marco. Nos creamos una nueva instancia del marco que ya tenemos
creado:
MarcoVentana mimarco2= new MarcoVentana();
mimarco2.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
Y a cada ventana le vamos a dar un título y un tamaño
diferente:
mimarco.setTitle("Ventana
1");
mimarco.setBounds(300,
300, 500, 150);
mimarco2.setTitle("Ventana
2");
mimarco2.setBounds(375,
300, 525, 150);
Por lo que en el constructor el método setTitle() y setBounds() los
comentamos.
Si ejecutamos la aplicación al cerrar una de las dos
ventanas como hemos indicado la constante de clase EXIT_ON_CLOSE la
otra también se va a cerrar. Para evitar esto existe una constante de
clase DISPOSE_ON_CLASE, si en el código indicamos lo siguiente:
MarcoVentana mimarco= new MarcoVentana();
mimarco.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
MarcoVentana mimarco2= new MarcoVentana();
mimarco2.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
Si probamos la aplicación, aparecen las dos ventanas.
Cuando se cierre la ventana 2 seguirá el programa en ejecución hasta que no se
cierre la ventana 1 no finalizará la aplicación.
En el método windowClosed() añadimos
un System.out para comprobar que la segunda ventana cuando se
cierra se sigue ejecutando el programa:
public void
windowClosed(WindowEvent e) {
System.out.println("La
ventana ha sido cerrada");
}
Probamos:
Cerramos la Ventana 2 se ejecuta el método windowClosed lo
podemos ver que sale por consola lo que hemos escrito dentro del System.out de
este método:
Esto sería el funcionamiento del método windowClosed().
Hemos visto que es bastante laborioso
programar eventos de ventana por la interfaz WindowListener() ya que implementa
un montón de métodos y nos obliga programar todos los métodos. Existe una
solución en Java que consiste en el uso de Clases Adaptadoras (Adapter
Classes), es una solución para que el código sea más corto y más limpio.
Como ya hemos visto la interfaz WindowListener() trae todos
estos métodos y tenemos la obligación de programarlos:
Para evitar programar todos estos métodos se
utiliza las clases adaptadoras:
Cada clase implementa una serie de
interfaces, la primera característica de estas clases es que empiezan todas con
el evento y todas terminan con la palabra Adapter. La que vamos a
utilizar es WindowAdapter que responde a eventos de ventana,
las demás clases MouseAdapter que responde a eventos del ratón
y KeyAdapter que responde a eventos de teclado las veremos más
adelante. Son útiles para interfaces que tienen varios métodos, si contienen
uno o dos pues no es necesario. Podéis obtener más información en la API de Java.
Si volvemos a la práctica del apartado
anterior, la clase M_Ventana implementaba la interfaz WindowListener que
obligaba a programar todos los métodos, si no programamos alguno de ellos la
clase nos daba un error. Si en lugar de implementar la interfaz WindowListener hacemos
que la clase M_Ventana herede o extienda de la clase WindowAdapter nos
evitamos programar todos los métodos, solo programaremos los que vamos a
utilizar:
class M_Ventana extends WindowAdapter{
public void
windowIconified(WindowEvent e) {
System.out.println("Ventana
minimizada");
}
}
Se puede simplificar un poco más utilizando
el método WindowListener para preparar el marco para que esté
a la escucha de los eventos que puedan surgir, a la hora de indicarle la
instancia de la clase oyente lo que podemos hacer es instanciarla directamente
en los parámetros de addWindowListener():
public MarcoVentana()
{
//setTitle("Respondiendo");
//setBounds(300, 300, 500,
150);
setVisible(true);
//M_Ventana oyente_ventana =
new M_Ventana();
//addWindowListener(oyente_ventana);
addWindowListener(new
M_Ventana());
}
Esto ha sido todo en cuanto a los
eventos de ventana, cualquier duda podéis hacerlo a través de los comentarios
del blog y entre todos ayudarnos. Un saludo!
5.1 INTRODUCCIÓN A LOS EVENTOS
<< >> 5.2.1 Cambios de estado de la ventana
No hay comentarios:
Publicar un comentario