Taller VI Modulo IV Cuatro 4

INSTITUTO de TECNOLOGÍA O. R. T.
Analista de Sistemas de Computación

Instituto Incorporado a la Enseñanza Oficial (A-763) Taller de Computación VI
Yatay 240 - Buenos Aires - República Argentina
Asignatura
Taller de Computación VI
Módulo IV
AWT, SWING y Eventos
Elaboración
Hugo Sanoguera, Fabián Gentile
Este material pertenece a la materia Taller de Computación VI, de la Carrera de Analista de Sistemas de
Computación del INSTITUTO DE TECNOLOGÍA ORT.
Todos los derechos reservados. No está permitida la reproducción total o parcial de este apunte, ni su
tratamiento informático, ni la transmisión de ninguna forma o por cualquier medio, ya sea electrónico,
mecánico, por fotocopia, por registro u otros métodos, sin el permiso previo de los titulares.
1ra edición Septiembre de 2007.
1
INSTITUTO de TECNOLOGÍA O. R. T. Analista de Sistemas de Computación
UNIDAD DIDÁCTICA IV
ÍNDICE
UNIDAD DIDÁCTICA IV ________________________________________________________ 1
ÍNDICE ____________________________________________________________________________ 1
Introducción y orientaciones para el estudio______________________________________________ 2
Objetivos ___________________________________________________________________________ 2
Aclaraciones previas al estudio _________________________________________________________ 2
AWT ______________________________________________________________________________ 3
Introducción al AWT _______________________________________________________________________ 3
Interfase de Usuario ________________________________________________________________________ 3
Estructura del AWT ________________________________________________________________________ 4
Componentes y Contenedores_________________________________________________________________ 4
Primer ejemplo de una aplicación grafica AWT___________________________________________ 6
Modelo de manejo de eventos __________________________________________________________ 7
Ejemplo de 4 maneras diferentes de manejar de eventos en una aplicación grafica AWT-SWING 10
Clases del AWT __________________________________________________________________________ 14
LAYOUT MANAGERS ___________________________________________________________________ 16
LA CLASE Event___________________________________________________________________ 18
TIPOS DE EVENTOS _______________________________________________________________ 19
Eventos de Ventana ________________________________________________________________________ 19
Eventos de Teclado ________________________________________________________________________ 19
Eventos de Ratón__________________________________________________________________________ 19
Eventos de Barras _________________________________________________________________________ 19
Eventos de Lista __________________________________________________________________________ 19
Eventos Varios ___________________________________________________________________________ 19
CREAR MENUS Y BARRAS DE MENUS______________________________________________ 20
1
Introducción y orientaciones para el estudio

En el desarrollo de este módulo abordaremos:
Awt y Swing.
Contenedores y componentes en java.
Eventos en java.
Creación de un programa en Java con manejo de Interfaz grafica y eventos.
Objetivos
Pretendemos que al finalizar de estudiar esta Unidad, el alumno logre:
Conocer como crear una aplicación grafica AWT.

Conocer los distintos componentes y contenedores de la clase AWT.
Tener una primera aproximación al manejo de eventos.
Conocer los distintos eventos que se generan de las componentes de la clase AWTEvent.
Poder realizar una primera aplicación grafica con manejo básico de eventos, desde su
escritura hasta su ejecución,
Aclaraciones previas al estudio

En este módulo, usted encontrará:
Contenidos
Conceptualizaciones centrales
Bibliografía
Referencia de material bibliográfico recomendado
Actividades
Usted debe tener presente que los contenidos presentados en el módulo

no ahondan profundamente en el tema, sino que pretenden ser un recurso
motivador, para que a través de la lectura del material, la bibliografía
sugerida, y el desarrollo de las actividades propuestas alcance los
objetivos planteados en el presente módulo.
2
AWT
Introducción al AWT
De la pagina (http://www.cienciasmisticas.com.ar/informatica/programacion/java/index.php)
AWT es el acrónimo del X Window Toolkit para Java, donde X puede ser cualquier cosa:
Abstract, Alternative, Awkward; aunque parece que Sun se decanta por Abstracto,
seriedad por encima de todo. Se trata de una biblioteca de clases Java para el desarrollo
de Interfaces de Usuario Gráficas. La versión del AWT que Sun proporciona con el JDK
se desarrolló en sólo dos meses y es la parte más débil de todo lo que representa Java
como lenguaje. El entorno que ofrece es demasiado simple, no se han tenido en cuenta
las ideas de entornos gráficos novedosos, sino que se ha ahondado en estructuras
orientadas a eventos, llenas de callbacks y sin soporte alguno del entorno para la
construcción gráfica; veremos que la simple acción de colocar un dibujo sobre un botón se
vuelve una tarea complicada. Quizá la presión de tener que lanzar algo al mercado haya
tenido mucho que ver en la pobreza de AWT.
JavaSoft, asegura que esto sólo era el principio y que AWT será multi-idioma, tendrá
herramientas visuales, etc. En fin, al igual que dicen los astrólogos, el futuro nos deparará
muchas sorpresas.
La estructura básica del AWT se basa en Componentes y Contenedores. Estos últimos

contienen Componentes posicionados a su respecto y son Componentes a su vez, de
forma que los eventos pueden tratarse tanto en Contenedores como en Componentes,
corriendo por cuenta del programador el encaje de todas las piezas, así como la
seguridad de tratamiento de los eventos adecuados.
No obstante y pese a ello, vamos a abordar en este momento la programación con el

AWT para tener la base suficiente y poder seguir profundizando en las demás
características del lenguaje Java, porque como vamos a ir presentando ejemplos gráficos
es imprescindible el conocimiento del AWT.
Interfase de Usuario
La interfase de usuario es la parte del programa que permite a éste interactuar con el
usuario. Las interfaces de usuario pueden adoptar muchas formas, que van desde la
simple línea de comandos hasta las interfaces gráficas que proporcionan las aplicaciones
más modernas.
La interfase de usuario es el aspecto más importante de cualquier aplicación. Una

aplicación sin un interfaz fácil, impide que los usuarios saquen el máximo rendimiento del
programa. Java proporciona los elementos básicos para construir decentes interfaces de
usuario a través del AWT.
Al nivel más bajo, el sistema operativo transmite información desde el ratón y el teclado
como dispositivos de entrada al programa. El AWT fue diseñado pensando en que el
programador no tuviese que preocuparse de detalles como controlar el movimiento del
ratón o leer el teclado, ni tampoco atender a detalles como la escritura en pantalla. El
AWT constituye una librería de clases orientada a objeto para cubrir estos recursos y
servicios de bajo nivel.
3
Debido a que el lenguaje de programación Java es independiente de la plataforma en que
se ejecuten sus aplicaciones, el AWT también es independiente de la plataforma en que
se ejecute. El AWT proporciona un conjunto de herramientas para la construcción de
interfaces gráficas que tienen una apariencia y se comportan de forma semejante en
todas las plataformas en que se ejecute. Los elementos de interface proporcionados por
el AWT están implementados utilizando toolkits nativos de las plataformas, preservando
una apariencia semejante a todas las aplicaciones que se creen para esa plataforma. Este
es un punto fuerte del AWT, pero también tiene la desventaja de que una interface gráfica
diseñada para una plataforma, puede no visualizarse correctamente en otra diferente.
Estructura del AWT
La estructura de la versión actual del AWT podemos resumirla en los puntos que
exponemos a continuación:
• Los Contenedores contienen Componentes, que son los controles básicos

• No se usan posiciones fijas de los Componentes, sino que están situados a través
de una disposición controlada (layouts).
• El común denominador de más bajo nivel se acerca al teclado, ratón y manejo de
eventos.
• Alto nivel de abstracción respecto al entorno de ventanas en que se ejecute la
aplicación (no hay áreas cliente, ni llamadas a X, ni hWnds, etc.)
• La arquitectura de la aplicación es dependiente del entorno de ventanas, en vez de
tener un tamaño fijo.
• Es bastante dependiente de la máquina en que se ejecuta la aplicación (no puede
asumir que un diálogo tendrá el mismo tamaño en cada máquina)
• Carece de un formato de recursos. No se puede separar el código de lo que es
propiamente interfase. No hay ningún diseñador de interfaces (todavía)
Componentes y Contenedores
Una interfase gráfica está construida en base a elementos gráficos básicos, los
Componentes. Típicos ejemplos de estos Componentes son los botones, barras de
desplazamiento, etiquetas, listas, cajas de selección o campos de texto. Los
Componentes permiten al usuario interactuar con la aplicación y proporcionar información
desde el programa al usuario sobre el estado del programa. En el AWT, todos los
Componentes de la interfase de usuario son instancias de la clase Component o uno de
sus subtipos.
Los Componentes no se encuentran aislados, sino agrupados dentro de Contenedores.

Los Contenedores contienen y organizan la situación de los Componentes; además, los
Contenedores son en sí mismos Componentes y como tales pueden ser situados dentro
de otros Contenedores. También contienen el código necesario para el control de
eventos, cambiar la forma del cursor o modificar el icono de la aplicación. En el AWT,
todos los Contenedores son instancias de la clase Container o uno de sus subtipos.
Los Componentes deben circunscribirse dentro del Contenedor que los contiene. Esto
hace que el anidamiento de Componentes (incluyendo Contenedores) en Contenedores
crean árboles de elementos, comenzando con un Contenedor en la raíz del árbol y
expandiéndolo en sus ramas.
4
Superclases comunes de muchos componentes Awt y swing
El paquete java.awt contiene clases que generan componentes GUI. En la figura se

observa un resumen de los componentes.
La figura muestra los manejadores de Layout por defecto.
Frame tendrá por defecto BorderLayout y Panel tendrá FlowLayout .

Si seteamos el layout en null (con setLayout) podremos colocar los componentes en
forma manual indicando sus coordenadas (con setBounds).
5
Primer ejemplo de una aplicación grafica AWT

(Posee una ventana y la posibilidad de cerrarla a través del botón de cierre de Windows)
package ejemplo_01; Importa la clase Frame de AWT para dibujar

ventanas
import java.awt.Frame;
import java.awt.event.WindowAdapter; Importa la clase event de AWT para manejar
import java.awt.event.WindowEvent; eventos
public class Ventana1 extends Frame {

Llama al constructor de Frame
private static final long serialVersionUID = 1L;
y le pasa el titulo de la ventana
Ventana1(){
super("Ventana 1");
setBounds(0,0,640,480);
Setea el tamaño de la ventana
addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent e){
System.exit(0);
} Este código es una clase
} interna y se codifica para
); poder responder al evento
} que se genera al clickear en
una ventana para cerrarla.
Se explicará más adelante
public static void main(String[] args){
Ventana1 v= new Ventana1();
v.setVisible(true);
}
} Crea un objeto de clase
Ventana y la hace visible
6
Modelo de manejo de eventos

Las GUI están controladas por eventos(es decir, generan eventos cuando el usuario del programa
interactúa con la GUI).
Las interacciones más comunes son: mover el mouse, hacer un clic con el mouse, clic en un
botón, escribir en un campo de texto, seleccionar un elemento del menú, cerrar una ventana, etc.
Siempre que ocurre una interacción se envía un evento al programa. La información de los
eventos se almacena en un objeto de la clase AWTEvent. En la figura siguiente se muestra la
jerarquía de las clases de eventos que hay en el paquete java.awt.event.
Interfaces que escuchan eventos del paquete java.awt.event
En los componentes de la clase java.swing se siguen utilizando los eventos de java.awt.event y

los que se agregaron están en java.swing.event.
Para procesar un evento de interfaz grafica de usuario, el programador debe realizar dos tareas
claves:
1- registrar un componente que escucha eventos.

2- implementar una manejador de eventos.
Un componente que escucha eventos GUI es un objeto de una clase que implementa una o más
interfaces que escuchan eventos correspondientes a los paquetes java.awt.event y
java.swing.event.
7
Muchos de los tipos de estos componentes son comunes para AWT y SWING. Estos tipos se
definen en el paquete java.awt.event (ver figura anterior). Los demás (adicionales) están en el
paquete java.swing.event.
Un componente “escucha” tipos específicos de eventos generados en el mismo objeto, o
generados por otros objetos (componentes GUI) en un programa.
Un manejador de eventos es un método que se invoca automáticamente en repuesta a un tipo

específico de evento. Cada interfaz que escucha eventos especifica uno o más métodos
manejadores de eventos que deben definirse en la clase que implementa a la interfaz (las
interfaces definen métodos abstract)
Cualquier clase que implementa a una interfaz deberá definir todos los métodos de esa interfaz;
caso contrario, será una clase abstracta y no podrá utilizarse para crear objetos. Al uso de
componentes que escuchan eventos en el manejo de eventos se conoce como modelo de
delegación de eventos; el procesamiento de un evento se delega a un objeto específico en el
programa.
Cuando ocurre un evento, el componente GUI que interactuó con el usuario notifica a sus
componentes de escucha registrados por medio de una llamada al método manejador de eventos
apropiado a cada componente de escucha.
Por ejemplo, cuando el usuario oprime la tecla Enter en un objeto TextField, se hace una llamada
al método actionPerformed del componente de escucha registrado.
Para cada categoría de eventos hay una interfase que tiene que ser implementada por la clase de
los objetos que quieren recibir los eventos. Esa interfaz requiere que uno o más métodos estén
bien definidos. Estos métodos son llamados cuando un evento en particular se genera.
La siguiente tabla lista esas categorías y las interfaces.
8
Componentes y eventos
La siguiente tabla nos muestra los componentes del AWT y los eventos de cada uno de ellos, así
como una breve explicación de en qué consiste cada tipo de evento.
Component Eventos generados Significado
Button ActionEvent Hacer click en el botón
Checkbox ItemEvent Seleccionar o deseleccionar un item.
CheckboxMenuItem ItemEvent Seleccionar o deseleccionar un item.
Choice ItemEvent Seleccionar o deseleccionar un item.
Mover, cambiar tamaño, mostrar u ocultar un
Component ComponentEvent
componente.
FocusEvent Obtener o perder el focus.
KeyEvent Pulsar o soltar una tecla.
Pulsar o soltar un botón del ratón; entrar o salir de un
MouseEvent componente; mover o arrastrar el ratón (tener en
cuenta que este evento tiene dos Listener).
Container ContainerEvent Añadir o eliminar un componente de un container.
List ActionEvent Hacer doble click sobre un item de la lista.
ItemEvent Seleccionar o deseleccionar un item de la lista.
MenuItem ActionEvent Seleccionar un item de un menú.
Scrollbar AdjustementEvent Cambiar el valor de la scrollbar.
TextComponent TextEvent Cambiar el texto.
TextField ActionEvent Terminar de editar un texto pulsando intro.
Acciones sobre una ventana: abrir, cerrar, restablecer e
Window WindowEvent
iniciar el cierre.
Se debe tomar en cuenta que los eventos propios de una super-clase pueden afectar también a
los componentes de sus sub-clases. Por ejemplo, la clase TextArea no tiene ningún evento
específico o propio, pero puede recibir los de su super-clase TextComponent.
Eventos que generan los distintos componentes del AWT.
9
Ejemplo de 4 maneras diferentes de manejar de eventos en una
aplicación grafica AWT-SWING
package demo.awt;
Este código importa todos los
import java.awt.AWTEvent; componentes que se van a utilizar
import java.awt.Button; junto con el manejo de los eventos que
import java.awt.Color; estos pueden generar de la clase awt
import java.awt.Component;
Podría resumirse en dos instrucciones
import java.awt.Cursor;
import java.awt.*;
import java.awt.Event;
import java.awt.event.*;
import java.awt.Frame;
import java.awt.Label;
import java.awt.TextField;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;
Este código importa el componente
Panel de opción de otra clase grafica
import javax.swing.JOptionPane; que es swing
public class Demo extends Frame {

private static final long serialVersionUID = 1;
public Demo() {
super("Ejemplo");
t6Init();
} Se setea a null el Layout para manejar la
disposición de los elementos gráficos en
forma manual con setBounds
private void t6Init() {
setLayout(null);
setBounds(0, 0, 600, 480); Se setea el color de fondo y la letra
setBackground(Color.ORANGE);
setForeground(Color.RED); Este código es una
addWindowListener( new WindowAdapter() { clase interna y se
public void windowClosing(WindowEvent evt) { codifica para poder
System.exit(0); responder al evento
} que se genera al
clickear en una
} ); ventana para
cerrarla.
Button btn;
// Botones que modifican el título de la ventana
// El evento utilizado es Demo.action(); Crea los botones del 0 al 9
for (int i = 0; i < 10; i++) { Observar que se utiliza una
btn = new Button(String.valueOf(i)); sola variable btn para crear
todos los botones
add(btn);
btn.setName("titulo");
btn.setBounds(30 * (i + 1), 50, 25, 25); Los asocia al Frame
}
Les asigna un nombre a
todos llamado “titulo”
Los posiciona en la pantalla
10
// Botón que pide confirmación para cerrar la aplicación

// El evento utilizado es una clase interna al evento.
btn = new Button("Salir 1"); Crea un botón
add(btn); Lo asocia al Frame
btn.setName("salir_con_mensaje");
btn.setBounds(30 * 11, 50, 55, 25); lo posiciona en la ventana
1)El evento se btn.addActionListener(new ActionListener() {
maneja a través
de una clase
public void actionPerformed(ActionEvent evt) {
interna que int n = JOptionPane.showConfirmDialog(Demo.this,
posee el método "¿Desea salir?", // sobre cual es modal!
actionPerformed "Confirme la salida", JOptionPane.YES_NO_OPTION);
el cual trata al if (n == JOptionPane.YES_OPTION)
evento generado System.exit(0);
al presionar sobre
algún botón del
}
panel });
Crea un objeto de clase
swing y si el evento es el
generado por el botón YES
termina la aplicación
// Botón que cierra la aplicación
// El evento utilizado es la clase interna EventHandler.actionPerformed().
btn = new Button("Salir 2"); 2)El evento se maneja a

add(btn); través de una clase escrita
por el programador
btn.setName("salir_directamente"); llamada EventHandler
btn.setBounds(30 * 13, 50, 55, 25); que implementa
btn.addActionListener(new EventHandler()); ActionListener
posee el método
actionPerformed el cual
trata al evento generado al
Crea un cuadro de texto presionar sobre el botón
Salir 2 del panel
// Agrega un TextField que solamente admite números

TextField txt = new TextField("Escribí solamente números");
add(txt); Lo asocia al Frame
txt.setBounds(30, 85, 200, 25);
txt.setBackground(Color.YELLOW);
txt.setForeground(Color.MAGENTA);
txt.addKeyListener(new KeyAdapter() { lo posiciona en la ventana
public void keyPressed(KeyEvent evt) {
char c = evt.getKeyChar();
if (c >= KeyEvent.VK_SPACE &&
(c < KeyEvent.VK_0 || c > KeyEvent.VK_9)) {
evt.consume();// sacar el evento de la cola consumo
//la tecla no se sigue notificando las que no validan
}
}
});
3)El evento se maneja a través de una clase interna que posee

un método keyPressed el cual trata al evento generado al
presionar sobre las teclas
Luego valida que solo sean números y saca el evento de la cola
consumiendo las teclas que no validan.
11
Crea un cuadro de texto

// Agrega un TextField deshabilitado Lo asocia al Frame
txt = new TextField("TextField deshabilitado!");
add(txt);
txt.setBounds(250, 85, 200, 25); lo posiciona en la ventana
txt.setBackground(Color.MAGENTA);
txt.setForeground(Color.BLUE); Deshabilita el cuadro de texto
txt.setEnabled(false);
Crea una etiqueta
// Agrega un Label
Label lbl = new Label("Este frame fue realizado a modo de ejemplo. El cursor
es una manito!"); La asocia al Frame
add(lbl); Cambia el cursor default por una mano
lbl.setForeground(Color.BLUE);
lbl.setCursor(new Cursor(Cursor.HAND_CURSOR));
lbl.setBounds(30, 120, 400, 25); la posiciona en la ventana
}
4)Viejo manejo de
eventos para
public boolean action(Event evt, Object what) { todos los controles
if (evt.target instanceof Button) { En este método se
manejaban todos
Button btn = (Button) evt.target; los eventos.
if ("titulo".equalsIgnoreCase(btn.getName())){ Actualmente no se
setTitle(btn.getLabel()); codifica más de
return true; este modo.
}
}
Compara el nombre del
return false; botón con el texto “titulo" si
} coincide copia la etiqueta del
botón en titulo de la ventana
public static void main(String[] args) {
Demo demo = new Demo(); Crea un objeto Demo y lo
demo.setVisible(true); hace visible con el método
} setVisible
class EventHandler implements ActionListener {

public void actionPerformed(ActionEvent e) {
((Button) e.getSource()).getLabel().equalsIgnoreCase("Salir 2");
System.exit(0);
} Esta clase creada por el
} programador implementa
ActionListener. Esa clase
} posee un método
actionPerformed que
El casting es para que el recibe en un parámetro en el
objeto e se convierta a objeto evento. A este objeto
Button y pueda utilizar el le preguntamos cual es su
método getLabel de la clase etiqueta y si es Salir 2
Button. termina el programa.
12
Esto es lo que se ve por pantalla al ejecutar la aplicación AWT
Esto es lo que se ve por pantalla al presiona el botón Salir1 y generarse un

evento que muestra un dialogo de la librería swing
13
Clases del AWT
Clase Component
Es una clase abstract de la que derivan todas las clases del AWT. Los métodos de esta clase son
importantes porque son heredados por todos los componentes del AWT. En las declaraciones de los
métodos de dicha clase aparecen las clases Point, Dimension y Rectangle.
Clase EventObject y AWTEvent

La clase AWTEvent no define ningún método, pero hereda de EventObject el método getSource( ), que
devuelve una referencia al objeto que genero el evento.
Clase ComponentEvent
Se generan cuando un Component de cualquier tipo se muestra, se oculta o cambia de posición o de
tamaño. Los eventos de mostrar u ocultar ocurren cuando se llama al método setVisible(boolean). Otro
método útil es Component getComponent( ) que devuelve el componente que generó el evento. Se puede
utilizan en lugar de getSource( ).
Clase InputEvent y MouseEvent

De la clase InputEvent descienden los eventos del ratón y el teclado. Esta clase dispone de métodos para
detectar si los botones del ratón o las teclas especiales han sido pulsadas. Se produce MouseEvent cada
vez que el cursor movido por el ratón entra o sale de un componente visible en la pantalla, al clicar, o
cuando se pulsa o se suelta un botón del ratón.
Clase FocusEvent
El Focus está relacionado con la posibilidad de sustituir al ratón por el teclado en ciertas operaciones. De los
componentes que aparecen en pantalla, en un momento dado hay sólo uno que puede recibir las acciones
del teclado y se dice que ese componente tiene el Focus.
Clase Container
Es una clase muy general. Los métodos de esta clase son heredados por las clases Frame y Panel, los
cuales son muy utilizados para crear objetos.
Clase Windows
Los objetos de ésta clase son ventanas de máximo nivel, pero sin bordes ni barras de menú. Las clases que
derivan de ella son: Frame y Dialog.
Clase WindowEvent
Se produce cada vez que se abre, cierra, iconiza, restaura, activa o desactiva una ventana. El uso más
frecuente de está clase es para cerrar ventanas (ctrl+alt+supr). También se utiliza para detener threads y
liberar recursos al iconizar una ventana (por ejemplo animaciones) y comenzar de nuevo al restaurarla.
Clase Frame
Es una ventana con un borde y que puede tener una barra de menús. Si una ventana depende de otra, es
mejor utilizar una Window que un Frame.
Clase Dialog
Es una ventana que depende de otra ventana (Frame). Si un Frame se cierra, se cierran también los Dialog
que dependen de ella. Un Dialog modal requiere atención inmediata del usuario: no se puede hacer otra
cosa hasta haber cerrado el Dialog.
Clase FileDialog
Muestra una ventan de diálogo en la cual se puede seleccionar un fichero. Las constantes enteras LOAD
(abrir fichero para lectura) y SAVE (abrir fichero para escritura) definen el modo de apertura del fichero.
Clase Panel
Un Panel es el Container de propósito general. Se puede utilizar tal cual para contener otros componentes.
Por default, el Layout Manager de Panel es FlowLayout. Los applets son sub-clase de Panel.
14
Clase Button
El evento más importante que recibe es que al clicar sobre él se genera un evento de la clase ActionEvent.
Se puede cambiar el aspecto del botón y también se puede establecer si está activado o no.
Clase ActionEvent
Se producen al clicar con el ratón en un botón (Button), al elegir un comando de un menú (MenuItem), al
hacer doble click en un elemento de una lista (List) y al pulsar intro para introducir un texto en una caja de
texto (TextField).
Clase Canvas
Un Canvas es una zona rectangular de pantalla en la que se puede dibujar y en la que se pueden generar
eventos. Las Canvas permiten realizar dibujos, mostrar imágenes y crear componentes a medida, de modo
que se muestre un aspecto similar en todas las plataformas. Constructor: Canvas( ) Método de la clase:
paint (Graphics g);
Component Checkbox y clase CheckboxGroup

Los objetos de la clase Checkbox son botones de opción o de selección con dos posibles valores: on y off.
Al cambiar la selección en un Checkbox se produce un ItemEvent.
La clase CheckboxGroup permite la opción de agrupar varios Checkbox de modo que uno y solo uno este
en on. Constructores: Checkbox( ), Checkbox(String), Checkbox(String, boolean),
Checkbox(String,Boolean,CheckboxGroup), Checkbox(String,CheckboxGroup,Boolean).
Clase ItemEvent
Se produce cuando ciertos componentes (Checkbox, CheckboxMenuItem, Choice y List) cambian de estado
(on/off).
Clase Choice
Permite elegir un elemento de la lista desplegable. Constructor Choice( ).
Clase Label
Introduce en un container un texto no seleccionable y no editable, por default se alinea a la izquierda. La
clase Label define las constantesLabel.CENTER , Label.LEFT y Label.RIGHT para determinar la alineación
del texto. Constructores: Label(String lbl) , Label(String lbl, int alineación).
Clase List
Viene definida por una zona de pantalla con varias líneas, de las que se muestran solo algunas, y entre las
cuales se puede hacer una selección simple o múltiple. Constructores: List( ), List(int línea, boolena mult).
Clase Scrollbar
Un Scrollbar es una barra de desplazamiento con un cursor que permite introducir y modificar valores, entre
unos valores mínimo y máximo, con pequeños y grandes incrementos. Esta clase tiene dos constantes,
Scrollbar.HORIZONTAL y Scrollbar.VERTICAL, que indican la posición de la barra. Constructores:
Scrollbar( ), Scrollbar(int pos), Scrollbar(int pos, int val, int vis, int min, int max) donde :
Pos es la posición de la barra vertical u horizontal; el rango es el intervalo entre los valores mínimo min.,
máximo max y por ultimo, vis que es el tamaño de área visible.
Clase ScrollPane
Es una ventana de tamaño limitado en las que se pueden mostrar un componente de mayor tamaño con
dos Scrollbar, uno vertical y otra horizontal. Constructores: ScrollPane(), ScrollPane(int scbs) .
Clases TextArea y TextField

Muestran texto seleccionable y editable. La diferencia principal es que TextField solo puede tener una línea,
mientras que TextArea puede tener varias líneas.
Constructores de TextField: TextField(), TextField(int ncol), TextField(String s), TextField(String s, int ncol).
Constructores de TextArea: TextArea(), TextArea(int nfil, int ncol), TextArea(String text), TextArea(String
text, int nfil, int ncol)
15
Clase Menu
Define las opciones que aparecen al seleccionar uno de los menús de la barra de menús. Constructores:
Menu (String).
Clase MenuBar
A una MenuBar solo pueden añadirse objetos Menu. Constructor : MenuBar().
Clase MenuItem
Los objetos de esta clase representan las distintas opciones de un menú.
Clase CheckboxMenuItem
Son elementos de un menú que pueden estar activados o no. Constructores: CheckboxMenuItem(String
lbl), CheckboxMenuItem(String lbl, boolean estado).
Menús pop-up
Son menús que aparecen en cualquier parte de la pantalla al clicar con el botón derecho del ratón.
Constructores : PopupMenu( ), PopupMenu(String titulo).
LAYOUT MANAGERS
Un Layout Managers es un objeto que controla como los componentes se sitúan en un Container.
El AWT define cinco Layout Managers: dos muy sencillos (FlowLayout y GridLayout), dos más
especializados (BorderLayout y CardLayout) y uno muy general (GridBagLayout).
FlowLayout
Los componentes se van añadiendo de izquierda a derecha y de arriba hacia abajo. Se puede
elegir alineación por la izquierda, central o por la derecha, respecto al container. Esta clase tiene
tres constructores:
FlowLayout( ); FlowLayout(int alineación);
FlowLayout(int alineación, int horizGap, int vertGap);
BorderLayout
El container se divide en 5 zonas: North, South, East, West y Center (que ocupa el resto del
espacio). Si se aumenta el tamaño de la ventana todas las zonas se mantienen en su mínimo
tamaño posible excepto Center, que absorbe casi todo el crecimiento. Por default BroderLayout
no deja espacio entre componentes. Constructores:
BorderLayout( ); BorderLayout(int horizGap, int vertGap);
16
GridLayout
Se utiliza una matriz de celdas que se numeran de izquierda a derecha y de arriba abajo. Todas
las celdas tienen el mismo tamaño. Constructores:
GridLayout(int nfilas, ncol); GridLayout(int nfilas, int ncol, int horizGap, int vertGap);
GridBagLayout
Se utiliza también una matriz de celdas, pero permite que algunos componentes ocupen más de
una celda. La diferencia con GridLayout es que las filas pueden tener distinta altura, las columnas
pueden tener distinta anchura, y además en el GridBagLayout un componente puede ocupar
varias celdas contiguas.
CardLayout
Permite disponer distintos componentes que comparten la misma ventana para ser mostrados
sucesivamente. Son como diapositivas que van apareciendo una detrás de otra. Los siguientes
métodos permiten controlar el orden en que aparecen las diapositivas:
void first (Container cont);

void last (Container cont);
void previous (Container cont);
void next (Container cont);
void show (Container cont, String nombre);
17
LA CLASE Event
Material de Tutorial de java (http://www.cica.es/formacion/JavaTut/Cap4/awt.html)
Un contenedor soltado en un entorno gráfico se convierte en rápido receptor de eventos de todo

tipo, singularmente de los relacionados con el movimiento del ratón, pulsaciones de teclas,
creación/movimiento/destrucción de partes gráficas y, por último, los referidos a acciones del
usuario respecto de componentes (elección de un menú, pulsación de un botón, etc.).
La clase Event es el jugador principal en el juego de los eventos. Intenta capturar las
características fundamentales de todos los eventos que genera el usuario. Los datos miembro de
la clase Event son los que se indican a continuación:
id - El tipo de evento que se ha producido
target - Componente sobre el que se ha producido el evento
x, y - Las coordenadas en donde se ha producido el evento relativas al Componente que

actualmente está procesando ese evento. El origen se toma en la esquina superior izquierda del
Componente
key - Para eventos de teclado, es la tecla que se ha pulsado. Su valor será el valor Unicode del
carácter que representa la tecla. Otros valores que puede tomas son los de las teclas especiales
como INICIO, FIN, F1, F2, etc.
when - Instante en que se ha producido el evento
modifiers - La combinación aritmética del estado en que se encuentran las teclas modificadoras
Mays, Alt, Ctrl.
clickCount - El número de clicks de ratón consecutivos. Sólo tiene importancia en los eventos
MOUSE_DOWN
arg - Es un argumento dependiente del evento. Para objetos Button, este objeto arg es un objeto
String que contiene la etiqueta de texto del botón
evt - El siguiente evento en una lista encadenada de eventos
Una instancia de la clase Event será creada por el sistema Java cada vez que se genere un
evento. Es posible, sin embargo, que un programa cree y envíe eventos a los Componentes a
través de su método postEvent()
18
TIPOS DE EVENTOS
Los eventos se catalogan por su naturaleza, que se indicará en el miembro id de su estructura.
Los grandes grupos de eventos son:
Eventos de Ventana
Son los que se generan en respuesta a los cambios de una ventana un frame o un dialogo.
• WINDOW_DESTROY
• WINDOW_EXPOSE
• WINDOW_ICONIFY
• WINDOW_DEICONIFY
• WINDOW_MOVED
Eventos de Teclado
Son generados en respuesta a cuando el usuario pulsa y suelta una tecla mientras un
Componente tiene el foco de entrada.
• KEY_PRESS
• KEY_RELEASE
• KEY_ACTION
• KEY_ACTION_RELEASE
Eventos de Ratón
Son los eventos generados por acciones sobre el ratón dentro de los límites de un Componente.
• MOUSE_DOWN
• MOUSE_UP
• MOUSE_MOVE
• MOUSE_ENTER
• MOUSE_EXIT
• MOUSE_DRAG
Eventos de Barras
Son los eventos generados como respuesta a la manipulación de barras de desplazamiento
(scrollbars).
• SCROLL_LINE_UP
• SCROLL_LINE_DOWN
• SCROLL_PAGE_UP
• SCROLL_PAGE_DOWN
• SCROLL_ABSOLUTE
Eventos de Lista
Son los eventos generados al seleccionar elementos de una lista.
• LIST_SELECT
• LIST_DESELECT
Eventos Varios
Son los eventos generados en función de diversas acciones.
• ACTION_EVENT
• LOAD_FILE
• SAVE_FILE
• GOT_FOCUS
• LOST_FOCUS
19
CREAR MENUS Y BARRAS DE MENUS
En la actual versión del AWT que se proporciona con el JDK, sólo se permite crear menús a través
de código, ya que Java todavía no dispone de un formato de recursos y tampoco hay un diseñador
como pueden ser AppStudio, Delphi o X-Designer; aunque terminará habiendo uno, con
seguridad.
No hay ningún método para diseñar una buena interface, todo depende del programador. Los
menús son el centro de la aplicación. La diferencia entre una aplicación útil y otra que es
totalmente frustrante radica en la organización de los menús, pero eso, las reglas del diseño de un
buen árbol de menús, no están claras. Hay un montón de libros acerca de la ergonomía y de cómo
se debe implementar la interacción con el usuario. Lo cierto es que por cada uno que defienda una
idea, seguro que hay otro que defiende la contraria. Todavía no hay un acuerdo para crear un
estándar, con cada Window Manager se publica una guía de estilo diferente. Así que, vamos a
explicar lo básico, sin que se deba tomar como dogma de fe, para que luego cada uno haga lo que
mejor le parezca.
La interface MenuContainer solamente se puede implementar sobre un Frame. Un applet que

desee tener un menú, debe crear un Frame en primer lugar. El código de la función que vamos a
ver, crea una barra de menús y se llama desde el constructor del Frame. La función es private
porque no queremos que se pueda llamar desde ninguna otra clase.
private void InicializaMenus() {

mbarra = new MenuBar();
Menu m = new Menu( "Archivo" );
m.add( new MenuItem( "Nuevo") );
m.add( new MenuItem( "Abrir") );
m.add( new MenuItem( "Guardar") );
m.add( new MenuItem( "Guardar como") );
m.add( new MenuItem( "Imprimir") );
m.addSeparator();
m.add( new MenuItem( "Salir") );
mbarra.add( m );
m = new Menu( "Ayuda" );

m.add( new MenuItem( "Ayuda!" ) );
m.addSeparator();
m.add( new MenuItem( "Acerca de..." ) );
mbarra.add( m );
setMenuBar( mbarra );
}
El menú que crea esta función tendrá la apariencia que muestra la figura siguiente:
20
Los eventos generados por las opciones de un menú se manejan del mismo modo que los
Botones, Listas, etc. En el caso de menús, es el evento ACTION_EVENT de la clase
java.awt.MenuItem el que se genera y en evt.target se nos indica la opción seleccionada.
case Event.ACTION_EVENT:
{
if( evt.target instanceof MenuItem )
{
if( "Nuevo".equals( evt.arg ) )
AplicacionAWT aAwt = new AplicacionAWT();
if( "Abrir".equals( evt.arg ) )
System.out.println( "Opcion -Abrir-" );
if( "Guardar".equals( evt.arg ) )
System.out.println( "Opcion -Guardar-" );
if( "Guardar como".equals( evt.arg ) )
System.out.println( "Opcion -Guardar como-" );
if( "Imprimir".equals( evt.arg ) )
System.out.println( "Opcion -Imprimir-" );
if( "Salir".equals( evt.arg ) )
System.exit( 0 );
if( "Ayuda!".equals( evt.arg ) )
System.out.println( "No hay ayuda" );
if( "Acerca de".equals( evt.arg ) )
System.out.println( "Opcion -Acerca de-" );
}
}
En el código anterior hemos tratado los eventos del menú. Para más seguridad, aunque no sea
estrictamente necesario, lo primero que hacemos es asegurarnos de que el objeto evt.target es
realmente un objeto MenuItem, es decir, procede de la barra de menús; y después comprobamos
la opción que se ha seleccionado.
Como todo, también se puede rizar el rizo y conseguir reproducir los sistemas de menús que
estamos acostumbrados a ver en las aplicaciones que manejamos habitualmente. Un ejemplo de
ello son los menús en cascada, semejantes al que muestra la figura y que ha sido generado
mediante la aplicación Cascada.java.
Básicamente se utiliza la técnica ya descrita, pero en vez de crear un nuevo MenuItem se crea un
nuevo Menu, lo que origina el menú en cascada.
No obstante, y volviendo al diseño de interfaces, no debe abusarse de este tipo de menús, porque
pueden crear mucha más confusión al usuario. Siempre se debe tener en mente que los usuarios
tienen que navegar habitualmente por una gran cantidad de menús en las más diversas
aplicaciones, por lo que no debemos esconderles demasiado las opciones que les pueden
interesar.
21

Taller VI Modulo IV Cuatro 4

Încărcat de

Informații document

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Taller VI Modulo IV Cuatro 4

Încărcat de

Drepturi de autor:

Formate disponibile

INSTITUTO de TECNOLOGÍA O. R. T.

Analista de Sistemas de Computación

Introducción y orientaciones para el estudio

 Conocer como crear una aplicación grafica AWT.

Aclaraciones previas al estudio

Usted debe tener presente que los contenidos presentados en el módulo

La estructura básica del AWT se basa en Componentes y Contenedores. Estos últimos

No obstante y pese a ello, vamos a abordar en este momento la programación con el

La interfase de usuario es el aspecto más importante de cualquier aplicación. Una

Estructura del AWT

• Los Contenedores contienen Componentes, que son los controles básicos

Los Componentes no se encuentran aislados, sino agrupados dentro de Contenedores.

Superclases comunes de muchos componentes Awt y swing

El paquete java.awt contiene clases que generan componentes GUI. En la figura se

La figura muestra los manejadores de Layout por defecto.

Frame tendrá por defecto BorderLayout y Panel tendrá FlowLayout .

Primer ejemplo de una aplicación grafica AWT

package ejemplo_01; Importa la clase Frame de AWT para dibujar

public class Ventana1 extends Frame {

Modelo de manejo de eventos

Interfaces que escuchan eventos del paquete java.awt.event

En los componentes de la clase java.swing se siguen utilizando los eventos de java.awt.event y

1- registrar un componente que escucha eventos.

Un manejador de eventos es un método que se invoca automáticamente en repuesta a un tipo

La siguiente tabla lista esas categorías y las interfaces.

public class Demo extends Frame {

// Botón que pide confirmación para cerrar la aplicación

btn = new Button("Salir 2"); 2)El evento se maneja a

// Agrega un TextField que solamente admite números

3)El evento se maneja a través de una clase interna que posee

Crea un cuadro de texto

class EventHandler implements ActionListener {

Esto es lo que se ve por pantalla al ejecutar la aplicación AWT

Esto es lo que se ve por pantalla al presiona el botón Salir1 y generarse un

Clases del AWT

Clase EventObject y AWTEvent

Clase InputEvent y MouseEvent

Component Checkbox y clase CheckboxGroup

Clases TextArea y TextField

FlowLayout( ); FlowLayout(int alineación);

FlowLayout(int alineación, int horizGap, int vertGap);

BorderLayout( ); BorderLayout(int horizGap, int vertGap);

void first (Container cont);

Un contenedor soltado en un entorno gráfico se convierte en rápido receptor de eventos de todo

id - El tipo de evento que se ha producido

target - Componente sobre el que se ha producido el evento

x, y - Las coordenadas en donde se ha producido el evento relativas al Componente que

when - Instante en que se ha producido el evento

evt - El siguiente evento en una lista encadenada de eventos

La interface MenuContainer solamente se puede implementar sobre un Frame. Un applet que

private void InicializaMenus() {

m = new Menu( "Ayuda" );

S-ar putea să vă placă și

Conocer como crear una aplicación grafica AWT.