1. AWT
Introducción
Componentes y contenedores
Elementos Básicos
Administradores de diseño
Ventanas
Manejo de eventos
Tipos y auditores de evento
Línea de Trabajo
Bibliografía
1

2. Introducción
AWT = Abstract Window Toolkit
(Juego de Herramientas de Ventanas Abstracto)
Permite el desarrollo de interfaces gráficas de
usuario rápida y fácilmente.
Contiene una mezcla de los componentes GUI
más simples.
La mayoría de sus clases e interfaces se pueden
usar en:
applets
aplicaciones
El paquete básico es java.awt.*
2

3. Componentes y Contenedores
Component: es la superclase del conjunto
de clases del AWT.
Container: se usa para definir
componentes que pueden contener a
otros componentes.
java.lang.Object
|
+--java.awt.Component
|
+--java.awt.Container
3

4. Componentes y Contenedores
Component: incluye métodos para trabajar con
manipuladores de eventos
imágenes
fuentes
colores
Container: ofrece métodos para manipular los
componentes
añadir
recuperar
mostrar
contar
eliminar
trabajar con administradores de diseño
4

5. La Primera import java.awt.*;
import java.awt.event.*;
Ventana class Ventana extends Frame{
public Ventana(){
super ("Ejemplo de Ventana");
inicializacionComponentes();
addWindowListener(new AdaptadorVentana());
setSize(300,200);
setVisible(true);
}
private void inicializacionComponentes(){
// Establecer Gestor de Posicionamiento
//Crear Componentes Gráficos
// Añadir al contenedor
}
public static void main(String arg[]){
Ventana f = new Ventana();
}
private class AdaptadorVentana extends WindowAdapter{
public void windowClosing(WindowEvent e){
System.exit(1);
}
}
}
5

6. Elementos Básicos: Botones
Button (Botón)
Se utilizan para ejecutar alguna acción
asociada cuando el usuario lo pulsa.
Dos constructores:
• Button()
• Button(String label)
Ejemplo:
Button boton=new Button(“Aceptar”);
6

7. Elementos Básicos: Label
Label (Etiqueta)
Se utilizan para escribir cadenas de caracteres
alineadas dentro de los limites del objeto de
este tipo.
Tres constructores:
• Label()
• Label(String label)
• Label(String label, int aligment)
Ejemplo:
Label etiqueta=new Label(“Bienvenido”,Label.CENTER);
7

8. Elementos Básicos: Checkbox
Checkbox (Casilla de verificación)
Representa una casilla de verificación a seleccionar.
Para comprobar el estado
• getState
Para establecer el estado
• setState
Se pueden asociar en grupos dentro de un elemento
CheckboxGroup
Ejemplo:
Checkbox check=new Checkbox(“One”,grupoCheck, true);
• Nota: grupoCheck es una instancia de un objeto
CheckboxGroup
8

9. Elementos Básicos: CheckboxGroup
CheckboxGroup (Agrupación de Casilla de
verificación)
Agrupa un conjunto de checkbox de manera
que sólo se puede seleccionar uno de ellos.
Para comprobar la casilla activa
• getSelectedCheckBox
Para establecer la casilla activa
• setSelectedCheckBox
Ejemplo: CheckboxGroup cbg = new CheckboxGroup();
add(new Checkbox("one", cbg, true));
add(new Checkbox("two", cbg, false));
add(new Checkbox("three", cbg, false));
9

10. Elementos Básicos: Choice
Choice (Selección)
Seleccionar una opción de entre varias visualizando solo
una de ellas.
Para añadir elementos: addItem
Para contar los elementos: countItems
Para seleccionar un elemento: select
Para obtener el elemento asignado: getSelectedItem
Para establecer el índice del elemento asignado:
getSelectedIndex
Ejemplo: Choice colorChooser = new Choice();
colorChooser.add("Green");
colorChooser.add("Red");
colorChooser.add("Blue");
10

11. Elementos Básicos: TextField
TextField (Campos de texto)
Implementa una zona de entrada de texto en
una sola línea.
Para cambiar el texto setText
Para obtener el texto getText
Ejemplo:
TextField tf1, tf2, tf3, tf4;
tf1 = new TextField();
tf2 = new TextField("", 20);
tf3 = new TextField("Hello!");
tf4 = new TextField("Hello", 30);
11

12. Elementos Básicos: TextArea
TextArea (Campos de área de texto)
Implementa una zona de entrada de varias
líneas de texto.Incluye su propia barra de
desplazamiento.
Para cambiar el texto disponemos de métodos:
appendText, insertText y replaceText.
Para obtener el texto getText.
Ejemplo:
new TextArea("Hello", 5, 40);
12

13. Elementos Básicos: Scrollbar
Scrollbar (Barra de desplazamiento)
Permiten seleccionar un valor entre un mínimo
y un máximo determinado.
Disponemos de los métodos: getValue,
setValue, getMinimum y getMaximum.
Ejemplo:
ranger = new Scrollbar(Scrollbar.HORIZONTAL, 0, 60, 0, 300);
add(ranger);
13

14. Administradores de diseño: Descendientes
de Container
Panel
Es un contenedor genérico que se puede mostrar dentro
de applets y aplicaciones.
ScrollPane
Es un contenedor desplazable que puede tener barras de
desplazamiento verticales y horizontales.
Window
Ofrece unas subclases para las ventanas principales de
aplicación, objetos Frame y ventanas Dialog.
• Estas tres clases cumplen la función de hospedar a los
componentes ya vistos pudiendo tener asociado un gestor
de organización (LayoutManager).
14

15. Administradores de diseño: Container
Cada Container tiene asociado un administrador
de diseño que establece la forma de colocar los
componentes dentro de un Container.
El administrador de diseño debe implementar la
interfaz LayoutManager.
La interfaz LayoutManager2 amplia sus funciones.
Para establecer el LayoutManager se usa el
método setLayoutManager del Container.
Existen varios administradores de diseño:
FlowLayout
BorderLayout
GridLayout
GridBagLayout
CardLayout
15

16. Administradores de diseño: Container
Como trabajar con Paneles
Creación del panel
• Panel p = new Panel ();
Añadir un administrador de diseño al panel
• p.setLayout(new FlowLayout());
Añadir los componentes al panel
• Label b = new Label(“Dentro del panel”);
• p.add(b);
Si no es un root Panel se añade al panel principal como
un componente mas
• frame.add(p);
Comentarios
Todas las ventanas (dialogo - principales) y applet tienen
asociado un panel inicial
Cuando el GUI es complicado los paneles se modelan en
clases independientes extendiendo de la clase Panel
16

17. Administradores de diseño: Container
Ejemplo
//Creación de variables de instancia
private Label label1;
private Panel p;
...
//Creación de un container
p = new Panel();
//Establecer administradores de diseño para los contenedores
this.setLayout(new FlowLayout());
p.setLayout(new FlowLayout());
//Creación de componentes
label1 = new Label("Dentro de un Panel");
//Añadir componentes a los contenedores
p.add(label1);
this.add(p);
17

18. Administradores de diseño: FlowLayout
Se colocan los elementos desde la esquina superior
izquierda, de izquierda a derecha y de arriba a abajo.
La separación entre componentes puede indicarse en el
constructor.
(Redimensionar la ventana para observar la recolocación de los componentes)
//Creación de variables de instancia
//this es la autoreferencia de un objeto Frame
this.setLayout(new FlowLayout());
this.add(new Button("Boton 1"));
this.add(new Button("Boton 2"));
this.add(new Button("Boton 3"));
this.add(new Button("Nombre Largo Boton 4"));
this.add(new Button("5")); 18

19. Administradores de diseño: BorderLayout
Se colocan los elementos siguiendo una distribución en
zonas: arriba, abajo, izquierda, derecha y centro.
Los elementos de los extremos ocupan el espacio que les
sea necesario. El central ocupa todo el que quede
disponible.
// Asignacion del administrador de diseño
//this es la autoreferencia de un objeto Frame
this.setLayout(new BorderLayout());
// Añadir componentes al panel
Button button = new Button("Boton 1 (PAGE_START)");
this.add(button, BorderLayout.PAGE_START);
button = new Button("Boton 2 (CENTER)");
this.add(button, BorderLayout.CENTER);
button = new Button("Boton 3 (LINE_START)");
this.add(button, BorderLayout.LINE_START);
button = new Button("Boton 4 (PAGE_END)");
this.add(button, BorderLayout.PAGE_END);
button = new Button("Boton 5 (LINE_END)");
this.add(button, BorderLayout.LINE_END); 19

20. Administradores de diseño: GridLayout
Se organizan los elementos por cuadriculas. Todos los
elementos tienen el mismo tamaño.
El constructor se usa para determinar el número de
cuadrículas.
Se puede indicar huecos entre las Cuadriculas
Constructores
GridLayout(int filas, int colums)
GridLayout(int filas, int colums, int xhueco, int yhueco)
/ Asignación del administrador de diseño
/this es la autoreferencia de un objeto Frame
his.setLayout(new GridLayout(3,2,2,2));
/ Añadir componente al panel
utton button;
or (int i=1;i<=6;i++){
button= new Button("Boton " + i);
this.add(button);
20

21. Administradores de diseño: GridBagLayout
Se organizan los elementos por
cuadrículas. Los elementos pueden ocupar
más de una fila o columna.
Usa la clase GridBagConstraints. Se usa
para identificar los parámetros de
posicionamiento de un componente.
21

22. Administradores de diseño: CardLayout
Solo se ve uno de sus componentes en cada
momento.
Sirve como base para tener varias ventanas una
debajo de otra.
Se puede asignar a cualquier contenedor
Son especialmente útiles con contenedores del
tipo JTabbedPane
Capa 1
Capa 2
Capa 3
22

23. Administradores de diseño: Nulo
Se permite trabajar sin administradores de diseño
Se indica la posición absoluta de cada componente en el
contenedor con el método setBounds.
setBounds(int x,int y,int anchura,int altura)
/ Asignacion del administrador de diseño nulo
/this es la autoreferencia de un objeto Frame
his.setLayout(null);
utton boton1 = new Button("Boton 1");
oton1.setBounds(30,30,200,100);
his.add(boton1);
utton boton2 = new Button("Boton 2");
oton2.setBounds(200,100,100,100);
his.add(boton2);
23

24. Ventanas
Para el trabajo con ventanas tenemos:
Window: ventana de alto nivel sin bordes ni barra de
menús.
Frame: subclase de Window
Dialog: subclase de Window
Frame: subclase de Window.
tiene una barra de título, esquinas para cambiar de
tamaño y una barra de menú.
Puede ser la ventana principal o secundaria.
setVisible(boolean)para mostrar y esconder el Frame.
setMenuBar cambia la barra de menú.
setTitle cambia el título de la ventana.
Dialog
ventana de dialogo asociada a una ventana de nivel
superior
24

25. Manejo de Eventos:IntroducciónI
El usuario se comunica con los programas de ventana
ejecutando acciones sobre los componentes gráficos.
Estas acciones tienen como resultado la generación de eventos.
Los programas de ventanas son “conducidos por eventos”.
El JDK 1.0.2 admitía un enfoque “modelo heredado”.
Se devuelve true o false si el componente gestiona el tipo de
evento. Si no se gestiona se envía al contenedor del objeto, así
sucesivamente.
El JDK 1.1 introduce el enfoque “delegación de eventos”.
Entrega los eventos a objetos específicos.
Menos complejo y más eficaz.
25

26. Manejo de Eventos: IntroducciónII
La clase java.util.EventObject es la clase de
nivel superior de la jerarquía de eventos.
Esta clase ofrece:
Una variable source, origen del evento.
Un método getSource() recupera el objeto fuente del
evento.
Un solo constructor que toma como argumento el objeto
origen del evento.
La clase java.awt.AWTEvent hereda de la clase
java.util.EventObject para admitir los eventos de
AWT.
Recoger evento Procesar evento
Registra auditor
Componente addXXXListener() Listener
26

27. Manejo de Eventos: Introducción III
Asociación/registro de auditores/oyentes/listener
Cada componente puede tener asociado varios tipos de
auditores a través de una interface.
Ej: A un botón se le puede asociar un oyente que
implemente la interface java.awt.event.ActionListener
...
b = new Button("Boton");
b.addActionListener(new Oyente()); // Registrar auditor
...
class Oyente implements ActionListener{
public void actionPerformed(ActionEvent e){
...
}
}
Recoger evento Procesar evento
Registra auditor
Componente addActionListener() Listener
Envía evento 27

28. Manejo de Eventos: Introducción IV
class Ventana extends Frame{
private Button b;
Ejemplo:
Se tiene un botón public Ventana(){
con un oyente super ("Ejemplo de Ventana");
inicializacionComponentes();
asociado setSize(300,200);
El oyente audita al setVisible(true);
componente y }
realiza private void inicializacionComponentes(){
operaciones en setLayout(new FlowLayout());
b = new Button("Boton");
función de los b.addActionListener(new Oyente());
eventos recibidos add(b);
por el botón. }
En el ejemplo el public static void main(String arg[]){
Ventana f = new Ventana();
oyente cambia el }
color del botón private class Oyente implements
cuando éste es ActionListener{
pulsado. public void actionPerformed(ActionEvent e){
Button baux=(Button) e.getSource();
baux.setBackground(Color.RED);
}
}
} 28

29. Manejo de Eventos: Introducción V
Ejercicio:
Realizar una Ventana con un Button
El oyente que audita al botón cambiará alternativamente
los colores de un objeto cuando éste es pulsado (azul –
rojo)
29

30. Manejo de Eventos: Consideraciones de
diseño I
Implementación de oyentes
Implementación de interface
• Ventaja tiene acceso a la parte privada de la clase
class Ventana extends Frame implements ActionListener{
private Button b;
...
b.addActionListener(this);
...
//Método de la interface ActionListener
public void actionPerformed(ActionEvent e){
Button baux=(Button) e.getSource();
baux.setBackground(Color.RED);
}
}//Fin class Ventana
30

31. Manejo de Eventos: Consideraciones de
diseño II
Implementación de oyentes
Clases internas (inner)
• Ventajas tiene acceso a la parte privada de la clase que la
contiene (outer) y mantiene un encapsulamiento del
oyente dentro de la clase
class Ventana extends Frame{
private Button b;
...
b.addActionListener(new Oyente());
...
//Clase interna tiene acceso a la parte privada de Ventana
private class Oyente implements ActionListener{
public void actionPerformed(ActionEvent e){
Button baux=(Button) e.getSource();
baux.setBackground(Color.RED);
}
}//Fin class Oyente
}//Fin class Ventana 31

32. Manejo de Eventos: Consideraciones de
diseño III
Implementación de oyentes
Clases externas
• El oyente se asocia igual que con clases internas
• La clase Auditor (class Oyente) no puede acceder a la zona
privada de la clase que le contiene (class Ventana)
Clases anónimas
class Ventana extends Frame{
private Button b;
...
b.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent e){
Button baux=(Button) e.getSource();
baux.setBackground(Color.RED);
});//Fin class anónima
}//Fin class Ventana
32

33. Manejo de Eventos: Consideraciones de
diseño IV
Asociación de oyentes
Posibilidades de asociación
• “n” oyentes a “1” componente
Oye nte 1
Oye nte 2 Co mpon ente
Oye nte 3
• “1” oyente a “n” componentes Componente 1
Oyente Componente 2
Componente n
• “1” oyente a “1” componente
Oyente Compon ente
33

34. Manejo de Eventos: Consideraciones de
diseño V
Asociación de oyentes
b1 = new Button("Boton dos listener");
b2 = new Button("Boton un listener");
t1 = new TextField(10);
//Asociación n a 1
b1.addActionListener(new Oyente1());
b1.addActionListener(new Oyente2());
//Asociación 1 a n
b2.addActionListener(new Oyente1());
private class Oyente1 implements ActionListener{
public void actionPerformed(ActionEvent e){
Button baux=(Button) e.getSource();
baux.setBackground(Color.RED);
}
}//Oyente1
private class Oyente2 implements ActionListener{
public void actionPerformed(ActionEvent e){
t1.setText("Boton pulsado");
}
34

35. Tipos y auditores de evento I
Tipos de eventos (heredan de java.awt.AWTEvent)
Eventos Descripción
ActionEvent Pulsación de botones o la selección de
elementos de menú.
AdjustmenEvent Acciones de desplazamiento.
ComponentEvent Cambios en la posición, foco o tamaño de un
componente de ventana, o una entrada de
teclado u otra acción del ratón.
InputMethodEvent Cambios en el texto que se introducen a
través de un método de entrada.
ItemEvent Cambios en el estado de un componente
como la selección de un elemento de la lista.
TextEvent Cambios en los textos
35

36. Tipos y auditores de evento II
Tipos de eventos (heredan de java.awt.AWTEvent)
Eventos Descripción
FocusEvent Cambios en el estado de un foco de entrada de
un componente.
InputEvent Se clasifican en KeyEvent y MouseEvent para
cubrir los eventos que generan las acciones del
teclado y los eventos de bajo nivel del ratón.
ContainertEvent eventos asociados a la suma y eliminación de
los componentes de un contenedor.
PaintEvent Se genera el dibujo/redibujo de una ventana.
WindowEvent la generan eventos como la apertura, cierre y
minimización de una ventana.
36

37. Tipos y auditores de evento III
Las clases AWTEvent y sus subclases dirigen los eventos
hacía los objetos registrados como oyentes.
Los oyentes (auditores) implementan la interfaz
java.util.EventListener (no define constantes ni métodos).
Tipos de auditores (heredan java.awt.event.EventListener )
Auditores Eventos asociados
ActionListener ActionEvent
AdjustmentListener AdjustmenEvent
ComponentListener ComponentEvent
ContainerListener ContainerEvent
FocusListener FocusEvent
InputMethodListener InputMethodEvent
37

38. Tipos y auditores de evento IV
Tipos de auditores (heredan java.awt.event.EventListener
Auditores Eventos asociados
ItemListener ItemEvent
KeyListener KeyEvent
MouseListener MouseEvent
MouseMotionListener MouseEvent
TextListener TextEvent
WindowListener WindowEvent
38

39. Tipos y auditores de evento V
Clases adaptadoras
Por comodidad se ofrecen clases adaptadoras que
implementan las interfaces de audición de eventos.
Se pueden utilizar para pasar por alto métodos
específicos de manejo de eventos.
Auditores Clases adaptadoras que implementan el
auditor
ComponentListener ComponentAdapter
ContainerListener ContainerAdapter
FocusListener FocusAdapter
KeyListener KeyAdapter
MouseListener MouseAdapter
MouseMotionListener MouseMotionAdapter
WindowListener WindowAdapter 39

40. Tipos y auditores de evento VI
Relación componentes awt/swing y auditores
Los componentes awt/swing descienden de
awt.Component
Se puede asignar los siguientes Listener
• component listener
• focus listener
• key listener
• mouse listener
• mouse-motion listener
• mouse-wheel listener (introducido en 1.4)
Dependiendo del tipo de componente podrá tener
además otros listener asociados
40

41. Tipos y auditores de evento VII
Relación componentes awt y auditores
able edit
document,undo
window
change
action
caret
item
Componentes
button X X X
check box X X X
radio button X X X
text area X X
text field X X X
Frame X
41

42. Línea de Trabajo
JFC = Java Foundation Classes
Agrupa a AWT y lo amplia con nuevas APIs como
Swing
Java 2D, Java 3D
Drag-and-Drop
Accessibility
Swing es parte de JFC ... aunque con distintas
características que AWT.
Permiten elaborar interfaces gráficas más
potentes.
http://java.sun.com/docs/books/tutorial/uiswing/compon
ents/components.html
Desventajas:
complejidad de manejo
problema en el soporte por parte de los navegadores. 42

43. Bibliografía
[Jaworski 1999] Jaworski, J. (1999). Java 1.2 Al
Descubierto.. Prentice Hall.
Capítulo 6, Construcción de GUI.
[Walrath et al., 2004] Walrath,K., Campione,M., Huml A.,
Zakhour S., (2004). The JFC Swing Tutorial: A Guide to
Constructing GUIs, Second Edition. Addison-Wesley .
• Disponible en formato electrónico en inglés
• http://java.sun.com/docs/books/
[Horstmann et al., 2003] Horstmann, G.S., Cornell, G.
(2003) Java 2. Fundamentos. Volumen 1. Prentice Hall
Java2 SDK, Standard Edition Documentation
43