1. Java Foundation Classes -JFC-
ü Es un conjunto de paquetes Java, que agrupa a las siguientes interfaces de
programación (API’s):
ü Abstract Window Toolkit (AWT 1.1 y posteriores): es un toolkit Java que
permite desarrollar interfaces de usuario. Es el fundamento de JFC.
ü Componentes Swing: implementan un nuevo conjunto de componentes de GUI con
“look & feel” configurable. Reemplazan a las componentes de GUI heavyweigth
del AWT por componentes lightweigth.
ü Java 2D: es un conjunto de clases que permiten manipular gráficos 2D avanzados
e imágenes.
ü Accesibility: consiste en un conjunto de clases que permiten a las componentes
Swing interactuar con tecnologías que ayudan a los usuarios con discapacidades.
ü El corazón de la JFC es el AWT (1.1 ó superior), el cual provee la siguiente
infraestructura:
ü Modelo de eventos basado en delegación
ü Componentes Lightweight
ü Servicio de portapapeles (clipboard) y transferencia de datos desde y hacia el
portapapeles
ü Impresión y operaciones sin mouse (navegación con teclas, abreviaturas de
menúes)
ü La JFC se incorporó a la API Java a partir de la versión 1.2 del JDK.

2. Abstract Window Toolkit -AWT-
El AWT es un mundo de componentes de GUI. Aproximadamente la mitad
de las clases del AWT son subclase de la clase java.awt.Component.
El fundamento del AWT lo constituyen:
üClase Component: es una clase abstracta que agrupa componentes
GUI éstandares como botones, menúes, listas, labels, etc.
üClase Container: es una clase abstracta, subclase de Component.
Tiene la capacidad de contener múltiples componentes. Applet, Panel,
Window, Dialog y Frame son subclases de Container.
üInterfaz LayoutManager, LayoutManager2: son interfaces que
definen métodos para la ubicación, la distribución y el cambio de
tamaño de las componentes dentro de un contenedor. Java provee
varias clases que implementan estas interfaces.
üClase Graphics: es una clase abstracta que define métodos para
realizar operaciones gráficas sobre una componente (mostrar
imágenes, texto, establecer colores y fonts). Toda componente AWT
tiene asociado un objeto Graphics donde dibujarse.

3. AWT. Las Clases Component y Containers,
la Interfaz Layout Manager
üLa relación fundamental en AWT se establece entre objetos:
Component, Container y Layout Manager.
üAWT establece una relación simple y fundamental entre objetos
Component y Container: los containers pueden contener components.
üTodos los containers tienen asociado un layout manager (excepto la
clase java.awt.Container) que establece la ubicación y la forma de las
componentes del Container.
üLas responsabilidades del layout manager las definen las interfaces
java.awt.LayoutManager y java.awt.LayoutManager2.

4. La clase java.awt.Component es una clase abstracta que
provee una amplia funcionalidad, heredada por todas sus
subclases. Los controles de la interfaz de usuario como
botones, scrollbars, labels, text, fields, etc. son subclase de
java.awt.Component. Cada componente AWT tiene asociada
la siguiente información:
ü Un objet Graphics (donde dibujarse)
ü Posición
ü Tamaño
ü Peer nativo (componente de GUI nativa)
ü Container padre
ü Fonts y dimensiones del font
ü Colores de foreground y de background
ü Tamaño mínimo, máximo y preferido
Componentes AWT

5. Componentes AWT estándares
Panel
Button
TextArea
Choice
Label
ScrollBar
Checkbox
List
TextField
Canvas
ScrollPane

6. Componentes AWT y Peers
üEl AWT original (versión 1.0) basó el diseño
de sus componentes de GUI en peers.
üLos peers son componentes de GUI nativas
(del sistema donde se ejecutan) manipuladas
por componentes AWT. Las clases AWT
encapsulan a los peers.
üLas componentes AWT estándares delegan en
los peers la mayor parte de su funcionalidad.

7. üCada componente AWT tiene una componente peer (nativa)
equivalente.
üEjemplo: cuando se usa el AWT para crear una instancia de la clase
Menu, la JVM crea una instancia de un menu peer. Es el peer el que hace
el trabajo real de desplegarse y manejar el comportamiento del menú.
En este caso, el JDK de Solaris creará un objeto menú peer Motif; el
JDK de Windows’95 creará menú peer Windows’95; el JDK de Macintosh
creará menú peer Macintosh, etc.
Componentes AWT y Peers
El programa JAVA crea y despliega una componente AWT, quien a su vez crea y despliega una componentes
nativa -peer-.
Programa Java Java AWT
Sistema de
Ventanas
Nativo, Peers
Presentación
Windows’95
MAC
Motif

8. Componentes AWT y Peers
Ventajas y desventajas del diseño basado en
peers:
El diseño basado en
peers no es escalable.
Desventajas
Retiene el “look
and feel” de la
plataforma
donde se
ejecuta el
applet ó la
aplicación.
Evita reimplementar la
funcionalidad provista
por las componentes
nativas de GUI.
Ventajas

9. Componentes AWT
Heavyweigth
ü Las componentes AWT estándares son heavyweigth:
ü Tienen un peer nativo, por lo tanto no pueden extenderse
para modificar el comportamiento por defecto.
ü Se pintan en su propia ventana nativa. En general tienen
forma rectangular y no son transparentes.
ü En la versión 1.0 del AWT la implementación de componentes
personalizadas (por ej. un botón con imágenes) implicaba
extender la clase java.awt.Canvas (ó java.awt.Container para
implementar un contener). No se podían extender
java.awt.Component ni java.awt.Container. Estas clases
solamente podían ser subclaseadas por clases del paquete
java.awt ya que sus constructores tenían alcance de paquete.

10. Componentes AWT
Lightweigth
ü El AWT 1.1 introduce componentes de GUI lightweigth:
üNo están basadas en peers.
üSe pintan en la ventana de su contenedor
heavyweigth (en el objeto graphic del contenedor).
Tienen forma inorgánica y son transparentes.
üSe implementan extendiendo las clases
java.awt.Component ó java.awt.Container.
ü Las componentes lightweigth necesitan un contenedor
heavyweigth donde dibujarse (por eso son
transparentes). Esto no es un inconveniente ya que las
componentes residen en un Applet ó en un Frame que son
contenedores heavyweigth (en el caso de aplicaciones).

11. Componentes AWT
Lightweigth
ü La manipulación de las componentes lightweigth es igual a
la de las heavyweigth. Esto es, se establece la posición, se
agregan a los contenedores, se pintan, etc..
ü Las componentes lightweigth NO tienen un objeto gráfico
propio donde pintarse.
ü Los contenedores lightweigth NO tienen layout manager
preestablecido. Es necesario establecer un layout
manager ó ubicar en forma manual cada una de sus
componentes.
ü Las componentes Swing provistas en el JDK 1.2 son
lightweigth y reemplazan a las componentes AWT
heavyweigth. Además proveen componentes de GUI
adicionales como tablas, árboles, cajas de diálogo.

12. üEn AWT las componentes se pintan de acuerdo a
un:
üRequerimiento del sistema:
El sistema le pide a la componente que despliegue su
contenido, usualmente porque la componente es la
primera vez que se muestra en la pantalla ó cambia de
tamaño ó necesita ser reparada (por ej. un objeto que
antes la tapaba parcialmente se movió).
üRequerimiento de la aplicación:
La componente decide que necesita actualizar su
contenido debido a que su estado interno cambió (por ej.
al presionar un botón mostrarlo con apariencia de
hundido).
Pintar componentes en AWT

13. üAWT usa un mecanismo de “callback” para pintar
las componentes. Esto significa que el programa
debe sobreescribir un método particular ubicando
allí el código para pintar y el AWT se encarga de
invocar este método en el momento preciso
(cuando se necesita pintar la componente).
üEste mecanismo es similar para las componentes
heavyweigth y lightweigth.
üEl método que debe sobreescribirse es:
public void paint (Graphics g)
El objeto Graphics pasado como
parámetro debe pre-configurarse con el
estado apropiado: color, fonts, área que
necesita ser reparada
Pintar componentes en AWT

14. üNo es recomendado desde un programa invocar
directamente al método paint().
üLos métodos de java.awt.Component:
public void repaint()
public void repaint(long tm)
public void repaint(int x, int y, int width, int heigth)
public void repaint(long tm, int x, int y, int width, int heigth)
Permiten que los programas realicen un
requerimiento explícito de pintado en forma
asincrónica.
üEl método repaint() causa que TODA la
componente se pinte. Los métodos repaint con
argumentos permiten definir la región que necesita
repararse.
Pintar componentes en AWT

15. Requerimiento de pintado de
componentes
El AWT causa que un thread invoque al
método update() sobre la componente.
Si la componente no sobreescribe el método
update(), la implementación por defecto
limpia el background de la componente e
invoca al método paint().
El programa invoca al método repaint() sobre
la componente. Esto causa que se registre un
pedido asincrónico al AWT para que se vuelva
a pintar la componente.
El AWT causa que un thread invoque al
método paint() sobre la componente
El programa determina que toda ó parte de
una componente necesita volver a pintarse in
respuesta a un cambio de estado interno.
El AWT determina que toda ó parte de
una componente necesita ser pintada.
El AWT causa un PaintEvent
Originado desde una aplicaciónOriginado desde el sistema
Si la componente heavyweigth
necesita actualizarse
continuamente (por ej. una
animación ), el método update()
debe sobreescribirse para invocar
sólo al paint(). Eliminando el
borrado de la componente, se
reduce el papadeo

16. Requerimiento de pintado de
componentes
üSi la componente es lightweigth, cuando el
contenedor padre pinta su ventana, debe propagar la
invocación al método paint() sobre todos sus
descencientes lightweigth visibles. El método paint()
de java.awt.Container (definido en AWT 1.1), es el
encargado de invocar al método paint() sobre todos
sus componentes lightweigth visibles.
üEs fundamental que toda subclase de Container
(lightweigth ó heavyweigth) que sobreescriba el
método paint() invoque al super.paint() para
asegurar que sus componentes lightweigth se pinten.
En otro caso, las componentes ligthweigth no se ven.

17. Paquetes del AWT
soporte de impresiónjava.awt.print
interfaces peers para componentes peersjava.awt.peer
métodos inputjava.awt.im
geometría 2Djava.awt.geom
fonts 2Djava.awt.font
soporte de drag and dropjava.awt.dnd
manejo de coloresjava.awt.color
tecnologías para asistir al usuariojava.awt.accessibility
clases para manipulación de imágenesjava.awt.image
soporte para clipboard y transferencia de
datos
java.awt.datatransfer
clases de eventos e interfaces listenersjava.awt.event
funcionalidad de las componentes básicas de
GUI
java.awt
DescripciónPaquetes AWT

18. üLa clase java.awt.Container es una clase abstracta, subclase de
java.awt.Component. Los objetos Container son simplemente componentes
AWT que pueden contener otras componentes.
üTodo objeto Container tiene una referencia a un objeto
LayoutManager, que es el responsable de ubicar y distribuir las
componentes. Cada vez que ocurre un evento que provoca que el
contenedor tenga que acomodar sus componentes (por ej. cambió el
tamaño de la ventana), el layout manager del contenedor es invocado para
reacomodar las componentes. Diferentes layout managers implementan
diferentes algoritmos para reubicar componentes.
üLa clase Applet es subclase de Panel, que a su vez es subclase de
Container, por lo tanto las applets heredan toda la capacidad de contener
y acomodar componentes sobre la pantalla. Así se simplifica el diseño de
las applets.
AWT - Containers

19. AWT - Containers
No tiene menubar ni borde.
Es la superclase de Frame y Dialog.
Window
Permite hacer “Scroll” de una
componente.
ScrollPane
Es un simple contenedor.Panel
Es subclase de Window.
Es el contenedor de las aplicaciones.
Puede contener un menubar.
Frame
Es un Dialog para elegir archivos.FileDialog
Es subclase de Window.
Puede ser modal o no-modal.
Dialog
Es subclase de Panel.
Es la superclase de todas las applets.
Applet
DescripciónSubclases

20. AWT - Layout Manager
üLos containers delegan en el layout manager todo lo
relacionado a la ubicación, tamaño, espaciado y distribución de
sus componentes en la pantalla.
üLa interfaz LayoutManager define métodos para calcular
tamaños mínimos y preferidos de sus contenedores y ubicar
las componentes en un contenedor.
üUn contenedor tiene exactamente un Layout Manager y un
Layout Manager resuelve el trabajo de más de un contenedor.
üEl AWT define cinco clases que implementan las interfaces
LayoutManager o LayoutManager2 (son los layouts que
establecen restricciones sobre las componentes):
BorderLayout, CardLayout, FlowLayout, GridBagLayout y
GridLayout

21. AWT - Layout Manager
Ubica las componentes en una grilla de celdas de igual tamaño.GridLayout
Es el layout más sofisticado y flexible. Ubica las componentes en una
grilla de filas y columnas, permitiendo que algunas componentes usen más
de una celda. No todas las filas tienen la misma altura, ni todas las
columnas el mismo ancho.
GridBagLayout
Es el layout por defecto de objetos Panel. Ubica las componentes de
izquierda a derecha, usando nuevas filas si es necesario. Es posible
alinear las componentes y establecer el espaciado entre las componentes.
FlowLayout:
Es usado para contener en una misma área diferentes componentes en
momentos diferentes. Frecuentemente es controlado por un objeto
Choice.
CardLayout
Es el layout por defecto de objetos Window. Establece restricciones
especificadas mediante strings sobre las componentes : North, South,
East, West, Center. Además es posible especificar el espaciado entre las
componentes.
BorderLayout

22. AWT - FlowLayout
ü Es el layout manager por defecto de Panel.
ü El FlowLayout acomoda las componentes del container en una fila, centradas
y con su tamaño preferido. Si el espacio horizontal del container no es
suficiente para ubicar a todas las componentes en una fila, el FlowLayout
utiliza múltiples filas.
ü El FlowLayout tiene tres constructores:
üFlowLayout()
üFlowLayout(int alineacion): establece diferentes alineaciones de las componentes
(izquierda, derecha, centrado).
üFlowLayout(int alineacion, int horizEsp, int vertEsp): establece un espaciado
horizontal y vertical entre componentes.
setLayout(new FlowLayout());
..................
add(new Button(“Button 1”));
add(new Button(“2”));
add(new Button(“Button 3”));
add(new Button(“Long-Named Button 4”));
add(new Button(“Button 5”));

23. AWT - BorderLayout
ü Es el layout manager por defecto de Window (Dialog y Frame).
ü El BorderLayout usa cinco áreas para acomodar las componentes del
container: North, South, East, West y Center. Al agrandar la ventana, el área
central es la que ocupará la mayor parte del espacio disponible, las restantes
áreas se expanden solamente lo necesario como para completar el espacio. Por
defecto, el BorderLayout no usa espaciado entre componentes.
setLayout(new BorderLayout());
..................
add(“North”, new Button(“North”));
add(“South”, new Button(“South”));
add(“East”, new Button(“East”));
add(“West”, new Button(“West”));
add(“Center”, new Button(“Center”));

24. public class UIDemo extends Applet {
Button b1,b2;
Checkbox c1;
Label l1;
public void init(){
b1=new Button();
b1.setLabel(“Botón 1”);
................
b2=new Button(“Botón 2”);
................
c1=new Checkbox(“Checkbox 1”,false);
l1=new Label();
l1.setText(“Label 1”);
l1.setAlignment(label.RIGHT);
//Agrega Componentes usando el FlowLayout (layout manager de default)
add(b1);
add(b2);
add(c1);
add(l1);
}
}
AWT - Ejemplo
Agrega las componentes de la GUI al applet
Container

25. üA partir del AWT 1.1, el manejo de eventos de la GUI está
basado en el modelo de delegación. La versión original del
AWT basó su manejo de eventos en herencia.
üLa premisa del modelo de delegación de eventos es simple:
objetos que disparán ú originan eventos llamados fuentes del
evento y objetos que escuchan y atienden esos eventos
llamados listeners del evento.
üLos objetos que disparán eventos son las componentes de
GUI (fuentes generadoras de eventos) y, delegan el manejo
de los mismos a los objetos listeners.
üLos objetos listeners son registrados sobre las componentes
invocando al método: addXYZListenter(XYZListener).
üLuego de la registración, los métodos apropiados del listener
serán invocados cuando el tipo de evento correspondiente
ocurra sobre la componente.
Manejo de Eventos en AWT 1.1

26. Manejo de Eventos en AWT 1.1
üLas componentes que generan eventos implementan un método para la
registración de listeners (por ej. Button.addActionListener(ActionListener)
y Button.removeActionListener(ActionListener)). De esta manera, los
objetos listeners de un tipo determinado pueden registrar interés ó
desregistrar interés en los eventos que la componente dispara.
üCuando un evento ocurre, la componente que lo originó instancia un evento
apropiado que es pasado al/los listeners que se registraron sobre la
componente.
üLos listeners son los responsables de implementar métodos para el manejo
de eventos. Estos métodos tienen como parámetro un objeto evento que
contiene información acerca del evento y al objeto que originó el evento.
Fuente de Eventos
Listener de Eventos
Ocurre un Evento
fuente.addListenerType(new ListenerType())1)
2)
3) Se instancia un evento de un tipo apropiado (event)
4) listener.eventHandler(event)

27. AWT - Clases de Eventos
MOUSE_CLICKED
MOUSE_ENTERED
MOUSE_EXITED
MOUSE_PRESSED
MOUSE_RELEASED
...................
EventObject
AWTEvent
ActionEvent AdjustmentEvent ItemEvent TextEvent
ContainerEvent FocusEvent PaintEvent WindowEvent
KeyEventMouseEvent
Objeto que generó el evento
A
CompomentEvent
InputEvent
WINDOW_ACTIVATED
WINDOW_DEACTIVATED
WINDOW_OPENED
WINDOW_CLOSED
WINDOW_ICONIFIED
La clase java.util.EventObject es uno de los fundamentos del modelo de delegación de eventos.
En el modelo de delegación de eventos estructura los eventos por clases de eventos relacionados.
A
Eventos para activar,
desactivar, cerrar, abrir,
minimizar y maximizar
ventanas.

28. AWT - Interfaces EventListener
EventListener
Action-
Listener
AdjustmentL
istener
Component-
Listener
Focus-
Listener
Text-
Listener
Window-
Listener
MouseMotion-
Listener
Mouse-Listener
Container-
Listener
KeyListener
Item-
Listener
Las interfaces EventListener residen en los paquetes java.util y java.awt.event
actionPerformed(ActionEvent)
mouseClicked(MouseEvent)
mouseEntered(MouseEvent)
mouseExited(MouseEvent)
mousePressed(MouseEvent)
mouseReleased(MouseEvent)
textValueChanged(TextEvent)

29. ü En el paquete java.awt.event se definen once (11)
interfaces para los diferentes tipos de eventos.
ü Cada interfaz listener define métodos que serán
invocados cuando ocurre un evento específico. Por
ejemplo, la interfaz ActionListener define un método
actionPerformed() que es invocado cuando un evento
action es disparado por una componente (por ej. un
botón).
ü Los listeners asociados a una componente son los
encargados de interceptar y atender los eventos
generados por la componente para los que el listener
registró interés.
AWT - Interfaces EventListener

30. import java.awt.*;
import java.awt.event.*;
import java.applet.Applet;
public class BotonTest extends Applet implements MouseListener {
public void init () {
Button boton = new Button(“Click”);
boton.addMouseListener(this);
add(boton);
}
public void mouseEntered(MouseEvent event){
System.out.println(“Mouse Enter”);
}
public void mouseExited(MouseEvent event){
System.out.println(“Mouse Exit”);
}
public void mousePressed(MouseEvent event){ }
public void mouseClicked(MouseEvent event){ }
public void mouseReleased(MouseEvent event){ }
}
AWT – Ejemplo de Interfaces Listener
El “listener” (applet) se registra con el botón
El botón
origina
eventos
con el
mouse

31. import java.awt.*;
import java.awt.event.*;
import java.applet.Applet;
public class BotonTest2 extends Applet {
public void init () {
Button boton = new Button(“Click”);
boton.addMouseListener(new ButtonMouseListener());
add(boton);
}
public ButtonMouseListener extends MouseAdapter {
public void mouseEntered(MouseEvent event){
System.out.println(“Mouse Enter”);
}
public void mouseExited(MouseEvent event){
System.out.println(“Mouse Exit”);
}
}
AWT - Ejemplo de Clases Adapters
La clase
MouseAdapter,
implementa la interfaz
MoudeListener
Clase
interna
subclase de
Adapter
}