2019

Tema 5
EVENTOS
STUDIUM
 Programación

5.1 Introducción
En el anterior tema hemos visto todas las herramientas necesarias para diseñar nuestros
interfaces gráficos de usuario con elementos como Frames, Buttons, Labels, TextFields,
etcétera.

Pero eran elementos “muertos”, que no respondían a nuestros órdenes. Ahora le vamos
a dar vida a través de los “Eventos”.

Para avanzar un paso más, se resumen a continuación los pasos que se pueden seguir
para construir una aplicación orientada a eventos sencilla, con interface gráfica de
usuario:
1. Determinar los componentes que van a constituir la interface de usuario
(botones, cajas de texto, menús, etc.).
2. Crear una clase para la aplicación que contenga la función main().
3. La función main() deberá crear un objeto de la clase Ventana (en el que se van
a introducir las componentes seleccionadas) y mostrarla por pantalla con el
tamaño y posición adecuados.
4. Añadir al objeto Ventana todos los componentes y menús que deba contener.
Se puede hacer en el constructor de la ventana o en el propio método main().
5. Definir los objetos Listener (objetos que se ocuparán de responder a los eventos,
cuyas clases implementan las distintas interfaces Listener) para cada uno de los
eventos que deban estar soportados. En aplicaciones pequeñas, el propio objeto
Ventana se puede ocupar de responder a los eventos de sus componentes. En
programas más grandes se puede crear uno o más objetos de clases especiales
para ocuparse de los eventos.
6. Finalmente, se deben implementar los métodos de las interfaces Listener que se
vayan a hacer cargo de la gestión de los eventos.

En este capítulo nos centraremos en esta sexta parte (y un poco en la quinta). Aquí
aprenderemos a dar “vida” a nuestras aplicaciones de forma que respondan a órdenes.

Toda gira en torno a los eventos. Un evento, según la Real Academia de la Lengua es un
“Acaecimiento. Eventualidad, hecho imprevisto, o que puede acaecer.” Es decir, algo que
puede ocurrir, suceder, acaecer, ... en nuestra aplicación. ¿Y qué eventos pueden ocurrir
en nuestras aplicaciones? Pues desde errores, hasta pulsaciones del ratón en ciertos
botones o partes de la ventana, selecciones de opciones, escritura de texto, ... Por
ejemplo, nuestras aplicaciones deben cerrarse al pulsar sobre el icono de la Barra de
Título que tiene dicho fin:

Pues bien, para que nuestras aplicaciones puedan reaccionar ante las acciones del
usuario, o de otro programa, o del sistema, ... debemos realizar lo que hemos llamado la
Gestión de los Eventos. Cada componente tiene una serie de eventos ante los que
responde. Esos eventos, cuando se producen, son “escuchados” por unas clases

Página 1 de 45
 Programación

especiales llamadas “Escuchadores” o “Listeners” cuyo código contendrá las acciones a

realizar cuando se produzca el evento en cuestión. Es una especie de acción – reacción
o evento – respuesta.

Los Listeners son clases Abstracta ya declaradas. Nuestra labor será la de implementar
los procedimientos de los Listeners que nos sirvan en cada momento de forma que
nuestra aplicación haga lo que se le haya programado en el momento en que se haya
dispuesto. Por ejemplo, que se envíe un documento a la impresora al pulsar un botón.
Dicho botón tendrá un Listener a la espera de que sea pulsado. En ese momento se
ejecutará el código asignado al evento relacionado con dicho Listener.

5.2 Interfaces Listener

Una vez vistos los distintos eventos que se pueden producir, conviene ver cómo se deben
gestionar estos eventos. A continuación, se detalla cómo se gestionan los eventos según
el modelo de JAVA:

1. Cada objeto que puede recibir un evento (event source), “registra” uno o más objetos
para que los gestionen (event listener). Esto se hace con un método que tiene la forma,
eventSourceObject.addEventListener(eventListenerObject);

donde eventSourceObject es el objeto (Componente) en el que se produce el evento, y

eventListenerObject es el objeto (Listener) que deberá gestionar los eventos. La relación
entre ambos se establece a través de una interface Listener que la clase del
eventListenerObject debe implementar. Esta interface proporciona la declaración de los
métodos que serán llamados cuando se produzca el evento. La interface a implementar
depende del tipo de evento.

Es importante observar la correspondencia entre eventos e interfaces Listener. Cada

evento tiene su interface, excepto el ratón que tiene dos interfaces MouseListener y
MouseMotionListener. La razón de esta duplicidad de interfaces se encuentra en la
peculiaridad de los eventos que se producen cuando el ratón se mueve. Estos eventos,
que se producen con muchísima más frecuencia que los simples clicks, por razones de
eficiencia son gestionados por una interface especial: MouseMotionListener.

Obsérvese que el nombre de la interface coincide con el nombre del evento, sustituyendo
la palabra Event por Listener.

2. Una vez registrado el objeto que gestionará el evento, perteneciente a una clase que
implemente la correspondiente interface Listener, se deben definir los métodos de dicha
interface. Siempre hay que definir todos los métodos de la interface, aunque algunos de
dichos métodos puedan estar “vacíos”.

Página 2 de 45
 Programación

5.3 Clases Adapter

JAVA proporciona ayudas para definir los métodos declarados en las interfaces Listener.
Una de estas ayudas son las clases Adapter, que existen para cada una de las interfaces
Listener que tienen más de un método. Su nombre se construye a partir del nombre de
la interface, sustituyendo la palabra “Listener” por “Adapter”. Hay 7 clases Adapter:
ComponentAdapter, ContainerAdapter, FocusAdapter, KeyAdapter, MouseAdapter,
MouseMotionAdapter y WindowAdapter.

Las clases Adapter derivan de Object, y son clases predefinidas que contienen
definiciones vacías para todos los métodos de la interface. Para crear un objeto que
responda al evento, en vez de crear una clase que implemente la interface Listener, basta
crear una clase que derive de la clase Adapter correspondiente, y redefina sólo los
métodos de interés.

5.4 Eventos asociados a Componentes y sus Listeners

correspondientes
En este apartado veremos detalladamente, y con ejemplos (finalizando los que dejamos
sin acabar en el Capítulo anterior) la forma de interactuar que tienen los componentes
con el usuario y cómo debemos programarlos para que reaccionen de la forma en que
nos interese.

Los Eventos tienen la siguiente jerarquía:

Página 3 de 45
 Programación

En la tabla que mostramos a continuación se trata de explicar los eventos generales y

sus métodos comunes.
Evento Método Explicación
ActionEvent boolean equals (Object o) Compara la etiqueta del objeto que produjo el
evento con el objeto o indicado
String getActionCommand() Obtiene el texto asociado con la acción que
provocó el evento
void setActionCommand(String a) Establecer un texto asociado.
AdjustmentEvent int getValue() Devuelve el valor después de cambiar
ComponentEvent Object getSource() Devuelve una referencia al objeto que generó el
evento
Component getComponent() Devuelve el componente que generó el evento

ContainerEvent Component getChild() Devuelve el componente añadido o eliminado

Container getContainer() Devuelve el contenedor que generó el evento
FocusEvent
ItemEvent Object getSource() Devuelve una referencia al objeto que generó el
evento
KeyEvent int getKeyChar() Obtiene el carácter Unicode asociado al evento
int getKeyCode() Obtiene el VKC de la tecla pulsada o soltada
boolean isActionKey() Indica si la tecla del evento es una ActionKey
(Inicio, Fin, ...)
String getKeyText(int keyCode) Devuelve un String que describe el VKC, tal
como “Inicio”, “Fin”,...
String getKeyModifiersText(int Devuelve un String que describe las teclas
modificadores) modificadoras, tales como “Shift”, “Ctrl+Shift”
MouseEvent int getClickCount() Devuelve el número de veces que se ha pulsado
sobre el componente
int getX() Devuelve la coordenada X donde se pulsó
int getY() Devuelve la coordenada Y donde se pulsó
MouseMoved() Indica si el ratón se ha movido o no
MouseDragged() Indica si se está arrastrando algún componente
TextEvent Object getSource() Devuelve una referencia al objeto que generó el
evento
WindowEvent Window getWindow() Devuelve la ventana que generó el evento

A continuación, explicaremos cada uno de los eventos, en qué consisten, dónde se

pueden producir y qué Listener tiene asociado.

Página 4 de 45
 Programación

Se muestran las tablas con los eventos que se pueden producir sobre los diferentes
componentes, lo que significan, los Listeners asociados que tenemos que implementar
para poder tratar dichos eventos y los métodos con que cuentan dichos Listeners.

Button
Eventos Generados Significado Listener Métodos del Listener
ActionEvent Pulsar sobre el ActionListener actionPerformed()
componente con el
ratón
ComponentEvent Mover, cambiar el ComponentListener componentHidden(),
tamaño, mostrar u componentMoved(),
ocultar el componente componentResized(),
componentShown()
FocusEvent Obtener o perder el FocusListener focusGained(), focusLost()
foco
KeyEvent Pulsar o soltar una KeyListener keyPressed(), keyReleased(),
tecla keyTyped()
MouseEvent Pulsar o soltar un MouseListener mouseClicked(),
botón del ratón; entrar mouseEntered(),
o salir de un mouseExited(),
componente; mousePressed(),
(tener en cuenta que mouseReleased()
este evento tiene dos
Listener)
MouseMotionEvent Mover o arrastrar el MouseMotionListener mouseDragged(),
ratón mouseMoved()

Página 5 de 45
 Programación

Canvas
Eventos Generados Significado Listener Métodos del Listener
ComponentEvent Mover, cambiar el tamaño, ComponentListener componentHidden(),
mostrar u ocultar el componentMoved(),
componente componentResized(),
componentShown()
FocusEvent Obtener o perder el foco FocusListener focusGained(),
focusLost()
KeyEvent Pulsar o soltar una tecla KeyListener keyPressed(),
keyReleased(),
keyTyped()
MouseEvent Pulsar o soltar un botón MouseListener mouseClicked(),
del ratón; entrar o salir de mouseEntered(),
un componente; mouseExited(),
(tener en cuenta que este mousePressed(),
evento tiene dos Listener) mouseReleased()
MouseMotionEvent Mover o arrastrar el ratón MouseMotionListener mouseDragged(),
mouseMoved()

Página 6 de 45
 Programación

Checkbox
Eventos Generados Significado Listener Métodos del Listener
ComponentEvent Mover, cambiar el ComponentListener componentHidden(),
tamaño, mostrar u componentMoved(),
ocultar el componentResized(),
componente componentShown()
FocusEvent Obtener o perder el FocusListener focusGained(), focusLost()
foco
ItemEvent Seleccionar o ItemListener itemStateChanged()
deseleccionar un
elemento
KeyEvent Pulsar o soltar una KeyListener keyPressed(), keyReleased(),
tecla keyTyped()
MouseEvent Pulsar o soltar un MouseListener mouseClicked(),
botón del ratón; mouseEntered(),
entrar o salir de un mouseExited(),
componente; mousePressed(),
(tener en cuenta que mouseReleased()
este evento tiene dos
Listener)
MouseMotionEvent Mover o arrastrar el MouseMotionListener mouseDragged(),
ratón mouseMoved()
CheckboxMenuItem
Eventos Generados Significado Listener Métodos del Listener
ItemEvent Seleccionar o deseleccionar ItemListener itemStateChanged()
un elemento

Choice
Idéntica tabla al CheckBox

Component
Idéntica tabla al Canvas

Página 7 de 45
 Programación

Container
Eventos Generados Significado Listener Métodos del Listener
ComponentEvent Mover, cambiar el ComponentListener componentHidden(),
tamaño, mostrar u componentMoved(),
ocultar el componentResized(),
componente componentShown()
ContainerEvent Añadir o eliminar un ContainerListener componentAdded(),
componente a un componentRemoved()
contenedor
FocusEvent Obtener o perder el FocusListener focusGained(), focusLost()
foco
KeyEvent Pulsar o soltar una KeyListener keyPressed(), keyReleased(),
tecla keyTyped()
MouseEvent Pulsar o soltar un MouseListener mouseClicked(),
botón del ratón; mouseEntered(),
entrar o salir de un mouseExited(),
componente; mousePressed(),
(tener en cuenta mouseReleased()
que este evento
tiene dos Listener)
MouseMotionEvent Mover o arrastrar el MouseMotionListener mouseDragged(),
ratón mouseMoved()

Página 8 de 45
 Programación

Dialog
Eventos Generados Significado Listener Métodos del Listener
ComponentEvent Mover, cambiar el ComponentListener componentHidden(),
tamaño, mostrar u componentMoved(),
ocultar el componente componentResized(),
componentShown()
ContainerEvent Añadir o eliminar un ContainerListener componentAdded(),
componente a un componentRemoved()
contenedor
FocusEvent Obtener o perder el FocusListener focusGained(), focusLost()
foco
KeyEvent Pulsar o soltar una KeyListener keyPressed(), keyReleased(),
tecla keyTyped()
MouseEvent Pulsar o soltar un MouseListener mouseClicked(),
botón del ratón; entrar mouseEntered(),
o salir de un mouseExited(),
componente; mousePressed(),
(tener en cuenta que mouseReleased()
este evento tiene dos
Listener)
MouseMotionEvent Mover o arrastrar el MouseMotionListener mouseDragged(),
ratón mouseMoved()
WindowEvent Acciones sobre WindowListener windowActivated(),
ventanas: abrir, cerrar, windowDeactivated(),
iconizar, restablecer e windowClosed(),
iniciar el cierre windowClosing(),
windowIconified(),
windowDeiconified(),
windowOpened()
Frame
Idéntica tabla al Dialog

Label
Idéntica tabla al Canvas

Página 9 de 45
 Programación

List
Eventos Generados Significado Listener Métodos del Listener
ActionEvent Pulsar sobre el ActionListener actionPerformed()
componente con el
ratón
ComponentEvent Mover, cambiar el ComponentListener componentHidden(),
tamaño, mostrar u componentMoved(),
ocultar el componentResized(),
componente componentShown()
FocusEvent Obtener o perder el FocusListener focusGained(), focusLost()
foco
ItemEvent Seleccionar o ItemListener itemStateChanged()
deseleccionar un
elemento
KeyEvent Pulsar o soltar una KeyListener keyPressed(), keyReleased(),
tecla keyTyped()
MouseEvent Pulsar o soltar un MouseListener mouseClicked(),
botón del ratón; mouseEntered(),
entrar o salir de un mouseExited(),
componente; mousePressed(),
mouseReleased()
MouseMotionEvent Mover o arrastrar el MouseMotionListener mouseDragged(),
ratón mouseMoved()
MenuItem
Eventos Generados Significado Listener Métodos del Listener
ActionEvent Pulsar sobre el componente con el ActionListener actionPerformed()
ratón

Panel
Idéntica tabla al Container

Página 10 de 45
 Programación

Scrollbar
Eventos Generados Significado Listener Métodos del Listener
AdjustmentEvent Cambiar el valor del AdjustmentListener adjustmentValueChanged()
Scrollbar
ComponentEvent Mover, cambiar el ComponentListener componentHidden(),
tamaño, mostrar u componentMoved(),
ocultar el componentResized(),
componente componentShown()
FocusEvent Obtener o perder el FocusListener focusGained(), focusLost()
foco
KeyEvent Pulsar o soltar una KeyListener keyPressed(), keyReleased(),
tecla keyTyped()
MouseEvent Pulsar o soltar un MouseListener mouseClicked(), mouseEntered(),
botón del ratón; mouseExited(), mousePressed(),
entrar o salir de un mouseReleased()
componente;
(tener en cuenta que
este evento tiene
dos Listener)
MouseMotionEvent Mover o arrastrar el MouseMotionListener mouseDragged(),
ratón mouseMoved()

TextArea
Eventos Generados Significado Listener Métodos del Listener
ComponentEvent Mover, cambiar el tamaño, ComponentListener componentHidden(),
mostrar u ocultar el componentMoved(),
componente componentResized(),
componentShown()
FocusEvent Obtener o perder el foco FocusListener focusGained(),
focusLost()
KeyEvent Pulsar o soltar una tecla KeyListener keyPressed(),
keyReleased(),
keyTyped()
MouseEvent Pulsar o soltar un botón MouseListener mouseClicked(),
del ratón; entrar o salir de mouseEntered(),
un componente; mouseExited(),
(tener en cuenta que este mousePressed(),
evento tiene dos Listener) mouseReleased()
MouseMotionEvent Mover o arrastrar el ratón MouseMotionListener mouseDragged(),
mouseMoved()
TextEvent Cambiar el texto TextListener textValueChanged()

Página 11 de 45
 Programación

TextField
Eventos Generados Significado Listener Métodos del Listener
ActionEvent Pulsar sobre el ActionListener actionPerformed()
componente con el
ratón
ComponentEvent Mover, cambiar el ComponentListener componentHidden(),
tamaño, mostrar u componentMoved(),
ocultar el componentResized(),
componente componentShown()
FocusEvent Obtener o perder FocusListener focusGained(), focusLost()
el foco
KeyEvent Pulsar o soltar una KeyListener keyPressed(), keyReleased(),
tecla keyTyped()
MouseEvent Pulsar o soltar un MouseListener mouseClicked(),
botón del ratón; mouseEntered(),
entrar o salir de un mouseExited(),
componente; mousePressed(),
(tener en cuenta mouseReleased()
que este evento
tiene dos Listener)
MouseMotionEvent Mover o arrastrar MouseMotionListener mouseDragged(),
el ratón mouseMoved()
TextEvent Cambiar el texto TextListener textValueChanged()
Window
Idéntica tabla a Dialog

Hasta aquí las tablas con todos los Componentes, Eventos, Listeners y Métodos de éstos.
En el apartado siguiente, veremos unos ejemplos para aclarar la forma de programar
nuestras aplicaciones gestionando los eventos.

Página 12 de 45
 Programación

5.5 Ejemplos de gestión de eventos

Empezaremos por un ejemplo sencillo. Crearemos una ventana que responda al evento
de pulsar sobre el botón de cerrar de la barra de título. Comentaremos las instrucciones
nuevas (en negrita) que vayan apareciendo para aclarar los conceptos con respecto a
los mismos ejemplos del tema anterior.
package es.studium.EventoCerrar;

import java.awt.*;
//Tenemos que importar la clase event que contiene a los Listeners
import java.awt.event.*;

//Declaramos nuestra clase que hereda de Frame e implementa //WindowListener

public class EventoCerrar extends Frame implements WindowListener
{
private static final long serialVersionUID = 1L;
public EventoCerrar()
{
setTitle("Ventana que se cierra");
setSize(300,100);
//Añadir el Listener a la ventana
addWindowListener(this);
setVisible(true);
}

public static void main(String[] args)

{
new EventoCerrar();
}

//A continuación debemos colocar TODOS los métodos de la clase

//abstracta WindowListener, aunque solamente vayamos a trabajar
//con el método windowClosing()
public void windowActivated(WindowEvent we) {}
public void windowClosed(WindowEvent we) {}
public void windowClosing(WindowEvent we)
{
//Llamamos al método exit de la clase System,
//devolviendo como código de salida un 0
System.exit(0);
}
public void windowDeactivated(WindowEvent we) {}

Página 13 de 45
 Programación

public void windowDeiconified(WindowEvent we) {}

public void windowIconified(WindowEvent we) {}
public void windowOpened(WindowEvent we) {}
}
//Fin de la clase EventoCerrar

Ahora, si ejecutamos nuestro programa, podremos cerrar la ventana al pulsar sobre el

botón de cerrar en la barra de título, cosa que, hasta ahora, no ocurría con los ejemplos
anteriores a éste.

En los siguientes ejemplos veremos el comportamiento de los diferentes componentes:

Button, Checkbox,...

Empecemos por el Button. Realizaremos un programa que muestre un botón en la

aplicación y al pulsarlo, se cierre la ventana. También se cerrará si pulsamos en el botón
de cerrar sobre la barra de título.
package es.studium.EventoBotonCerrar;

import java.awt.*;
import java.awt.event.*;

//Declaramos nuestra clase que hereda de Frame e implementa //WindowListener

y ActionListener para el botón
public class EventoBotonCerrar extends Frame implements WindowListener,
ActionListener
{
private static final long serialVersionUID = 1L;
Button btnBoton = new Button("Cerrar");

public EventoBotonCerrar()
{
setLayout(new FlowLayout());
setTitle("Botón que cierra la ventana");
add(btnBoton);
addWindowListener(this);
//Añadir el listener al botón
btnBoton.addActionListener(this);

Página 14 de 45
 Programación

setSize(100,100);
setVisible(true);
}

public static void main(String[] args)

{
new EventoBotonCerrar();
}

//A continuación debemos colocar el método de la clase

//abstracta ActionListener
public void actionPerformed(ActionEvent ae)
{
System.exit(0);
}
public void windowActivated(WindowEvent we) {}
public void windowClosed(WindowEvent we) {}
public void windowClosing(WindowEvent we)
{
System.exit(0);
}
public void windowDeactivated(WindowEvent we) {}
public void windowDeiconified(WindowEvent we) {}
public void windowIconified(WindowEvent we) {}
public void windowOpened(WindowEvent we) {}
}
//Fin de la clase EventoBotonCerrar

El siguiente ejemplo mostrará dos botones en pantalla y una etiqueta. Al pulsar un botón,
en la etiqueta aparecerá el nombre del botón pulsado. Con este ejemplo vamos a ver la
forma de diferenciar qué botón se ha pulsado.
package es.studium.EventoBotones;
import java.awt.*;
import java.awt.event.*;

public class EventoBotones extends Frame implements WindowListener, ActionListener

Página 15 de 45
 Programación

{
private static final long serialVersionUID = 1L;
Button btnBoton1 = new Button("Uno");
Button btnBoton2 = new Button("Dos");
Label lblEtiqueta = new Label("");

public EventoBotones()
{
setLayout(new FlowLayout());
setTitle("Diferenciar botones");
add(btnBoton1);
add(btnBoton2);
add(lblEtiqueta);
addWindowListener(this);
btnBoton1.addActionListener(this);
btnBoton2.addActionListener(this);
setSize(300,100);
setVisible(true);
}

public static void main(String[] args)

{
new EventoBotones();
}

public void actionPerformed(ActionEvent ae)

{
//Mediante la comparación de cadenas con equals
//comprobaremos qué botón se pulsó mediante el método
//getSource que al aplicarse sobre el objeto ae
//nos dirá el nombre del botón que generó el evento
if(btnBoton1.equals(ae.getSource()))
{
lblEtiqueta.setText("Uno");
}
else
{
lblEtiqueta.setText("Dos");
}
}
public void windowActivated(WindowEvent we) {}

Página 16 de 45
 Programación

public void windowClosed(WindowEvent we) {}

public void windowClosing(WindowEvent we)
{
System.exit(0);
}
public void windowDeactivated(WindowEvent we) {}
public void windowDeiconified(WindowEvent we) {}
public void windowIconified(WindowEvent we) {}
public void windowOpened(WindowEvent we) {}
}
//Fin de la clase EventoBotones

Veamos ahora un programa que maneja un Canvas. Al pulsar una tecla sobre él,
cambiará de color de fondo.
package es.studium.EventoCanvas;

import java.awt.Canvas;
import java.awt.Color;
import java.awt.FlowLayout;
import java.awt.Frame;
import java.awt.Graphics;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;

public class EventoCanvas extends Frame implements WindowListener, KeyListener

{
private static final long serialVersionUID = 1L;
// Variable iteradora
int indice = 0;
// Declaración de una tabla de colores (Tipo Color)
Color colores[] = {Color.red, Color.green, Color.blue};
// Creación del Canvas
Canvas cvCanvas = new Canvas ( );

Página 17 de 45
 Programación

public EventoCanvas()
{
setLayout(new FlowLayout());
setTitle("Canvas");
add(cvCanvas);
setSize(300,100);
// Obtener el foco para el canvas para que al pulsar una
// tecla se active el evento correspondiente del canvas
cvCanvas.requestFocus();
// Añadir el listener al frame
addKeyListener(this);
addWindowListener(this);
setVisible(true);
}

public static void main(String[] args)

{
new EventoCanvas();
}
// Implementar el método del canvas
public void keyTyped(KeyEvent ke)
{
indice++;
// Comprobamos si hemos llegado al final de la tabla colores
if(indice==colores.length)
{
indice=0;
}
// Llamamos al método repaint de la clase util, que a su vez
// llamará al método paint()
repaint();
}
public void keyPressed(KeyEvent ke) {}
public void keyReleased(KeyEvent ke) {}

public void windowActivated(WindowEvent we) {}

public void windowClosed(WindowEvent we) {}
public void windowClosing(WindowEvent we)
{
System.exit(0);
}

Página 18 de 45
 Programación

public void windowDeactivated(WindowEvent we) {}

public void windowDeiconified(WindowEvent we) {}
public void windowIconified(WindowEvent we) {}
public void windowOpened(WindowEvent we) {}
public void paint(Graphics g)
{
// Establecer el color de relleno
g.setColor(colores[indice]);
// Dibujar un rectángulo relleno desde 0,0 hasta las
// dimensiones del canvas
g.fillRect(0,0,getSize().width, getSize().height);
}
}

El siguiente ejemplo nos mostrará la forma de trabajar con los Checkboxes. Tendremos
una ventana con tres opciones y tres etiquetas. Al seleccionar una opción, en su etiqueta
correspondiente aparecerá la palabra “Activado”. Al deseleccionar una opción, aparecerá
la palabra “Desactivado”
package es.studium.EventoCheckbox1;

import java.awt.Checkbox;
import java.awt.FlowLayout;
import java.awt.Frame;
import java.awt.Label;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;

public class EventoCheckbox1 extends Frame implements WindowListener,

ItemListener
{
private static final long serialVersionUID = 1L;
// En este caso, se pueden elegir todas las opciones que queramos
Checkbox chkUno = new Checkbox("Uno");
Checkbox chkDos = new Checkbox("Dos");

Página 19 de 45
 Programación

Checkbox chkTres = new Checkbox("Tres");

Label lblEtiqueta1 = new Label("Desactivado");
Label lblEtiqueta2 = new Label("Desactivado");
Label lblEtiqueta3 = new Label("Desactivado");

public EventoCheckbox1()
{
setLayout(new FlowLayout());
setTitle("Botones de Opción");
add(chkUno);
add(lblEtiqueta1);
add(chkDos);
add(lblEtiqueta2);
add(chkTres);
add(lblEtiqueta3);

addWindowListener(this);
// Añadir los listeners a los botones de opción
chkUno.addItemListener(this);
chkDos.addItemListener(this);
chkTres.addItemListener(this);

setSize(500,100);
setVisible(true);
}

public static void main(String[] args)

{
new EventoCheckbox1();
}

// Primero debemos averiguar qué opción produjo este evento

// A continuación veremos su estado actual y actuaremos en
// consecuencia
public void itemStateChanged(ItemEvent ie)
{
// Comparamos mediante equals, una cadena con el elemento
// que produjo el evento mediante getItem()
if("Uno".equals(ie.getItem()))
{
// Comparamos el estado actual del checkbox mediante

Página 20 de 45
 Programación

// getStateChange() con la constante SELECTED aplicada

// al tipo de evento producido
if(ie.getStateChange()==ItemEvent.SELECTED)
{
lblEtiqueta1.setText("Activado");
}
else
{
lblEtiqueta1.setText("Desactivado");
}
}
else if("Dos".equals(ie.getItem()))
{
if(ie.getStateChange()==ItemEvent.SELECTED)
{
lblEtiqueta2.setText("Activado");
}
else
{
lblEtiqueta2.setText("Desactivado");
}
}
else if("Tres".equals(ie.getItem()))
{
if(ie.getStateChange()==ItemEvent.SELECTED)
{
lblEtiqueta3.setText("Activado");
}
else
{
lblEtiqueta3.setText("Desactivado");
}
}
}
public void windowActivated(WindowEvent we) {}
public void windowClosed(WindowEvent we) {}
public void windowClosing(WindowEvent we)
{
System.exit(0);
}
public void windowDeactivated(WindowEvent we) {}

Página 21 de 45
 Programación

public void windowDeiconified(WindowEvent we) {}

public void windowIconified(WindowEvent we) {}
public void windowOpened(WindowEvent we) {}
}

A continuación, veremos la forma de trabajar con los Checkboxes pero que solamente
esté seleccionado uno a la vez, es decir usando opciones excluyentes. Para ello
simplemente modificaremos el anterior ejemplo y usaremos un CheckboxGroup para
agrupar las opciones y así indicar que solamente queremos que esté activa una cada vez.
package es.studium.EventoCheckbox2;

import java.awt.Checkbox;
import java.awt.CheckboxGroup;
import java.awt.FlowLayout;
import java.awt.Frame;
import java.awt.Label;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;

public class EventoCheckbox2 extends Frame implements WindowListener, ItemListener

{
private static final long serialVersionUID = 1L;
// Definir el grupo
CheckboxGroup grupo = new CheckboxGroup();
// En este caso, sólo se puede tener activa una de las opciones
// Las opciones se crean indicando su etiqueta, si están o no
// seleccionadas y el grupo al que pertenecen
Checkbox chkUno = new Checkbox("Uno", true, grupo);
Checkbox chkDos = new Checkbox("Dos", false, grupo);
Checkbox chkTres = new Checkbox("Tres", false, grupo);
Label lblEtiqueta1 = new Label("Activado");
Label lblEtiqueta2 = new Label("Desactivado");
Label lblEtiqueta3 = new Label("Desactivado");

Página 22 de 45
 Programación

public EventoCheckbox2()
{
setLayout(new FlowLayout());
setTitle("Botones de Opción con sólo uno activo");
add(chkUno);
add(lblEtiqueta1);
add(chkDos);
add(lblEtiqueta2);
add(chkTres);
add(lblEtiqueta3);

addWindowListener(this);
chkUno.addItemListener(this);
chkDos.addItemListener(this);
chkTres.addItemListener(this);

setSize(500, 100);
setResizable(false);
setVisible(true);
}

public static void main(String[] args)

{
new EventoCheckbox2();
}

public void itemStateChanged(ItemEvent ie)

{
if("Uno".equals(ie.getItem()))
{
lblEtiqueta1.setText("Activado");
lblEtiqueta2.setText("Desactivado");
lblEtiqueta3.setText("Desactivado");
}
else if("Dos".equals(ie.getItem()))
{
lblEtiqueta1.setText("Desactivado");
lblEtiqueta2.setText("Activado");
lblEtiqueta3.setText("Desactivado");
}
else if("Tres".equals(ie.getItem()))

Página 23 de 45
 Programación

{
lblEtiqueta1.setText("Desactivado");
lblEtiqueta2.setText("Desactivado");
lblEtiqueta3.setText("Activado");
}
}
public void windowActivated(WindowEvent we) {}
public void windowClosed(WindowEvent we) {}
public void windowClosing(WindowEvent we)
{
System.exit(0);
}
public void windowDeactivated(WindowEvent we) {}
public void windowDeiconified(WindowEvent we) {}
public void windowIconified(WindowEvent we) {}
public void windowOpened(WindowEvent we) {}
}

A continuación, veremos cómo se trabaja con Choice. Mostraremos una ventana con una
lista de tres colores. Al elegirlos, cambiaremos el fondo de la pantalla al color elegido:
package es.studium.EventoChoice;

import java.awt.Choice;
import java.awt.Color;
import java.awt.FlowLayout;
import java.awt.Frame;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;

Página 24 de 45
 Programación

public class EventoChoice extends Frame implements WindowListener, ItemListener

{
private static final long serialVersionUID = 1L;
// Creamos la lista
Choice lista = new Choice();

public EventoChoice()
{
setLayout(new FlowLayout());
setTitle("Lista");
//Añadimos a la lista los elementos que la componen
lista.add("Blanco");
lista.add("Rojo");
lista.add("Azul");
//Añadimos la lista
add(lista);

addWindowListener(this);
//Añadimos el listener a la lista
lista.addItemListener(this);
setSize(300, 200);
setVisible(true);
}

public static void main(String[] args)

{
new EventoChoice();
}

// Implementamos el método del listener

public void itemStateChanged(ItemEvent ie)
{
// El tratamiento se hace igual que para los checkboxes
if("Blanco".equals(ie.getItem()))
{
// Con setBackground cambiamos el color del fondo
// Color.white es la constante color para el blanco
setBackground(Color.white);
}
else if("Rojo".equals(ie.getItem()))
{

Página 25 de 45
 Programación

setBackground(Color.red);
}
else
{
setBackground(Color.blue);
}
}
public void windowActivated(WindowEvent we) {}
public void windowClosed(WindowEvent we) {}
public void windowClosing(WindowEvent we)
{
System.exit(0);
}
public void windowDeactivated(WindowEvent we) {}
public void windowDeiconified(WindowEvent we) {}
public void windowIconified(WindowEvent we) {}
public void windowOpened(WindowEvent we) {}
}

Para mostrar un ejemplo de eventos con Containers, veremos uno con la clase Dialog.
Se mostrará un Frame con un botón. Al pulsar dicho botón, aparecerá un diálogo con
un mensaje. Al cerrar el Dialog, volveremos al Frame principal.
package es.studium.EventoDialog;

import java.awt.Button;
import java.awt.Dialog;
import java.awt.FlowLayout;
import java.awt.Frame;
import java.awt.Label;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowEvent;

Página 26 de 45
 Programación

import java.awt.event.WindowListener;

public class EventoDialog extends Frame implements WindowListener, ActionListener

{
private static final long serialVersionUID = 1L;
Button btnBoton = new Button("Pulsar...");
// Crear el diálogo indicando el padre, el título y si es o no
// modal
Dialog dlgUno = new Dialog(this, "Diálogo con mensaje", true);
Label lblEtiqueta = new Label("Programando en JAVA...");

public EventoDialog()
{
//Definir la Ventana principal
setLayout(new FlowLayout());
setTitle("Ventana con Diálogo");
setSize(300, 100);
add(btnBoton);
btnBoton.addActionListener(this);
addWindowListener(this);
//Definir el Diálogo
dlgUno.setLayout(new FlowLayout());
dlgUno.add(lblEtiqueta);
dlgUno.setSize(200,150);
//Para poder cerrar el Diálogo
dlgUno.addWindowListener(this);

setVisible(true);
}

public static void main(String[] args)

{
new EventoDialog();
}
public void actionPerformed(ActionEvent ae)
{
dlgUno.setVisible(true);
}

public void windowActivated(WindowEvent we) {}

public void windowClosed(WindowEvent we) {}

Página 27 de 45
 Programación

public void windowClosing(WindowEvent we)

{
if(dlgUno.isActive())
{
dlgUno.setVisible(false);
}
else
{
System.exit(0);
}
}
public void windowDeactivated(WindowEvent we) {}
public void windowDeiconified(WindowEvent we) {}
public void windowIconified(WindowEvent we) {}
public void windowOpened(WindowEvent we) {}
}

Pasaremos a continuación a ver un ejemplo para manejo de Listas. Se mostrará una lista
con 6 colores y al seleccionar uno, cambiará el color de fondo de la aplicación. No se
permitirá selección múltiple al no tener sentido.
package es.studium.EventoList;

import java.awt.Color;
import java.awt.FlowLayout;
import java.awt.Frame;
import java.awt.List;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;

Página 28 de 45
 Programación

public class EventoList extends Frame implements WindowListener, ActionListener

{
private static final long serialVersionUID = 1L;
// Creación de una lista con 4 elementos visibles y que no
// permite multiselección
List lista = new List ( 4, false );

public EventoList()
{
setLayout(new FlowLayout());
setTitle("Lista con colores");
lista.add("Blanco");
lista.add("Rojo");
lista.add("Azul");
lista.add("Verde");
lista.add("Amarillo");
lista.add("Naranja");
add(lista);
addWindowListener(this);
// Para implementar el doble clic del ratón
// Si sólo quisiéramos una pulsación, lista.addItemListener
lista.addActionListener(this);

setSize(250, 200);
setVisible(true);
}

public static void main(String[] args)

{
new EventoList();
}
public void actionPerformed(ActionEvent ae)
{
if("Rojo".equals(lista.getSelectedItem()))
{
setBackground(Color.red);
}
else if("Azul".equals(lista.getSelectedItem()))
{
setBackground(Color.blue);
}

Página 29 de 45
 Programación

else if("Verde".equals(lista.getSelectedItem()))
{
setBackground(Color.green);
}
else if("Amarillo".equals(lista.getSelectedItem()))
{
setBackground(Color.yellow);
}
else if("Naranja".equals(lista.getSelectedItem()))
{
setBackground(Color.orange);
}
else
{
setBackground(Color.white);
}
}
public void windowActivated(WindowEvent we) {}
public void windowClosed(WindowEvent we) {}
public void windowClosing(WindowEvent we)
{
System.exit(0);
}
public void windowDeactivated(WindowEvent we) {}
public void windowDeiconified(WindowEvent we) {}
public void windowIconified(WindowEvent we) {}
public void windowOpened(WindowEvent we) {}
}

El ejemplo próximo muestra la forma de gestionar los eventos con los Scrollbar.
Tenemos una pantalla con un scrollbar horizontal y un cuadro de texto donde se muestra
el valor actual del scrollbar.

Página 30 de 45
 Programación

package es.studium.EventoScrollbar;

import java.awt.BorderLayout;
import java.awt.Frame;
import java.awt.Scrollbar;
import java.awt.TextField;
import java.awt.event.AdjustmentEvent;
import java.awt.event.AdjustmentListener;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;

public class EventoScrollbar extends Frame implements WindowListener,

AdjustmentListener
{
private static final long serialVersionUID = 1L;
Scrollbar scrHorizontal = new Scrollbar(Scrollbar.HORIZONTAL,1,10,1,265);
// Empieza en 1, vale 10 el cuadrado, y va desde 1 a 255 (265–10)
TextField txtCampo = new TextField(5);
public EventoScrollbar()
{
setLayout(new BorderLayout());
setTitle("Scrollbar");
txtCampo.setText("1");

add("North", scrHorizontal);
add("South", txtCampo);
scrHorizontal.addAdjustmentListener(this);
addWindowListener(this);
setSize(200, 100);
setVisible(true);
}

public static void main(String[] args)

{
new EventoScrollbar();
}

public void windowActivated(WindowEvent we) {}

public void windowClosed(WindowEvent we) {}
public void windowClosing(WindowEvent we)
{

Página 31 de 45
 Programación

System.exit(0);
}
public void windowDeactivated(WindowEvent we) {}
public void windowDeiconified(WindowEvent we) {}
public void windowIconified(WindowEvent we) {}
public void windowOpened(WindowEvent we) {}
public void adjustmentValueChanged(AdjustmentEvent ae)
{
txtCampo.setText(Integer.toString((ae.getValue())));
}
}

El siguiente ejemplo nos enseñará a manejar los componentes TextArea y TextField. Se

trata de una pantalla con un TextField donde iremos escribiendo. Al pulsar un botón que
existe al lado, se pasará el texto antes escrito, a un TextArea que hay en la parte inferior,
añadiéndose al final de lo que hubiera.
package es.studium.EventoTexto;

import java.awt.Button;
import java.awt.FlowLayout;
import java.awt.Frame;
import java.awt.Label;
import java.awt.TextArea;
import java.awt.TextField;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.TextEvent;
import java.awt.event.TextListener;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;

public class EventoTexto extends Frame implements WindowListener, ActionListener,

TextListener
{
private static final long serialVersionUID = 1L;
Label lblEtiqueta = new Label("Escribe un texto:");
// Creamos el textfield con 20 caracteres de ancho

Página 32 de 45
 Programación

TextField txtCampo1 = new TextField(20);

// Creamos el textarea vacío, con 5 filas y 20 columnas
TextArea txaCampo2 = new TextArea("",5,20);
Button btnBoton = new Button ("Añadir texto");
String cadena = "";
int longitud=0;

public EventoTexto()
{
setLayout(new FlowLayout());
setTitle("TextField y TextArea");
add(lblEtiqueta);
add(txtCampo1);
add(btnBoton);
add(txaCampo2);
btnBoton.addActionListener(this);
//Añadir el listener al textfield para poder escribir en él
txtCampo1.addTextListener(this);
addWindowListener(this);
setSize(300, 200);
setVisible(true);
}

public static void main(String[] args)

{
new EventoTexto();
}
// Al cambiar el texto en el textfield, guardamos lo escrito en
// la cadena ca
public void textValueChanged(TextEvent te)
{
cadena = txtCampo1.getText();
}
public void actionPerformed(ActionEvent ae)
{
// Calculamos la longitud de lo escrito
longitud = longitud + cadena.length();
// Si no supera los 20, lo metemos en el TextArea a
// continuación de lo que ya haya
if(longitud<=20)
{

Página 33 de 45
 Programación

txaCampo2.setText(txaCampo2.getText()+" "+cadena);
}
// Si no, lo pasamos a la línea siguiente
else
{
txaCampo2.setText(txaCampo2.getText()+"\n"+cadena);
longitud = cadena.length();
}
// Borramos lo que haya en el textfield
txtCampo1.setText("");
}
public void windowActivated(WindowEvent we) {}
public void windowClosed(WindowEvent we) {}
public void windowClosing(WindowEvent we)
{
System.exit(0);
}
public void windowDeactivated(WindowEvent we) {}
public void windowDeiconified(WindowEvent we) {}
public void windowIconified(WindowEvent we) {}
public void windowOpened(WindowEvent we) {}
}

Por último, veremos la forma de trabajar con los Menús. Veremos dos ejemplos: uno con
el típico menú en una barra con opciones y el otro ejemplo será un Popup Menú, es
decir, un menú emergente que aparece al pulsar con el ratón en una zona definida de la
pantalla.

Empezaremos por la barra de menú. Dicha barra tendrá dos opciones: Colores y Salir.
Dentro de Colores nos encontraremos con otras dos opciones: Rojo y Blanco. Al elegir
una de ellas se pondrá el fondo del color indicado.
package es.studium.EventoMenu;

Página 34 de 45
 Programación

import java.awt.Color;
import java.awt.FlowLayout;
import java.awt.Frame;
import java.awt.Menu;
import java.awt.MenuBar;
import java.awt.MenuItem;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;

public class EventoMenu extends Frame implements WindowListener, ActionListener

{
private static final long serialVersionUID = 1L;
// Declarar la Barra de Menú
MenuBar mnbMenu = new MenuBar();
// Declarar las opciones de la Barra de Menú
Menu mn1 = new Menu("Colores");
Menu mn2 = new Menu("Salir");
// Declarar las opciones de Colores
MenuItem mn11 = new MenuItem("Rojo");
MenuItem mn12 = new MenuItem("Blanco");
MenuItem mn21 = new MenuItem("Salir");

public EventoMenu()
{
setLayout(new FlowLayout());
setTitle("Barra de Menú");
// Crear el primer submenú añadiendo las opciones
mn1.add(mn11);
// Añadir un Separador
mn1.addSeparator();
mn1.add(mn12);
// Crear el segundo submenu
mn2.add(mn21);
// Añadir los submenús, a la barra de menú
mnbMenu.add(mn1);
mnbMenu.add(mn2);
// Establecer la Barra de Menú como tal
setMenuBar(mnbMenu);

Página 35 de 45
 Programación

setSize(250,150);
addWindowListener(this);
// Se añaden los Listeners a las opciones de los submenús
// no a las opciones del menú
mn11.addActionListener(this);
mn12.addActionListener(this);
mn21.addActionListener(this);

setVisible(true);
}
public static void main(String[] args)
{
new EventoMenu();
}
public void actionPerformed(ActionEvent ae)
{
Object a;
a=ae.getSource();
if(a.equals(mn21))
{
System.exit(0);
}
else if(a.equals(mn11))
{
setBackground(Color.red);
}
else
{
setBackground(Color.white);
}
}
public void windowActivated(WindowEvent we) {}
public void windowClosed(WindowEvent we) {}
public void windowClosing(WindowEvent we)
{
System.exit(0);
}
public void windowDeactivated(WindowEvent we) {}
public void windowDeiconified(WindowEvent we) {}
public void windowIconified(WindowEvent we) {}

Página 36 de 45
 Programación

public void windowOpened(WindowEvent we) {}

}

Para finalizar veremos el ejemplo de un Menú Popup. Simplemente se trata de una

ventana en la que tendremos un botón que al pulsarlo aparecerá a su lado el menú popup
con dos opciones: Rojo y Blanco. Al elegir una de ellas, cambiaremos el fondo de la
ventana al color elegido.
package es.studium.EventoMenuPopup;

import java.awt.Button;
import java.awt.Color;
import java.awt.FlowLayout;
import java.awt.Frame;
import java.awt.MenuItem;
import java.awt.PopupMenu;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;

public class EventoMenuPopup extends Frame implements ActionListener,

WindowListener
{
private static final long serialVersionUID = 1L;
Button btnBoton = new Button("Púlsame...");
// Crear el menú popup
PopupMenu ppMenu = new PopupMenu("Popup");
// Crear las opciones del menú
MenuItem mnUno = new MenuItem("Rojo");
MenuItem mnDos = new MenuItem("Blanco");

public EventoMenuPopup()
{
setLayout(new FlowLayout());

Página 37 de 45
 Programación

setTitle("Menú Pop-up");
// Añadimos el botón
add(btnBoton);
// Añadimos las opciones al menú
ppMenu.add(mnUno);
ppMenu.add(mnDos);
// Añadimos el menú
add(ppMenu);

// Añadir los Listeners

btnBoton.addActionListener(this);
mnUno.addActionListener(this);
mnDos.addActionListener(this);
addWindowListener(this);

setSize(250,100);
setVisible(true);
}

public static void main(String[] args)

{
new EventoMenuPopup();
}
public void actionPerformed(ActionEvent ae)
{
Object a;
//Obtener qué se ha producido, si pulsado el botón o una opción del
menú
a = ae.getSource();
if(a.equals(btnBoton))
{
// Se mostrará el popup a una distancia de 10 en
// horizontal y 10 en vertical respecto al objeto btnBoton
ppMenu.show(btnBoton,10,10);
}
else if(a.equals(mnUno))
{
setBackground(Color.red);
}
else
{

Página 38 de 45
 Programación

setBackground(Color.white);
}
}
public void windowActivated(WindowEvent we) {}
public void windowClosed(WindowEvent we) {}
public void windowClosing(WindowEvent we)
{
System.exit(0);
}
public void windowDeactivated(WindowEvent we) {}
public void windowDeiconified(WindowEvent we) {}
public void windowIconified(WindowEvent we) {}
public void windowOpened(WindowEvent we) {}
}

Otra posibilidad para trabajar con los eventos sería utilizar clases Adapters en lugar de
clases Listeners. De esta forma se hereda de WindowAdapter, no se implementan
interfaces, con lo cual nos ahorramos por un lado la definición de métodos, pero, por
otro lado, nuestra clase principal ya no puede heredar de Frame, con lo cual tendremos
que crear nuestro propio Frame.

Veamos un ejemplo de una ventana que, al pulsar el botón de cierre, se cierra, pero ahora
mediante el uso de un Adapter:
package es.studium.UsoAdapter;

import java.awt.FlowLayout;
import java.awt.Frame;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

// Ahora heredaremos, no implementaremos

// Esto tiene el inconveniente que no podremos heredar de Frame
// por lo que tendremos que crear el Frame dentro de nuestra clase
public class UsoAdapter extends WindowAdapter
{
Frame frm = new Frame("Ventana que se Cierra con Adapter");

Página 39 de 45
 Programación

public UsoAdapter()
{
// Ahora hay que referirse a f
frm.setLayout(new FlowLayout());
frm.addWindowListener(this);
frm.setSize(200,200);
frm.setVisible(true);
}
// Solamente definiremos el método de WindowListener que
// necesitemos, en este caso windowClosing
public void windowClosing(WindowEvent we)
{
System.exit(0);
}
public static void main(String[] args)
{
new UsoAdapter();
}
}

Otro ejemplo más. En este caso vamos a mostrar una ventana con un botón centrado
tanto horizontal como verticalmente. Y, además, si redimensionamos la ventana, el botón
se recolocará siempre en dicho centro.
package es.studium.Centrado;

import java.awt.Button;
import java.awt.FlowLayout;
import java.awt.Frame;
import java.awt.event.ComponentEvent;
import java.awt.event.ComponentListener;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;

Página 40 de 45
 Programación

public class Centrado extends Frame implements WindowListener,

ComponentListener
{
private static final long serialVersionUID = 1L;
Button boton1 = new Button("Aceptar");

public Centrado()
{
setLayout(new FlowLayout());
setSize(500, 600);
addWindowListener(this);
add(boton1);
addComponentListener(this);
boton1.setLocation((getWidth()/2)-
(boton1.getWidth()/2),(getHeight()/2)-(boton1.getHeight()/2));
setVisible(true);
}

public static void main(String[] args)

{
new Centrado();
}

public void componentHidden(ComponentEvent arg0) {}

public void componentMoved(ComponentEvent arg0) {}

public void componentResized(ComponentEvent arg0)

{
boton1.setLocation((getWidth()/2)-
(boton1.getWidth()/2),(getHeight()/2)-(boton1.getHeight()/2));
}
public void componentShown(ComponentEvent arg0) {}
public void windowActivated(WindowEvent arg0) {}
public void windowClosed(WindowEvent arg0) {}
public void windowClosing(WindowEvent arg0)
{
System.exit(0);
}
public void windowDeactivated(WindowEvent arg0) {}

Página 41 de 45
 Programación

public void windowDeiconified(WindowEvent arg0) {}

public void windowIconified(WindowEvent arg0) {}
public void windowOpened(WindowEvent arg0) {}
}

Obtenemos el siguiente resultado:

En el tema anterior, no se pudo apreciar correctamente el ejemplo del CardLayout,

porque hacían falta los eventos. Completémoslo ahora.
package es.studium.AwtCard;

import java.awt.BorderLayout;
import java.awt.Button;
import java.awt.CardLayout;
import java.awt.Choice;
import java.awt.Frame;
import java.awt.Panel;
import java.awt.TextField;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;

public class AwtCard extends Frame implements WindowListener, ItemListener

{
private static final long serialVersionUID = 1L;
// Creamos un par de paneles

Página 42 de 45
 Programación

Panel card = new Panel();

Panel ac = new Panel();
// Creamos un Choice o Lista de Selección
Choice c = new Choice();
// Cadenas constantes (final) que insertaremos en el Choice
final static String PanelBoton = "Panel con Botones";
final static String PanelTexto = "Panel con Campo de Texto";
// Creamos otros dos panels que irán dentro del Panel card
Panel p1 = new Panel();
Panel p2 = new Panel();
Button b1 = new Button ("Botón 1");
Button b2 = new Button ("Botón 2");
Button b3 = new Button ("Botón 3");
// Creamos un TextField o Campo de Texto de tamaño 20
TextField t = new TextField( "Texto",20 );

public AwtCard()
{
// Establecer distribución del Frame
setLayout( new BorderLayout() );
// Añadir elementos al Choice
c.addItem( PanelBoton );
c.addItem( PanelTexto );
// Añadir el Choice al panel ac
ac.add( c );
// Añadir el panel ac al Frame en la parte superior
add( "North",ac );
// Establecer distribución del panel card
card.setLayout( new CardLayout() );

// Añadir botones al panel p1

p1.add( b1 );
p1.add( b2 );
p1.add( b3 );

// Añadir TextField al panel p2

p2.add( t );

// Añadir los panels p1 y p2 al panel card

card.add( PanelBoton, p1 );
card.add( PanelTexto, p2 );

Página 43 de 45
 Programación

// Añadir el panel card al Frame en el centro

add( "Center",card );
// Establecer el tamaño del Frame
setSize(200,200);
// Añadir los Listeners
addWindowListener(this);
c.addItemListener(this);
// Mostrar el Frame en pantalla
setVisible(true);
}
// Fin del Constructor
public static void main(String[] args)
{
new AwtCard();
}
// Fin del main
// Gestión de Eventos
public void windowActivated(WindowEvent we) {}
public void windowClosed(WindowEvent we) {}
public void windowClosing(WindowEvent we)
{
System.exit(0);
}
public void windowDeactivated(WindowEvent we) {}
public void windowDeiconified(WindowEvent we) {}
public void windowIconified(WindowEvent we) {}
public void windowOpened(WindowEvent we) {}
public void itemStateChanged(ItemEvent ie)
{
Object a = new Object();
a = ie.getSource();
// El tratamiento se hace igual que para los checkboxes
if(PanelBoton.equals(ie.getItem()))
{
card.add( PanelBoton, p1 );
card.add( PanelTexto, p2 );
}
else
{
card.add( PanelTexto, p2 );
card.add( PanelBoton, p1 );

Página 44 de 45
 Programación

}
}
}
// Fin de la clase

11/10/2020

Página 45 de 45