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.
 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.
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.
 Componentes AWT

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 estándares
Panel
Canvas Button

TextArea
TextField

ScrollPane

List Choice

Checkbox Label

ScrollBar
 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.
 Componentes AWT y Peers
ü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.

Windows’95
Presentación
MAC
Sistema de Motif
Programa Java Java AWT Ventanas
Nativo, Peers

El programa JAVA crea y despliega una componente AWT, quien a su vez crea y despliega una componentes
nativa -peer-.
 Componentes AWT y Peers

Ventajas y desventajas del diseño basado en

peers:
Ventajas Evita reimplementar la Retiene el “look
funcionalidad provista and feel” de la
por las componentes plataforma
nativas de GUI. donde se
ejecuta el
applet ó la
aplicación.

Desventajas El diseño basado en

peers no es escalable.
 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.
 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).
 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.
 Pintar componentes en AWT

ü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
ü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
ü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.
 Requerimiento de pintado de
componentes
Originado desde el sistema
El AWT determina que toda ó parte de
una componente necesita ser pintada.
El AWT causa un PaintEvent
El AWT causa que un thread invoque al
método paint() sobre la componente
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
Originado desde una aplicación
El programa determina que toda ó parte de
una componente necesita volver a pintarse in
respuesta a un cambio de estado interno.
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 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().
 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.
 Paquetes del AWT
Paquetes AWT Descripción
java.awt funcionalidad de las componentes básicas de
GUI
java.awt.event clases de eventos e interfaces listeners
java.awt.datatransfer soporte para clipboard y transferencia de
datos
java.awt.image clases para manipulación de imágenes
java.awt.accessibility tecnologías para asistir al usuario
java.awt.color manejo de colores
java.awt.dnd soporte de drag and drop
java.awt.font fonts 2D
java.awt.geom geometría 2D
java.awt.im métodos input
java.awt.peer interfaces peers para componentes peers
java.awt.print soporte de impresión
 AWT - Containers
ü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

Subclases Descripción
Applet Es subclase de Panel.
Es la superclase de todas las applets.
Dialog Es subclase de Window.
Puede ser modal o no-modal.
FileDialog Es un Dialog para elegir archivos.
Frame Es subclase de Window.
Es el contenedor de las aplicaciones.
Puede contener un menubar.
Panel Es un simple contenedor.
ScrollPane Permite hacer “Scroll” de una
componente.
Window No tiene menubar ni borde.
Es la superclase de Frame y Dialog.
 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
 AWT - Layout Manager

BorderLayout 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.
CardLayout Es usado para contener en una misma área diferentes componentes en
momentos diferentes. Frecuentemente es controlado por un objeto
Choice.
FlowLayout: 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.
GridBagLayout 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.
GridLayout Ubica las componentes en una grilla de celdas de igual tamaño.
 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”));
 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”));
 AWT - Ejemplo
public class UIDemo extends Applet {
Button b1,b2;
Checkbox c1;
Label l1; Container
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); Agrega las componentes de la GUI al applet
add(c1);
add(l1);
}
}
 Manejo de Eventos en AWT 1.1
ü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
ü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.
3) Se instancia un evento de un tipo apropiado (event)

2) 4) listener.eventHandler(event)
Ocurre un Evento Fuente de Eventos

Listener de Eventos

1) fuente.addListenerType(new ListenerType())
 AWT - Clases de Eventos
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.

Objeto que generó el evento

EventObject

Eventos para activar,

desactivar, cerrar, abrir,
minimizar y maximizar
AWTEvent ventanas.
A

ActionEvent AdjustmentEvent CompomentEvent ItemEvent TextEvent

ContainerEvent FocusEvent InputEvent PaintEvent WindowEvent

A

MOUSE_CLICKED WINDOW_ACTIVATED
MOUSE_ENTERED WINDOW_DEACTIVATED
MOUSE_EXITED MouseEvent KeyEvent WINDOW_OPENED
MOUSE_PRESSED WINDOW_CLOSED
MOUSE_RELEASED WINDOW_ICONIFIED
...................
 AWT - Interfaces EventListener
Las interfaces EventListener residen en los paquetes java.util y java.awt.event

EventListener

Action-
Window-
Listener
Listener
actionPerformed(ActionEvent)
AdjustmentL MouseMotion-
istener Listener

Component- Mouse-Listener
Listener

Focus- KeyListener mouseClicked(MouseEvent)

Listener mouseEntered(MouseEvent)
mouseExited(MouseEvent)
Item-
mousePressed(MouseEvent)
Listener mouseReleased(MouseEvent)
Container-
Listener Text-
Listener
textValueChanged(TextEvent)
 AWT - Interfaces EventListener
ü 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 – Ejemplo de Interfaces Listener
import java.awt.*;
import java.awt.event.*;
import java.applet.Applet;

public class BotonTest extends Applet implements MouseListener {

public void init () {
El botón Button boton = new Button(“Click”);
origina
eventos
boton.addMouseListener(this); El “listener” (applet) se registra con el botón
con el add(boton);
mouse }

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 Clases Adapters
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); La clase
MouseAdapter,
}
implementa la interfaz
MoudeListener
public ButtonMouseListener extends MouseAdapter {
public void mouseEntered(MouseEvent event){
System.out.println(“Mouse Enter”);
Clase
}
interna
subclase de public void mouseExited(MouseEvent event){
Adapter System.out.println(“Mouse Exit”);
}
}
}