5 Eventos¶
Introducción¶
Los eventos son acciones que son provocadas por la interacción de los usuarios con los componentes. Por ejemplo, al hacer clic en un botón, al cambiar el estado de un checkbox, al escribir en un campo de texto, etc.
En AWT, los eventos son objetos que representan dicha interacción. El manejo de estos eventos se realizan mediante listeners, es decir, escuchadores que responden a dichos eventos.
Podemos distinguir diferentes grupos de eventos:
- Eventos del mouse: Son generados por el ratón, como hacer clic, moverlo o arrastrar.
- Eventos del teclado: Se generan cuando se interactúa con el teclado, al escribir o pulsar una tecla.
- Eventos del componente: Generados cuando el componente cambia de estado, como ser redimensionados, mostrados u ocultados.
- Eventos del foco: Generados cuando un componente gana o pierde el foco.
- Eventos de acción: Generados por componentes interactivos como botones.
- Eventos de selección: Generados por componentes de selección, como checkbox o listas.
- Eventos de texto: Generados por componentes de campos de textos.
- Eventos de ventana: Generados por la ventana principal.
Eventos del mouse¶
Son manejados por las interfaces MouseListener y MouseMotionListener. La interfaz MouseListener se encarga de los eventos del ratón:
mouseClicked(event): Se ejecuta cuando se hace clic en el ratón.mousePressed(event): Se ejecuta cunado se presiona sobre el ratón.mouseReleased(event): Se ejecuta cuando el botón del ratón se suelta.mouseEntered(event): Se ejecuta cuando el ratón entra en un componente.mouseExited(event): Se ejecuta cuando el ratón sale de un componente.
Mientras que, la interfaz MouseMotionListener se encarga de los movimientos del ratón:
mouseDragged: Se ejecuta cuando se arrastra el ratón con un botón presionado.mouseMoved: Se ejecuta cuando se arrastra el ratón, pero sin presionar ningún botón.
Todos los métodos reciben como parámetro un objeto de la clase MouseEvent. Esta clase registra las operaciones realizadas por el ratón:
int getButton(). Retorna un valor número indicado el botón del teclado que ha devuelto. Si ha devuelto 0, no ha presionado ningún botón. Si devuelve un número entre 1 y 5, devuelve el botón presionado por el ratón desde la izquierda (comienza en 1) hasta la derecha(termina en 5).Point getPoint(). Retorna la posicional horizontal (x, también se puede obtener congetX()) y la posición vertical (y,getY()).int getClickCount(). Retorna el número de veces que se ha hecho clic en un botón.
Los componentes que admiten este evento, tienen el método addMouseListener que recibe un objeto de MouseListener y addMouseMotionListener que recibe un objeto de MouseMotionListener.
Existe otra tipo de evento del ratón, que controla cuando la rueda del ratón es movida. La interfaz MouseWheelListener es una interfaz funcional que contiene el método mouseWheelMoved(mouseWheelEvent) que se ejecuta cuando la rueda del ratón se mueve. Además, recibe un objeto de la clase MouseWheelEventque se encarga de almacenar información sobre el evento. Para añadir un evento de este tipo se llama al método addMouseWheelListener del componente.
public class MouseEvents {
public void show() {
Panel panel = new Panel();
Frame frame = new Frame();
Label label = new Label("Sin movimiento");
Canvas canvas = new Canvas();
panel.add(label);
panel.add(canvas);
canvas.setBounds(0,0, 100,100);
canvas.setBackground(Color.BLACK);
canvas.addMouseWheelListener(new MouseWheelListener() {
@Override
public void mouseWheelMoved(MouseWheelEvent e) {
}
});
canvas.addMouseListener(new MouseListener() {
@Override
public void mouseClicked(MouseEvent e) {
int button = e.getButton();
if(button == 1){
label.setText("Izquierdo presionado");
} else if(button == 2){
label.setText("Medio presionado");
} else if(button == 3){
label.setText("Derecho presionado");
}
}
@Override
public void mousePressed(MouseEvent e) {
label.setText(e.getPoint().toString());
}
@Override
public void mouseReleased(MouseEvent e) {
System.out.println(e.getClickCount());
}
@Override
public void mouseEntered(MouseEvent e) {
}
@Override
public void mouseExited(MouseEvent e) {
}
});
frame.add(panel);
frame.setSize(500, 500);
frame.setVisible(true);
}
public static void main(String[] args) {
new MouseEvents().show();
}
}
Eventos del teclado¶
La interfaz KeyListener es la encarga de manejar los eventos del teclado. Entre sus métodos encontramos:
keyTyped(event). Se produce cuando se escribe una tecla.keyPressed(event). Se produce cuando se presiona una tecla.keyReleased(event). Se produce cuando se presiona una tecla.
Dichos métodos reciben un objeto de tipo KeyEvent, que es la clase encargada de recibir información sobre el evento. Entre sus métodos, podemos destacar:
int getKeyCode(): retorna el número asociado a la tecla relacionada con el evento.char getKeyChar(): retorna el carácter.static String getKeyText(): retorna la función de la tecla, como por ejemplo, la tecla ENTER.boolean isActionKey(): retornatruesi la tecla es una tecla de acción.
Parra ejecutar un evento de este tipo, se llama al método addKeyListener()
public class KeyEvents {
public void show() {
Panel panel = new Panel();
Frame frame = new Frame();
Label label = new Label("Sin movimiento");
Canvas canvas = new Canvas();
panel.add(label);
panel.add(canvas);
canvas.setBounds(0,0, 100,100);
canvas.setBackground(Color.BLACK);
canvas.setFocusable(true);
canvas.addMouseWheelListener(new MouseWheelListener() {
@Override
public void mouseWheelMoved(MouseWheelEvent e) {
}
});
canvas.addKeyListener(new KeyListener() {
@Override
public void keyTyped(KeyEvent e) {
System.out.println("KEY TYPED");
System.out.printf("CHAR -> %c\n", e.getKeyChar());
System.out.printf("INTEGER -> %d\n", e.getKeyCode());
System.out.printf("TEXT -> %s\n", KeyEvent.getKeyText(e.getKeyCode()));
}
@Override
public void keyPressed(KeyEvent e) {
System.out.println("KEY PRESSED");
System.out.printf("CHAR -> %c\n", e.getKeyChar());
System.out.printf("INTEGER -> %d\n", e.getKeyCode());
System.out.printf("TEXT -> %s\n", KeyEvent.getKeyText(e.getKeyCode()));
}
@Override
public void keyReleased(KeyEvent e) {
System.out.println("KEY RELEASED");
System.out.printf("CHAR -> %c\n", e.getKeyChar());
System.out.printf("INTEGER -> %d\n", e.getKeyCode());
System.out.printf("TEXT -> %s\n", KeyEvent.getKeyText(e.getKeyCode()));
}
});
frame.add(panel);
frame.setSize(500, 500);
frame.setVisible(true);
}
public static void main(String[] args) {
new KeyEvents().show();
}
}
Eventos de componentes¶
La interfaz ComponentListener es la encargada de manejar los eventos del componente. Los métodos que se ejecutarían serían:
componentResized(event): Se llama cuando el componente cambia de tamaño.componentMoved(event): Se llama cuando el componente cambia de posición.componentShown(event): Se llama cuando el componente se hace visible.componentHidden(event): Se llama cuando el componente se oculta.
Para añadir este tipo de eventos, se puede usar el método addComponentListener de los componentes.
public class ComponentEvents {
public void show() {
Panel panel = new Panel();
Frame frame = new Frame();
Label label = new Label("Sin movimiento");
panel.add(label);
frame.addComponentListener(new ComponentListener() {
@Override
public void componentResized(ComponentEvent e) {
System.out.println("Component resized");
}
@Override
public void componentMoved(ComponentEvent e) {
System.out.println("Component moved");
}
@Override
public void componentShown(ComponentEvent e) {
System.out.println("Component shown");
}
@Override
public void componentHidden(ComponentEvent e) {
System.out.println("Component hidden");
}
});
frame.add(panel);
frame.setSize(500, 500);
frame.setVisible(true);
}
public static void main(String[] args) {
new ComponentEvents().show();
}
}
Eventos del foco¶
Para controla el foco, disponemos de la interfaz FocusListener con métodos para comprobar, si el foco ha sido adquirido focusGained(focusEvent), o lo ha perdido focusGained(focusEvent). La clase FocusEvent guarda la información sobre la obtención o pérdida del foco.
Con el método addFocusListener() se puede añadir un objeto de tipo FocusListener para manejar el evento del foco. Además los componentes suelen tener un método setFocusable(boolean b) para indicar desde el código la pérdida o la obtención del foco.
public class FocusEvents {
public void show() {
Panel panel = new Panel();
Frame frame = new Frame();
TextField field = new TextField(40);
panel.add(field);
field.addFocusListener(new FocusListener() {
@Override
public void focusGained(FocusEvent e) {
System.out.println("Foco obtenido");
}
@Override
public void focusLost(FocusEvent e) {
System.out.println("Foco perdido");
}
});
frame.add(panel);
frame.setSize(500, 500);
frame.setVisible(true);
}
public static void main(String[] args) {
new FocusEvents().show();
}
}
Eventos de acción¶
La interfaz ActionListener es la encargada de manejar los eventos por acciones provocados por los componentes. Es un interfaz funcional y su único método actionPerformed(actionEvent) es el que se ejecuta cuando el evento se produce.
La clase ActionEvent almacena información relevante para la acción realizada, como obtener el comando de la acción ejecutada (getActionCommand()), obtener el momento de la ejecución de la acción (getWhen()), etc.
Para registrar un objeto de este tipo para manejar el evento, se puede llamar al método addActionListener() de los componentes.
public class ActionEvents {
public void show() {
Panel panel = new Panel();
Frame frame = new Frame();
Button button = new Button("Press me");
panel.add(button);
button.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
System.out.println("Button clicked in " + e.getWhen() + " with action " + e.getActionCommand());
}
});
frame.add(panel);
frame.setSize(500, 500);
frame.setVisible(true);
}
public static void main(String[] args) {
new ActionEvents().show();
}
}
Eventos de selección¶
La interfaz ItemListener es la encargada de manejar los eventos de los componentes de selección (Choice, Checkbox, List). Es una interfaz funcional, cuyo método itemStateChange(itemEvent) se invoca cuando se cambia el estado del componente.
El objeto ItemEvent almacena información sobre el evento, como:
Object getItem(). Obtiene el elemento seleccionado.int getStateChange(). Obtiene el estado cambiado, puede serSELECTEDoDESELECTED.getSource(). Obtiene la fuente del evento.
Para añadir dicho evento, se puede usar el método addItemListener().
public class ItemEvents {
public void show() {
Panel panel = new Panel();
Frame frame = new Frame();
Label label = new Label("Choose an option");
Choice choice = new Choice();
choice.addItem("Opción 1");
choice.addItem("Opción 2");
choice.addItem("Opción 3");
panel.add(label);
panel.add(choice);
choice.addItemListener(new ItemListener() {
@Override
public void itemStateChanged(ItemEvent e) {
System.out.println(e.getItem());
}
});
frame.add(panel);
frame.setSize(500, 500);
frame.setVisible(true);
}
public static void main(String[] args) {
new ItemEvents().show();
}
}
Eventos de texto¶
La interfaz TextListener es la encarga de manejar los cambios producidos por los textos de los componentes de textos (TextField y TextArea). Es una interfaz funcional, cuyo método textValueChange(event) es ejecutado cuando se produce el evento.
La clase TextEvent almacena la información relevante sobre el evento producido. Con el método addTextListener se añade el controlador de dicho evento.
public class TextEvents {
public void show() {
Panel panel = new Panel();
Frame frame = new Frame();
Label label = new Label("Type something: ");
TextArea textArea = new TextArea(300, 300);
panel.add(label);
panel.add(textArea);
textArea.addTextListener(new TextListener() {
@Override
public void textValueChanged(TextEvent e) {
System.out.println(textArea.getText());
}
});
frame.add(panel);
frame.setSize(500, 500);
frame.setVisible(true);
}
public static void main(String[] args) {
new TextEvents().show();
}
}
Eventos de ventana¶
La interfaz WindowListener es la encargada de manejar los eventos relacionados con la ventana de nuestra aplicación. Sus métodos son:
void windowOpened(event). Se invoca cuando la ventana ha sido abierta.void windowClosing(event). Se invoca cuando el usuario intenta cerrar la ventana, desde el sistema ventanas nativo. Este método suele usarse, para realizar limpiezas antes de cerrar la aplicación.void windowClosed(event). Se invoca después de cerrar la ventana.void windowIconified(event). Se invoca cuando la ventana se minimiza (iconifica).void windowDeiconified(event). Se invoca cuando la ventana se maximiza (desiconifica) desde un estado minimizado.void windowActivated(event). Se invoca cuando una ventana se convierte en la ventana activavoid windowDeactivated(event). Se invoca cuando una ventana deja de ser la ventana activa
La interfaz WindowFocusListener se encarga de manejar el foco de la ventana, con sus métodos windowGainedFocus(event) y windowLostFocus(event).
La interfaz WindowStateListener se encarga de manejar el cambio del estado de la ventana, con su método windowStateChanged(event). La clase WindowEvent almacena el cambio de estado, y con su método getOldState() se puede obtener el antiguo estado, y con getNewState() el nuevo. Los diferentes estados a tener son:
Frame.NORMAL: La ventana está en su estado normal.Frame.ICONIFIED: La ventana está minimizada.Frame.MAXIMIZED_HORIZ: La ventana está maximizada horizontalmente.Frame.MAXIMIZED_VERT: La ventana está maximizada verticalmente.Frame.MAXIMIZED_BOTH: La ventana está maximizada completamente.
Con el método dispose() de los componentes, se puede liberar los recursos de dicho componente, así como eliminar el componente.
public class WindowEvents {
public void show() {
Panel panel = new Panel();
Frame frame = new Frame();
frame.add(panel);
frame.setSize(500, 500);
frame.setVisible(true);
frame.setLocation(100, 100);
frame.addWindowListener(new WindowListener() {
@Override
public void windowOpened(WindowEvent e) {
System.out.println("Ventana abierta");
}
@Override
public void windowClosing(WindowEvent e) {
System.out.println("Cerrando ventana");
frame.dispose();
}
@Override
public void windowClosed(WindowEvent e) {
System.out.println("Ventana cerrada");
}
@Override
public void windowIconified(WindowEvent e) {
System.out.println("Ventana minimizada");
}
@Override
public void windowDeiconified(WindowEvent e) {
System.out.println("Ventana maximizada");
}
@Override
public void windowActivated(WindowEvent e) {
System.out.println("Ventana activada");
}
@Override
public void windowDeactivated(WindowEvent e) {
System.out.println("Ventana desactivada");
}
});
frame.addWindowFocusListener(new WindowFocusListener() {
@Override
public void windowGainedFocus(WindowEvent e) {
System.out.println("Ventana tiene foco");
}
@Override
public void windowLostFocus(WindowEvent e) {
System.out.println("Ventana perdió el foco");
}
});
frame.addWindowStateListener(new WindowStateListener() {
@Override
public void windowStateChanged(WindowEvent e) {
int state = e.getNewState();
switch (state) {
case Frame.NORMAL -> System.out.println("NORMAL");
case Frame.ICONIFIED -> System.out.println("ICONIFIED");
case Frame.MAXIMIZED_HORIZ -> System.out.println("MAXIMIZED HORIZONTALLY");
case Frame.MAXIMIZED_VERT -> System.out.println("MAXIMIZED VERTICALLY");
case Frame.MAXIMIZED_BOTH -> System.out.println("MAXIMIZED");
}
}
});
}
public static void main(String[] args) {
new WindowEvents().show();
}
}