2TAP Tema 1-Eventos.pptx

Departamento de Sistemas y Computación
TECNOLÓGICO NACIONAL DE MÉXICO
Instituto Tecnológico de Ciudad Madero
Tópicos Avanzados de
Programación
Unidad 1:
Interfaz gráfica de usuario - Eventos

Contenido
Unidad 1 Subtemas
Interfaz gráfica de
usuario.
1.1 Creación de interfaz gráfica para
usuarios.
1.2 Tipos de eventos.
1.3 Manejo de eventos.
1.4 Manejo de componentes gráficos
de control.

Competencia específica
Desarrolla programas para interactuar con el usuario de
una manera amigable, utilizando GUI (Interfaz Gráfica de
Usuario) manipuladas a través de eventos.

Programas
Por consola:
La operación del programa
está determinado por la
secuencia del código; todo
está predeterminado. Se
introducen datos y se
obtiene la información
solicitada. En cualquier
momento el código a
ejecutar es conocido.
Con GUI:
La operación del programa
está determinado por lo que
el usuario solicita al GUI que
realice en un momento
dado, nada está
predeterminado,
dependiendo de la acción
del usuario se ejecuta el
código relacionado.

Programas manejados por eventos
Cuando trabajamos con un GUI, una acción realizada por el
usuario de la aplicación, tal como un clic con el ratón o el
uso del teclado en un componente de la misma,
primeramente el S.O. lo registra considerando la posición
del mouse en la pantalla y en qué aplicación se dio,
comunicándolo al programa donde esto sucedió, y esta
señal que recibe el programa por parte del S.O. es lo que se
llama un evento.

Acciones - Eventos
Beginning Java
Ivor Horton
John Wiley & Sons, Inc.

Manejo de eventos en Java

Objeto de escucha (listener object)
La clase que representa a un oyente puede recibir objetos de
cualquier tipo de escucha, e implementa una interfaz para
atender los diferentes tipos de eventos.
En el caso del clic sobre el botón, la clase escuchadora del
evento necesita implementar la interfaz ActionListener que en
el código de su método actionPerformed ( ) donde se recibe el
objeto de evento, permitirá responder a dicho evento.

Escuchador – origen del evento
Sin embargo, no es suficiente con implementar la interfaz de
escucha, para vincular el objeto de escucha al origen del
evento.
Para registrar un objeto de escucha con una fuente se llama al
método particular addActionListener ( ) en el objeto de origen,
para el objeto JButton y pasa el objeto escuchador como
argumento al método.

Escuchador – origen del evento
La forma en que los eventos se manejan en Java, utilizando
objetos de escucha, se conoce como modelo de evento de
delegación (delegation event model).
Esto se debe a que la responsabilidad de responder a eventos
de un componente, como un botón o un elemento de menú, no
se maneja por los objetos que originaron los eventos en sí,
sino que se delega a otros objetos de escuchas.

Hilos de ejecución para eventos
El código para manejar eventos se ejecuta en el hilo de
envío de eventos, que está separado del hilo en el que
se ejecuta el main ( ), por lo que mientras se procesa un
evento, no se pueden procesar otros eventos, es
necesario que el controlador de eventos actual finalice y
evitar así que se produzca un bloqueo.

Clases de eventos
Un programa necesita responder a diferentes tipos de
eventos como los que se producen sobre los menús,
botones, ratón, teclado y algunos otros componentes.
Para tener un enfoque estructurado para manejar eventos,
los eventos se dividen en subconjuntos. En el nivel más
alto, hay dos grandes categorías de eventos en Java:
 Eventos de bajo nivel
 Eventos semánticos

Categorías de eventos
• Eventos de bajo nivel – son eventos a nivel de sistema que
surgen del teclado o del mouse o eventos asociados con
operaciones en una ventana, como reducirlo a un icono o
cerrarlo. El significado de un evento de bajo nivel es algo
como "el ratón fue movido", "esta ventana ha sido cerrada" o
"esta tecla fue presionada.
Beginning Java
Ivor Horton

• Eventos semánticos: son eventos específicos del
componente GUI a nivel de elemento, como seleccionar un
botón haciendo clic en él para causar alguna acción del
programa o ajustar una barra de desplazamiento. El
significado de un evento semántico es típicamente a lo largo
de las líneas de "se presionó el botón OK" o "se seleccionó el
elemento de menú Guardar". Cada tipo de componente, un
botón o un elemento de menú, por ejemplo, puede generar un
tipo particular de evento semántico.
Beginning Java
Ivor Horton

Las dos categorías se superponen de alguna manera. Si hace
clic en un botón, se crean las dos categorías de eventos: evento
de bajo nivel – "se ha hecho clic en el ratón"; y el semántico –
"se presionó el botón".
La mayoría de los eventos están representados por clases del
paquete java.awt.event, que también define las interfaces de
escucha para varios tipos de eventos. El paquete
javax.swing.event define las clases para eventos que son
específicos para los componentes Swing.
Beginning Java
Ivor Horton

Eventos y Escuchadores
Por ejemplo, si el usuario pulsa un botón llamado “Salir” cerrará
la aplicación. Otro ejemplo muy usado es para validar texto que
se introduzca en un campo de texto.
Los oyentes o escuchadores (Listeners) se encargan de
controlar los eventos, esperan a que el evento se produzca y
realizan una serie de acciones. Según el evento, se necesita un
Listener que lo controle.
Cada Listener tiene una serie de métodos que se deben
implementar, aunque solo se quiera usar uno solo de ellos.
Estos están en el paquete java.awt.event.
Beginning Java
Ivor Horton

Jerarquía de clases de eventos (awt)

Interfaces de eventos escuchadores

Clases de eventos de bajo nivel
Evento Descripción
FocusEvent Eventos que se originan cuando un componente gana o
pierde el foco. Sólo el componente que tiene el foco
puede recibir entrada, por lo que normalmente se
resalta o se muestra el cursor.
MouseEvent Eventos que resultan de las acciones del usuario con el
mouse, como mover el mouse o presionar un botón del
mouse.
KeyEvent Eventos que surgen al presionar las teclas del teclado.
WindowEvent Eventos que se relacionan con una ventana, como
activarla o desactivarla, reducirla a su icono o cerrarla.
Estos eventos se relacionan con objetos de tipo
Window o cualquier subclase de Window.

Clase MouseEvent
Tiene dos subclases para eventos de ratón más especializados:
 MenuDragMouseEvent – define los eventos que señalan
cuando el ratón se arrastra sobre un elemento de menú.
 MouseWheelEvent – define los eventos que indican cuando se
gira la rueda del ratón.

Jerarquía de clases de eventos

Interfaz, métodos y constantes
AWTEvent se deriva de java.util.EventObject. La clase
EventObject implementa la interfaz Serializable, por lo que
todos los objetos de las clases de eventos del diagrama son
serializables. También define un método getSource ( ) que
devuelve el objeto en el cual el evento ocurrió (tipo Object) y
todas las clases de eventos heredan este método. La clase
AWTEvent define constantes públicas que identifican los
distintos tipos de eventos que se denominan como el
nombre del evento en mayúsculas, seguido de _MASK.

Constantes para eventos de bajo nivel
De tipo long con un solo bit en 1, se pueden combinar utilizando un
operador OR bit a bit y se puede separar una constante particular de
una combinación utilizando un AND bit a bit:
MOUSE_EVENT_MASK MOUSE_MOTION_EVENT_MASK
MOUSE_WHEEL_EVENT_MASK KEY_EVENT_MASK
ADJUSTMENT_EVENT_MASK WINDOW_EVENT_MASK
WINDOW_FOCUS_EVENT_MASK WINDOW_STATUS_EVENT_MASK
TEXT_EVENT_MASK ITEM_EVENT_MASK
FOCUS_EVENT_MASK

Eventos semánticos
Se relacionan con las operaciones de los componentes en la
GUI del programa.
Si se selecciona un elemento de menú o se hace clic en un
botón, por ejemplo, se genera un evento semántico.
Tres clases representan los eventos semánticos básicos y se
derivan de la clase AWTEvent, como se muestra enseguida:

Eventos semánticos

Eventos semánticos
Un ActionEvent Se genera cuando se realiza una acción en un
componente como hacer clic en un elemento de menú o en un
botón.
Un ItemEvent se produce cuando un componente está
seleccionado o deseleccionado.
Un AdjustmentEvent se produce cuando se ajusta un objeto
ajustable, como una barra de desplazamiento.
Diferentes tipos de componentes pueden producir diferentes
tipos de eventos semánticos.

Eventos semánticos
Algunos componentes que originan estos eventos:
 ActionEvent
 Buttons: JButton, JToggleButton, JCheckBox
 Menus: JMenuItem, JMenu, JCheckBoxMenuItem,
JRadioButtonMenuItem
 ItemEvent
 Buttons: JButton, JToggleButton, JCheckBox
 Menus: JMenuItem, JMenu, JCheckBoxMenuItem,
JRadioButtonMenuItem
 AdjustmentEvent
 Scrollbar: JScrollbar

Escuchadores de eventos semánticos
Se tiene una interfaz de escucha definida para cada uno de
los tres tipos de evento semántico y cada uno define un
método único:
 ActionListener – define actionPerformed ( ActionEvent e )
 ItemListener – deﬁne itemStateChanged ( ItemEvent e )
 AdjustmentListener – deﬁne adjustmentValueChanged (
AdjustmentEvent e )

Escuchadores de eventos semánticos
Debido a que cada una de estas interfaces de escuchas de
eventos semánticos declara un solo método, no hay
necesidad de las clases de adaptador correspondientes. Las
clases de adaptador para los eventos de nivel bajo estaban
allí sólo debido al número de métodos implicados en cada
interfaz de escucha. Para definir sus objetos de escucha de
eventos semánticos, sólo defina una clase que implementa la
interfaz de escucha adecuada.

Listeners, métodos y eventos
NOMBRE LISTENER DESCRIPCIÓN MÉTODOS EVENTOS
ActionListener Se produce al hacer click en
un componente, también si
se pulsa Enter teniendo el
foco en el componente.
public void actionPerformed(ActionEvent e)  JButton: click o pulsar Enter con el
foco activado en él.
 JList: doble click en un elemento
de la lista.
 JMenuItem: selecciona una
opción del menú.
 JTextField: al pulsar Enter con el
foco activado.
KeyListener Se produce al pulsar una
tecla. según el método
cambiara la forma de pulsar
la tecla.
public void keyTyped(KeyEvent e)
public void keyPressed(KeyEvent e)
public void keyReleased(KeyEvent e)
Cuando pulsamos una tecla, según el
Listener:
 keyTyped:al pulsar y soltar la
tecla.
 keyPressed: al pulsar la tecla.
 keyReleased: al soltar la tecla.
FocusListener Se produce cuando un
componente gana o
pierde el foco, es decir,
que esta seleccionado.
public void focusGained(FocusEvent e)
public void focusLost(FocusEvent e)
Recibir o perder el foco.

Listeners, métodos y eventos
NOMBRE LISTENER DESCRIPCIÓN MÉTODOS EVENTOS
MouseListener Se produce cuando
realizamos una acción
con el ratón.
public void mouseClicked(MouseEvent e)
public void mouseEntered(MouseEvent e)
public void mouseExited(MouseEvent e)
public void mousePressed(MouseEvent e)
public void mouseReleased(MouseEvent e)
Según el Listener:
 mouseCliked: pinchar y soltar.
 mouseEntered: entrar en un
componente con el puntero.
 mouseExited: salir de un
componente con el puntero
 mousePressed: presionar el
botón.
 mouseReleased: soltar el
botón.
MouseMotionListener Se produce con el
movimiento del
mouse..
public void mouseDragged(MouseEvent e)
public void mouseMoved(MouseEvent e)
Cuando pulsamos una tecla, según
el Listener:
 keyTyped:al pulsar y soltar la
tecla.
 keyPressed: al pulsar la tecla.
 keyReleased: al soltar la tecla.

Cuando ocurre un evento, el componente GUI con el que el
usuario interactúa notifica a sus oyentes registrados,
llamando al método de manejo de eventos apropiado de cada
oyente.
Por ejemplo, cuando el usuario presiona la tecla Enter en un
JTextField, se llama al método actionPerformed del oyente
registrado.
Cómo trabaja el manejo de eventos

Cada JComponent tiene una variable de instancia llamada
listenerList que hace referencia a un objeto de la clase
EventListenerList en el paquete javax.swing.event.
Cada objeto de una subclase JComponent mantiene las
referencias a los escuchadores registrados en la lista de
escuchadores.
Esto se muestra en la siguiente figura:
Registro de eventos

Registro de eventos

Producir la siguiente interfaz:
Ejemplo JTextField y JPasswordField

package pruebacampotexto;
// Demostración de la clase JTextField.
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class PruebaCampoTexto extends JFrame {
private JTextField campoTexto1, campoTexto2,
campoTexto3;
private JPasswordField campoContraseña;
Código

// configurar GUI
public PruebaCampoTexto ( ) {
super ( "Prueba de JTextField y JPasswordField" );
Container contenedor = getContentPane ( );
contenedor.setLayout ( new FlowLayout ( ) );
// crear campo de texto con tamaño predeterminado
campoTexto1 = new JTextField ( 10 );
contenedor.add ( campoTexto1 );
// crear campo de texto con texto predeterminado
campoTexto2 = new JTextField ( "Escriba el texto aquí" );
Código

// crear campo de texto con texto predeterminado,
// 20 elementos visibles y sin manejador de eventos
campoTexto3 = new JTextField ( "Campo de texto no
editable", 20 );
campoTexto3.setEditable ( false );
// crear campo de contraseña con texto predeterminado
campoContraseña = new JPasswordField ( "Texto oculto" );
contenedor.add ( campoContraseña );
Código

// registrar manejadores de eventos
ManejadorCampoTexto manejador = new
ManejadorCampoTexto ( );
campoTexto1.addActionListener ( manejador );
campoContraseña.addActionListener ( manejador );
setSize ( 325, 100 );
setVisible ( true );
} // fin del constructor de PruebaCampoTexto
Código

public static void main ( String [ ] args ) {
// TODO code application logic here
PruebaCampoTexto aplicacion = new PruebaCampoTexto ( );
aplicacion.setDefaultCloseOperation (
JFrame.EXIT_ON_CLOSE );
}
// clase interna privada para el manejo de eventos
private class ManejadorCampoTexto implements
ActionListener {
// procesar eventos de campo de texto
public void actionPerformed ( ActionEvent evento ) {
String cadena = "";
Código

// el usuario oprimió Enter en objeto JTextField campoTexto1
if ( evento.getSource ( ) == campoTexto1 ) {
cadena = "campoTexto1: " + evento.getActionCommand ( );
} //el usuario oprimió Enter en objeto JTextField campoTexto2
else if ( evento.getSource ( ) == campoTexto2 ) {
}// el usuario oprimió Enter en objeto JTextField campoTexto3
else if ( evento.getSource ( ) == campoTexto3 ) {
} // el usuario oprimió Enter en objeto JTextField Contraseña
else if ( evento.getSource ( ) == campoContraseña ) {
cadena = "campoContraseña: " + new String (
campoContraseña.getPassword ( ) );
// getActionCommand ( ) – regresa cadena que identifica el comando para este evento
Código

JOptionPane.showMessageDialog ( null, cadena );
} // fin del método actionPerformed
} // fin de la clase interna privada ManejadorCampoTexto
} // fin de la clase PruebaCampoTexto
Código

Otro ejemplo
Obtener la siguiente interfaz “Prueba de la clase
StringTokenizer”, usando etiquetas (JLabel) y campos de texto
(JTextField):

Código
package pruebatoken;
import java.util.*;
import java.awt.*;
public class PruebaToken extends JFrame {
private JLabel indicadorEtiqueta;
private JTextField entradaCampo;
private JTextArea areaSalida;

Código
// configurar GUI y manejo de eventos
public PruebaToken ( ) {
super ( "Prueba de la clase StringTokenizer" );
indicadorEtiqueta = new JLabel ( "Escriba una oración y
oprima Intro" );
contenedor.add ( indicadorEtiqueta );
entradaCampo = new JTextField ( 20 );
entradaCampo.addActionListener ( new ActionListener ( ) {
// clase interna anónima
// addActionListener - agrega receptor acciones para eventos de acción del
// campo de texto, Parámetros: oyente de la acción que se agregará

Código
// manejar evento de campo de texto
StringTokenizer tokens = new StringTokenizer (
evento.getActionCommand ( ) );
areaSalida.setText ( "Número de elementos: "
+ tokens.countTokens ( ) + "nLos tokens son:n" );
while ( tokens.hasMoreTokens ( ) ) {
areaSalida.append ( tokens.nextToken ( ) + "n" );
}
}
} // fin de clase interna anónima
); // fin de la llamada a addActionListener

Código
contenedor.add ( entradaCampo );
areaSalida = new JTextArea ( 10, 20 );
areaSalida.setEditable ( false );
contenedor.add ( new JScrollPane ( areaSalida ) );
setSize ( 275, 240 ); // establecer el tamaño de la ventana
setVisible ( true ); // mostrar la ventana
}
// ejecutar la aplicación
PruebaToken aplicacion = new PruebaToken ( );
}
} // fin de la clase PruebaToken

Un botón es un componente en el que el usuario hace clic
para activar una acción específica. Una aplicación Java puede
utilizar varios tipos de botones: botones de comando,
checkboxes, los botones de conmutación (toggle) y radio
botones. Como puede verse en la siguiente figura, todos los
tipos de botones son subclases de AbstractButton (paquete
javax.swing), que declara las características comunes de los
botones Swing. En esta parte se revisarán los botones que
normalmente se utilizan para iniciar un comando.
JButton

Jerarquía de Botones Swing

Producir la siguiente ventana donde se utilicen etiquetas
(JLabel), campos de edición (JTextField) editables y no
editables y botones (JButton):
Ejemplo

package ventanapruebatiempo;
// Fig. 10.21: Tiempo.java
import java.text.DecimalFormat;
public class Tiempo {
private int hora; // 0 - 23
private int minuto; // 0 - 59
private int segundo; // 0 - 59
Código

// un objeto de formato para compartir en toString y
// StringUniversal
private static DecimalFormat dosDigitos = new
DecimalFormat ( "00" );
// el constructor de Tiempo inicializa cada variable de
// instancia en cero;
// se asegura que cada objeto Tiempo inicie en un estado
// consistente
public Tiempo ( ) {
this ( 0, 0, 0 ); // invocar al constructor de Tiempo
// con tres argumentos
}
Código

public Tiempo ( int h ) {
this ( h, 0, 0 );
}
public Tiempo ( int h, int m ) {
this ( h, m, 0 );
}
public Tiempo ( int h, int m, int s ) {
establecerTiempo ( h, m, s );
}
public Tiempo ( Tiempo tiempo ) {
this ( tiempo.obtenerHora ( ), tiempo.obtenerMinuto ( ),
tiempo.obtenerSegundo ( ) );
}
Código

// Métodos Establecer
public void establecerTiempo ( int h, int m, int s ) {
establecerHora ( h ); // establecer la hora
establecerMinuto ( m ); // establecer el minuto
establecerSegundo ( s ); // establecer el segundo
}
public void establecerHora ( int h ) {
hora = ( ( h >= 0 && h < 24 ) ? h : 0 );
}
public void establecerMinuto ( int m ) {
minuto = ( ( m >= 0 && m < 60 ) ? m : 0 );
}
public void establecerSegundo ( int s ) {
segundo = ( ( s >= 0 && s < 60 ) ? s : 0 );
}
Código

// Métodos Obtener
public int obtenerHora ( ) { // obtener valor de hora
return hora;
}
public int obtenerMinuto ( ) { // obtener valor de minuto
return minuto;
}
public int obtenerSegundo ( ) { // obtener valor de segundo
return segundo;
}
Código

// convertir a String en formato de hora universal
public String aStringUniversal ( ) {
return dosDigitos.format ( obtenerHora ( ) ) + ":"
+ dosDigitos.format ( obtenerMinuto ( ) ) + ":"
+ dosDigitos.format ( obtenerSegundo ( ) );
}
// convertir a String en formato de hora estándar
public String toString ( ) {
return (( obtenerHora ( ) == 12 || obtenerHora ( ) == 0) ?
12 : obtenerHora ( ) % 12 ) + ":" +
dosDigitos.format ( obtenerMinuto ( ) )
+ ":" + dosDigitos.format ( obtenerSegundo ( ) )
+ ( obtenerHora ( ) < 12 ? " AM" : " PM" );
}
} // fin de la clase Tiempo
Código

package ventanapruebatiempo;
// Declaraciones de clase interna utilizadas para crear
// manejadores de eventos.
import java.awt.*;
public class VentanaPruebaTiempo extends JFrame {
private Tiempo tiempo;
private JLabel horaEtiqueta, minutoEtiqueta, segundoEtiqueta;
private JTextField horaCampo, minutoCampo, segundoCampo,
pantallaCampo;
private JButton salirBoton;
Código

// configurar GUI
public VentanaPruebaTiempo ( ) {
super ( "Demostración de clase interna" );
tiempo = new Tiempo ( ); // crear objeto Tiempo
// preparar horaEtiqueta y horaCampo
horaEtiqueta = new JLabel ( "Ajuste hora" );
horaCampo = new JTextField ( 10 );
contenedor.add ( horaEtiqueta );
contenedor.add ( horaCampo );
Código

// preparar minutoEtiqueta y minutoCampo
minutoEtiqueta = new JLabel ( "Ajuste minuto" );
minutoCampo = new JTextField ( 10 );
contenedor.add ( minutoEtiqueta );
contenedor.add ( minutoCampo );
// preparar segundoEtiqueta y segundoCampo
segundoEtiqueta = new JLabel ( "Ajuste segundo" );
segundoCampo = new JTextField ( 10 );
contenedor.add ( segundoEtiqueta );
contenedor.add ( segundoCampo );
// establecer pantallaCampo
pantallaCampo = new JTextField ( 30 );
pantallaCampo.setEditable ( false );
contenedor.add ( pantallaCampo );
Código

// establecer salirBoton
salirBoton = new JButton ( "Salir" );
contenedor.add ( salirBoton );
// crear una instancia de la clase interna ActionEventHandler
ActionEventHandler manejador = new ActionEventHandler ( );
// registrar manejadores de eventos; el objeto referenciado
// por manejador es el ActionListener, el cual contiene el
// método actionPerformed que será llamado para manejar
// los eventos de acción generados por horaCampo,
// minutoCampo, segundoCampo y salirBoton
horaCampo.addActionListener ( manejador );
minutoCampo.addActionListener ( manejador );
segundoCampo.addActionListener ( manejador );
salirBoton.addActionListener ( manejador );
} // fin del constructor
Código

// mostrar tiempo en pantallaCampo
public void mostrarTiempo ( ) {
pantallaCampo.setText ( "La hora es: " + tiempo );
}
// iniciar aplicación: crear, ajustar tamaño y mostrar
// VentanaPruebaTiempo; cuando main termina, el programa
// continua ejecutándose ya que se muestra una ventana
// mediante las instrucciones en main
VentanaPruebaTiempo ventana = new
VentanaPruebaTiempo ( );
ventana.setSize ( 400, 140 );
ventana.setVisible ( true );
} // fin de main
Código

// declaración de clase interna para manejar eventos JTextField
// y JButton
private class ActionEventHandler implements ActionListener {
// método para manejar eventos de acción
// el usuario oprimió salirBoton
if ( evento.getSource ( ) == salirBoton ) {
System.exit ( 0 ); // terminar la aplicación
} // el usuario oprimió tecla Intro en horaCampo
else if ( evento.getSource ( ) == horaCampo ) {
tiempo.establecerHora ( Integer.parseInt (
evento.getActionCommand ( ) ) );
horaCampo.setText ( "" );
} // el usuario oprimió tecla Intro en minutoCampo
Código

else if ( evento.getSource ( ) == minutoCampo ) {
tiempo.establecerMinuto ( Integer.parseInt (
minutoCampo.setText ( "" );
} // el usuario oprimió tecla Intro en segundoCampo
else if ( evento.getSource ( ) == segundoCampo ) {
tiempo.establecerSegundo ( Integer.parseInt (
segundoCampo.setText ( "" );
}
mostrarTiempo ( ); // llamar a un método de la clase externa
} // fin del método actionPerformed
} // fin de la clase interna ActionEventHandler
} // fin de la clase VentanaPruebaTiempo
Código

Esta es una modificación del ejemplo anterior, la clase Tiempo es
igual, sólo se modifica la clase VentanaPruebaTiempo:
Ejemplo

package ventanapruebatiempo2;
import java.awt.*;
public class VentanaPruebaTiempo2 extends JFrame {
private Tiempo tiempo;
private JLabel horaEtiqueta, minutoEtiqueta, segundoEtiqueta;
private JTextField horaCampo, minutoCampo, segundoCampo,
pantallaCampo;
public VentanaPruebaTiempo2 ( ) {
super ( "Demostración de clase interna anónima" );
tiempo = new Tiempo ( ); // crear objeto Tiempo
crearGUI ( ); // configurar GUI
// configurar manejo eventos
registrarManejadoresDeEventos ( );
}
Código

// crear componentes de GUI y adjuntarlos al panel de contenido
private void crearGUI ( ) {
horaEtiqueta = new JLabel ( "Ajuste hora" );
horaCampo = new JTextField ( 10 );
contenedor.add ( horaEtiqueta );
contenedor.add ( horaCampo );
minutoEtiqueta = new JLabel ( "Ajuste minuto" );
minutoCampo = new JTextField ( 10 );
contenedor.add ( minutoEtiqueta );
contenedor.add ( minutoCampo );
Código

segundoEtiqueta = new JLabel ( "Ajuste segundo" );
segundoCampo = new JTextField ( 10 );
contenedor.add ( segundoEtiqueta );
contenedor.add ( segundoCampo );
pantallaCampo = new JTextField ( 30 );
pantallaCampo.setEditable( false );
contenedor.add ( pantallaCampo );
} // fin del método crearGUI
Código

// registrar manejadores de eventos para horaCampo,
// minutoCampo y segundoCampo
private void registrarManejadoresDeEventos ( ) {
// registrar manejador de eventos para horaCampo
horaCampo.addActionListener ( new ActionListener ( ) {
// clase interna anónima
tiempo.establecerHora ( Integer.parseInt (
horaCampo.setText ( "" );
mostrarTiempo ( );
}
} // fin de la clase interna anónima
); // fin de la llamada a addActionListener para horaCampo
Código

// registrar manejador de eventos para minutoCampo
minutoCampo.addActionListener (
new ActionListener ( ) { // clase interna anónima
tiempo.establecerMinuto ( Integer.parseInt (
minutoCampo.setText ( "" );
mostrarTiempo ( );
}
); // fin de la llamada a addActionListener para minutoCampo
Código

segundoCampo.addActionListener (
tiempo.establecerSegundo ( Integer.parseInt (
segundoCampo.setText ( "" );
mostrarTiempo ( );
}
); // fin de la llamada a addActionListener para segundoCampo
} // fin del método registrarManejadoresDeEventos
// mostrar tiempo en pantallaCampo
public void mostrarTiempo ( ) {
pantallaCampo.setText ( "La hora es: " + tiempo );
}
Código

// crear objeto VentanaPruebaTiempo2, registrarse para sus
// eventos de ventana
// y mostrarlo para empezar la ejecución de la aplicación
VentanaPruebaTiempo2 ventana = new
VentanaPruebaTiempo2 ( );
// registrar componente de escucha para evento
// windowClosing
ventana.addWindowListener (
// clase interna anónima para evento windowClosing
new WindowAdapter ( ) {
// terminar aplicación cuando usuario cierra la ventana
public void windowClosing ( WindowEvent evento ) {
System.exit ( 0 );
}
Código

); // fin de la llamada a addWindowListener para ventana
ventana.setSize ( 400, 105 );
ventana.setVisible ( true );
} // fin de main
} // fin de la clase VentanaPruebaTiempo2
Código

Producir la siguiente ventana:
Ejemplo sencillo manejo botones
Salida dependiendo del botón sobre el que se hace clic:

// Creación de objetos JButton.
import java.awt.*;
public class PruebaBoton extends JFrame {
private JButton botonSimple, botonElegante;
// configurar GUI
public PruebaBoton ( ) {
super ( "Prueba de botones" );
Código

// obtener panel de contenido y establecer su esquema
// crear botones
botonSimple = new JButton ( "Botón simple" );
contenedor.add ( botonSimple );
Icon insecto1 = new ImageIcon ( "insecto1.gif" );
Icon insecto2 = new ImageIcon ( "insecto2.gif" );
botonElegante = new JButton ( "Botón elegante",
insecto1 );
botonElegante.setRolloverIcon ( insecto2 );
contenedor.add ( botonElegante );
Código

// crear una instancia de la clase interna ManejadorBoton
// a usar para el manejo de eventos de botones
ManejadorBoton manejador = new ManejadorBoton ( );
botonElegante.addActionListener ( manejador );
botonSimple.addActionListener ( manejador );
setSize ( 300, 100 );
} // fin del constructor de PruebaBoton
Código

PruebaBoton aplicacion = new PruebaBoton ( );
}
// clase interna para el manejo de eventos de botón
private class ManejadorBoton implements ActionListener {
// manejar evento de botón
JOptionPane.showMessageDialog ( PruebaBoton.this,
"Usted oprimió: " + evento.getActionCommand ( )) ;
}
} // fin de la clase interna privada ManejadorBoton
} // fin de la clase PruebaBoton
Código

Al dar Valor1 y Valor2, dependiendo del botón seleccionado se
obtienen los siguientes resultados:
Ejemplo

Código
package opsbitsmisc;
// Uso de los operadores a nivel de bits.
import java.awt.*;
public class OpsBitsMisc extends JFrame {
private JTextField campoEntrada1, campoEntrada2,
campoBits1, campoBits2, campoBits3,
campoResultado;
private int valor1, valor2;

Código
// configurar GUI
public OpsBitsMisc ( ) { // constructor
super ( "Operadores a nivel de bits" );
JPanel panelEntrada = new JPanel ( );
panelEntrada.setLayout ( new GridLayout ( 4, 2 ) );
panelEntrada.add ( new JLabel ( "Escriba 2 enteros" ) );
panelEntrada.add ( new JLabel ( "" ) );
panelEntrada.add ( new JLabel ( "Valor 1" ) );
campoEntrada1 = new JTextField ( 8 );
panelEntrada.add ( campoEntrada1 );

Código
panelEntrada.add ( new JLabel ( "Valor 2" ) );
campoEntrada2 = new JTextField ( 8 );
panelEntrada.add ( campoEntrada2 );
panelEntrada.add ( new JLabel ( "Resultado" ) );
campoResultado = new JTextField ( 8 );
campoResultado.setEditable ( false );
panelEntrada.add ( campoResultado );
JPanel panelBits = new JPanel ( );
panelBits.setLayout ( new GridLayout ( 4, 1 ) );
panelBits.add ( new JLabel ( "Representaciones de bits" ) );

Código
Beginning Java
Ivor Horton
campoBits1 = new JTextField ( 33 );
campoBits1.setEditable ( false );
panelBits.add ( campoBits1 );
JPanel panelBotones = new JPanel ( );

Código
// botón para realizar operación con AND a nivel de bits
JButton botonAND = new JButton ( "AND" );
panelBotones.add ( botonAND );
botonAND.addActionListener (
// realizar op. AND a nivel de bits y mostrar resultados
establecerCampos ( );
campoResultado.setText ( Integer.toString ( valor1 &
valor2 ) );
campoBits3.setText ( obtenerBits ( valor1 & valor2 ) );
}

Código
// botón para realizar operación OR incluyente a nivel de bits
JButton botonORIncluyente = new JButton ( "OR
incluyente" );
panelBotones.add ( botonORIncluyente );
botonORIncluyente.addActionListener (
// realizar op. OR incluyente a nivel de bits y mostrar res.
campoResultado.setText ( Integer.toString ( valor1
| valor2 ) );
campoBits3.setText ( obtenerBits ( valor1 | valor2 ) );
}

Código
// botón para realizar operación OR excluyente a nivel de bits
JButton botonORExcluyente = new JButton ( "OR excluyente" );
panelBotones.add ( botonORExcluyente );
botonORExcluyente.addActionListener (
// realizar op. OR excluyente a nivel de bits y mostrar res.
campoResultado.setText ( Integer.toString ( valor1 ^
valor2 ) );
campoBits3.setText ( obtenerBits ( valor1 ^ valor2 ) );
}
Beginning Java
Ivor Horton

Código
// botón para realizar operación complemento a nivel de bits
JButton botonComplemento = new JButton ( "Complemento" );
panelBotones.add ( botonComplemento );
botonComplemento.addActionListener (
// realizar op. Comp. a nivel de bits y mostrar resultado
campoEntrada2.setText ( "" );
campoBits2.setText ( "" );
int valor = Integer.parseInt ( campoEntrada1.getText ( ) );
campoResultado.setText ( Integer.toString ( ~valor ) );
campoBits1.setText ( obtenerBits ( valor ) );
campoBits3.setText ( obtenerBits ( ~valor ) );
}

Código
contenedor.add ( panelEntrada, BorderLayout.WEST );
contenedor.add ( panelBits, BorderLayout.EAST );
contenedor.add ( panelBotones, BorderLayout.SOUTH );
setSize ( 600, 150 );
} // fin del constructor
// mostrar números y su forma en bits
private void establecerCampos ( ) {
valor1 = Integer.parseInt ( campoEntrada1.getText ( ) );
valor2 = Integer.parseInt ( campoEntrada2.getText ( ) );
campoBits1.setText ( obtenerBits ( valor1 ) );
campoBits2.setText ( obtenerBits ( valor2 ) );
}
// mostrar representación de bits del valor int especificado

Código
private String obtenerBits ( int valor ) {
// crear valor int con 1 en el bit más a la izquierda y
// 0s en las demás posiciones
int mascaraMostrar = 1 << 31;
StringBuffer bufer = new StringBuffer ( 35 ); // bufer p/salida
// para cada bit anexar 0 ó 1 al búfer
for ( int bit = 1; bit <= 32; bit++ ) { // usar mascaraMostrar
// para aislar bit
bufer.append ( ( valor & mascaraMostrar ) == 0 ? '0' : '1' );
valor <<= 1; // desplazar valor una posición a la izquierda
if ( bit % 8 == 0 ) {
bufer.append (' '); // anexar un espacio al búfer c/ 8 bits
} }
return bufer.toString ( );
} // fin del método obtenerBits

Código
OpsBitsMisc aplicacion = new OpsBitsMisc ( );
}
} // fin de la clase OpsBitsMisc

Ejemplo
Producir la siguiente interfaz usando campo de texto
(JTextField) y cajas de verificación (JCheckBox). Se trabajará
con fonts: negritas y cursivas.

Ejemplo
Dependiendo de la caja(s) de verificación se obtendrán los
siguientes cambios en el campo de texto:

Código
package pruebacasillaverificacion;
// Creación de botones JCheckBox.
import java.awt.*;
public class PruebaCasillaVerificacion extends JFrame {
private JTextField campo;
private JCheckBox negrita, cursiva;

Código
// configurar GUI
public PruebaCasillaVerificacion ( ) {
super ( "Prueba de JCheckBox" );
// configurar objeto JTextField y establecer su tipo de letra
campo = new JTextField ( "Observe el cambio en el estilo de
tipo de letra", 25 );
campo.setFont ( new Font ( "Serif", Font.PLAIN, 14 ) );
contenedor.add ( campo );

Código
// crear objetos casilla de verificación
negrita = new JCheckBox ( "Negrita" );
contenedor.add ( negrita );
cursiva = new JCheckBox ( "Cursiva" );
contenedor.add ( cursiva );
// registrar componentes de escucha para objetos JCheckBox
ManejadorCasillaVerificacion manejador = new
ManejadorCasillaVerificacion ( );
negrita.addItemListener ( manejador );
cursiva.addItemListener ( manejador );
setSize ( 300, 100 );
} // fin del constructor de PruebaCasillaVerificacion

Código
PruebaCasillaVerificacion aplicacion = new
PruebaCasillaVerificacion ( );
}
// clase interna para manejo de eventos de ItemListener
private class ManejadorCasillaVerificacion
implements ItemListener {
private int valNegrita = Font.PLAIN;
private int valCursiva = Font.PLAIN;
// responder a eventos de casilla de verificación

Código
public void itemStateChanged ( ItemEvent evento ) {
// procesar eventos de casilla de verificación negrita
if ( evento.getSource ( ) == negrita )
valNegrita = negrita.isSelected ( ) ? Font.BOLD :
Font.PLAIN;
// procesar eventos de casilla de verificación cursiva
if ( evento.getSource ( ) == cursiva )
valCursiva = cursiva.isSelected ( ) ? Font.ITALIC :
Font.PLAIN;
// establecer tipo de letra del campo de texto
campo.setFont ( new Font ( "Serif", valNegrita +
valCursiva, 14 ) );
} // fin del método itemStateChanged
} // fin de la clase interna privada ManejadorCasillaVerificacion
} // fin de la clase PruebaCasillaVerificacion

Ejemplo
Producir la siguiente interfaz usando campo de texto (JTextField)
y radio botones (JRadioButton). Se trabajará con fonts: simples,
negritas y cursivas.

Ejemplo
Dependiendo del botón seleccionado se obtendrán los
siguientes cambios en el campo de texto:

Código
package pruebabotonopcion;
// Creación de botones de opción, ButtonGroup y JRadioButton.
import java.awt.*;
public class PruebaBotonOpcion extends JFrame {
private JTextField campo;
private Font tipoLetraSimple, tipoLetraNegrita,
tipoLetraCursiva, tipoLetraNegritaCursiva;
private JRadioButton botonSimple, botonNegrita,
botonCursiva, botonNegritaCursiva;
private ButtonGroup grupoBotonesOpcion;

Código
// crear GUI y tipos de letra
public PruebaBotonOpcion ( ) {
super ( "Prueba de RadioButton" );
// establecer JTextField
campo = new JTextField ( "Observe cómo cambia el estilo del
tipo de letra", 30 );
contenedor.add ( campo );
// crear botones de opción

Código
botonSimple = new JRadioButton ( "Simple", true );
contenedor.add ( botonSimple );
botonNegrita = new JRadioButton ( "Negrita", false );
contenedor.add ( botonNegrita );
botonCursiva = new JRadioButton ( "Cursiva", false );
contenedor.add ( botonCursiva );
botonNegritaCursiva = new JRadioButton ( "Negrita/Cursiva",
false );
contenedor.add ( botonNegritaCursiva );

Código
// crear relación lógica entre objetos JRadioButton
grupoBotonesOpcion = new ButtonGroup ( );
grupoBotonesOpcion.add ( botonSimple );
grupoBotonesOpcion.add ( botonNegrita );
grupoBotonesOpcion.add ( botonCursiva );
grupoBotonesOpcion.add ( botonNegritaCursiva );
// crear objetos de tipo de letra
tipoLetraSimple = new Font ( "Serif", Font.PLAIN, 14 );
tipoLetraNegrita = new Font ( "Serif", Font., 14 );
tipoLetraCursiva = new Font ( "Serif", Font.BOLDITALIC, 14 );
tipoLetraNegritaCursiva = new Font ( "Serif", Font.BOLD +
Font.ITALIC, 14 );
campo.setFont ( tipoLetraSimple ); // establecer tipo de letra
// inicial

Código
// registrar eventos para objetos JRadioButton
botonSimple.addItemListener ( new ManejadorBotonOpcion (
tipoLetraSimple ) );
botonNegrita.addItemListener ( new ManejadorBotonOpcion (
tipoLetraNegrita ) );
botonCursiva.addItemListener ( new
ManejadorBotonOpcion( tipoLetraCursiva ) );
botonNegritaCursiva.addItemListener ( new
ManejadorBotonOpcion( tipoLetraNegritaCursiva ) );
setSize ( 350, 100 );
} // fin del constructor de PruebaBotonOpcion

Código
PruebaBotonOpcion aplicacion = new PruebaBotonOpcion ( );
}
// clase interna para manejar eventos de botón de opción
private class ManejadorBotonOpcion implements ItemListener {
private Font tipoDeLetra;
public ManejadorBotonOpcion ( Font f ) {
tipoDeLetra = f;
}

Código
// manejar eventos de botón de opción
campo.setFont ( tipoDeLetra );
}
} // fin de la clase interna privada ManejadorBotonOpcion
} // fin de la clase PruebaBotonOpcion

Ejemplo
Uso de un objeto JComboBox para seleccionar una de sus
opciones.

Ejemplo
Al dar clic sobre el componente, se puede seleccionar alguna de
las opciones:
Se usa la barra deslizadora para mostrar las demás opciones
y así seleccionar una dando clic sobre ella:

Código
package pruebacuadrocomb;
import java.awt.*;
public class PruebaCuadroComb extends JFrame {
private JComboBox cuadroCombImagenes;
private JLabel etiqueta;
private String nombres [ ] = { "insecto1.gif", "insecto2.gif",
"insectoviaje.gif", "insectanim.gif" };
private Icon iconos [ ] = { new ImageIcon ( nombres [ 0 ] ),
new ImageIcon ( nombres [ 1 ] ),
new ImageIcon ( nombres [ 2 ] ),
new ImageIcon ( nombres [ 3 ] ) };

Código
// configurar GUI
public PruebaCuadroComb ( ) {
super ( "Prueba de JComboBox" );
cuadroCombImagenes = new JComboBox ( nombres );
// para desplegar 3 filas
cuadroCombImagenes.setMaximumRowCount ( 3 );

Código
cuadroCombImagenes.addItemListener (
new ItemListener ( ) { // clase interna anónima
// manejar evento para JComboBox
// determinar si casilla de verificación está seleccionada
if( evento.getStateChange ( ) == ItemEvent.SELECTED ) {
etiqueta.setIcon ( iconos [
cuadroCombImagenes.getSelectedIndex ( ) ] );
}
}
); // fin de la llamada a addItemListener
contenedor.add ( cuadroCombImagenes );

Código
// establecer objeto JLabel para mostrar objetos ImageIcon
etiqueta = new JLabel ( iconos [ 0 ] );
contenedor.add ( etiqueta );
setSize ( 350, 150 );
} // fin del constructor de PruebaCuadroComb
PruebaCuadroComb aplicacion = new PruebaCuadroComb ( );
}
} // fin de la clase PruebaCuadroComb

Ejemplo
Uso de un objeto JList para seleccionar una de las opciones de
colores.

Ejemplo
Dependiendo de la selección de color, el área de la interfaz se
pinta de ese color:

Código
package pruebalista;
// Selección de colores de un objeto JList.
import java.awt.*;
import javax.swing.event.*;
public class PruebaLista extends JFrame {
private JList listaColores;
private Container contenedor;

Código
private final String nombresColores [ ] = { "Negro", "Azul",
"Cyan", "Gris oscuro", "Gris", "Verde", "Gris claro",
"Magenta", "Naranja", "Rosa", "Rojo", "Blanco",
"Amarillo" };
private final Color colores [ ] = { Color.BLACK, Color.BLUE,
Color.CYAN, Color.DARK_GRAY, Color.GRAY,
Color.GREEN, Color.LIGHT_GRAY,
Color.MAGENTA, Color.ORANGE, Color.PINK,
Color.RED, Color.WHITE, Color.YELLOW };
// configurar GUI
public PruebaLista ( ) {
super ( "Prueba de JList" );

Código
contenedor = getContentPane ( );
// crear una lista con elementos del arreglo nombresColores
listaColores = new JList ( nombresColores );
listaColores.setVisibleRowCount ( 5 );
// no permitir selecciones múltiples
listaColores.setSelectionMode (
ListSelectionModel.SINGLE_SELECTION );
// agregar un objeto JScrollPane, que contiene a JList, al
// panel de contenido
contenedor.add ( new JScrollPane ( listaColores ) );

Código
listaColores.addListSelectionListener (
new ListSelectionListener ( ) { // clase interna anónima
// manejar eventos de selección en la lista
public void valueChanged ( ListSelectionEvent evento ) {
contenedor.setBackground (
colores [ listaColores.getSelectedIndex ( ) ] );
}
); // fin de la llamada a addListSelectionListener
setSize ( 350, 150 );
} // fin del constructor de PruebaLista

Código
PruebaLista aplicacion = new PruebaLista ( );
}
} // fin de la clase PruebaLista

Manejo de ratón
Java How to Program
Deitel y Deitel
Prentice Hall

Ejemplo
Crear la siguiente interfaz para demostrar el manejo de ratón.

Ejemplo
Y al mover el ratón se pueden presentar los siguiente mensajes:
 Ratón fuera de la ventana – cuando el ratón sale del área y la
interfaz se pinta en blanco
 Ratón entro en – cuando el ratón entra al área y la interfaz se
pinta de verde

Ejemplo
 Se movió en – cuando el usuario mueve el ratón
 Se oprimió en – cuando se oprime el botón del ratón

Ejemplo
 Se hizo clic en – cuando el botón del ratón se suelta
inmediatamente después de oprimir
 Se soltó en – cuando se suelta el ratón después de arrastrar
 Se arrastró en – cuando el usuario arrastra el ratón con el botón
oprimido

Código
package rastreadorraton;
// Demostración de los eventos de ratón.
import java.awt.*;
public class RastreadorRaton extends JFrame
implements MouseListener,
MouseMotionListener {
private JLabel barraEstado;

Código
// configurar GUI y registrar manejadores de eventos de ratón
public RastreadorRaton ( ) {
super ( "Demostración de los eventos de ratón" );
barraEstado = new JLabel ( );
getContentPane ( ).add ( barraEstado, BorderLayout.SOUTH );
addMouseListener ( this ); // escucha sus propios eventos de
// ratón
addMouseMotionListener ( this ); // y de movimiento de ratón
setSize ( 300, 125 );
}

Código
// Manejadores de eventos de MouseListener
// manejar el evento cuando el botón del ratón se suelta
// inmediatamente después de oprimir
public void mouseClicked ( MouseEvent evento ) {
barraEstado.setText ( "Se hizo clic en [" + evento.getX ( )
+ ", " + evento.getY ( ) + "]" );
}
// manejar evento cuando se oprime el botón del ratón
public void mousePressed ( MouseEvent evento ) {
barraEstado.setText ( "Se oprimió en [" + evento.getX ( )
+ ", " + evento.getY ( ) + "]" );
}

Código
// manejar evento cuando se suelta el ratón después de arrastrar
public void mouseReleased ( MouseEvent evento ) {
barraEstado.setText ( "Se soltó en [" + evento.getX ( )
+ ", " + evento.getY ( ) + "]" );
}
// manejar el evento cuando el ratón entra al área
public void mouseEntered ( MouseEvent evento ) {
barraEstado.setText ( "Ratón entro en [" + evento.getX ( )
+ ", " + evento.getY ( ) + "]" );
getContentPane ( ).setBackground ( Color.GREEN );
}

Código
// manejar evento cuando el ratón sale del área
public void mouseExited ( MouseEvent evento ) {
barraEstado.setText ( "Ratón fuera de la ventana" );
getContentPane ( ).setBackground ( Color.WHITE );
}
// Manejadores de eventos de MouseMotionListener
// manejar el evento cuando el usuario arrastra el ratón con el
// botón oprimido
public void mouseDragged ( MouseEvent evento ) {
barraEstado.setText ( "Se arrastró en [" + evento.getX ( )
+ ", " + evento.getY ( ) + "]" );
}

Código
// manejar el evento cuando el usuario mueve el ratón
public void mouseMoved ( MouseEvent evento ) {
barraEstado.setText ( "Se movió en [" + evento.getX ( )
+ ", " + evento.getY ( ) + "]" );
}
RastreadorRaton aplicacion = new RastreadorRaton ( );
}
} // fin de la clase RastreadorRaton

Manejo de eventos de tecla
La interfaz utilizada para el manejo de estos eventos es
KeyListener, que se generan cuando se pulsan y sueltan las
teclas del teclado.
La clase manejadora de estos eventos que implemente
KeyListener debe proporcionar declaraciones para los
métodos keyPressed, keyReleased y keyTyped, cada uno de
los cuales recibe un objeto de clase KeyEvent como
argumento, la cual es una subclase de InputEvent.

Métodos de eventos de tecla
 keyPressed – se llama en respuesta a presionar cualquier
tecla.
 keyTyped – se llama en respuesta a presionar cualquier
tecla que no sea una tecla de acción. (Las teclas de acción
son cualquier tecla de flecha, Home, End, Page Up, Page
Down, cualquier tecla de función, etc.)
 keyRelease – se llama cuando la tecla se libera después de
cualquier evento keyPressed o keyTyped.

Ejemplo
Definir la siguiente interfaz para demostrar los eventos de
pulsación de tecla.

Ejemplo
Se pueden obtener los siguientes resultados:

Código
package demoteclas;
import java.awt.*;
public class DemoTeclas extends JFrame implements KeyListener {
private String linea1 = "", linea2 = "", linea3 = "";
private JTextArea areaTexto;
// configurar GUI
public DemoTeclas ( ) {
super ( "Demostración de eventos de pulsación de tecla" );

Código
// establecer objeto JTextArea
areaTexto = new JTextArea ( 10, 15 );
areaTexto.setText ( "Oprima cualquier tecla en el teclado..." );
areaTexto.setEnabled ( false ); // no permite editar
// para cambiar color del texto para hacerlo visible
areaTexto.setDisabledTextColor ( Color.BLACK );
getContentPane ( ).add ( areaTexto );
addKeyListener ( this ); // permitir al marco procesar eventos de
// teclas
setSize ( 350, 100 );
} // fin del constructor de DemoTeclas

Código
// manejar evento de pulsación de cualquier tecla
public void keyPressed ( KeyEvent evento ) {
// getKeyText devuelve cadena con nombre de tecla presionada
// getKeyCode obtiene código de tecla virtual de la tecla pulsada
linea1 = "Se oprimió tecla: " + evento.getKeyText (
evento.getKeyCode ( ) );
establecerLineas2y3 ( evento );
}
// manejar evento de liberación de cualquier tecla
public void keyReleased ( KeyEvent evento ) {
linea1 = "Se soltó tecla: " + evento.getKeyText (
evento.getKeyCode ( ) );
}

Código
// manejar evento de pulsación de una tecla de acción
// GetKeyChar devuelve valor Unicode del carácter escrito.
public void keyTyped ( KeyEvent evento ) {
linea1 = "Se escribió tecla: " + evento.getKeyChar ( );
}
// establecer segunda y tercera líneas de salida
private void establecerLineas2y3 ( KeyEvent evento ) {
linea2 = "Esta tecla " + ( evento.isActionKey ( ) ? "" : "no " ) +
"es una tecla de acción";
// getKeyModifiersText - nombres de las teclas modificadoras
// presionadas.
String temp = evento.getKeyModifiersText (
evento.getModifiers ( ) );

Código
linea3 = "Teclas modificadoras oprimidas: " +
( temp.equals ( "" ) ? "ninguna" : temp );
areaTexto.setText ( linea1 + "n" + linea2 + "n" + linea3 + "n" );
}
DemoTeclas aplicacion = new DemoTeclas ( );
}
}

Clases adaptadoras
Una clase adaptadora es un término para una clase que
implementa una interfaz de escucha con métodos que no
tienen contenido, por lo que no hacen nada. La idea es
permitir derivar la clase propia de oyente de cualesquiera de
las clases del adaptador que se proporcionan y después
aplicar solamente los métodos de interés. La clase de
adaptador MouseInputAdapter que se define en el paquete
javax.swing.event define los métodos para la interfaz
MouseInputListener.

Clases adaptadoras
Hay también otras cinco clases de adaptadores definidas en el
paquete java.awt.event que cubren los métodos en las otras
interfaces de escucha de bajo nivel:
FocusAdapter WindowAdapter KeyAdapter
MouseAdapter MouseMotionAdapter MouseInputAdapter
La clase WindowAdapter implementa todos los métodos
declarados en las interfaces WindowListener,
WindowFocusListener y WindowStateListener. Las otras cinco
clases de adaptadores implementan cada uno de los métodos
en la interfaz de escucha correspondiente.

2TAP Tema 1-Eventos.pptx

Recomendados

Recomendados

Más contenido relacionado

Similar a 2TAP Tema 1-Eventos.pptx

Similar a 2TAP Tema 1-Eventos.pptx (20)

Último

Último (20)

2TAP Tema 1-Eventos.pptx