Jfc java

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 heavyweigthdel AWT por componentes lightweigth.

ü Java 2D: es un conjunto de clases que permiten manipular gráficos 2D avanzadose imágenes.

ü Accesibility: consiste en un conjunto de clases que permiten a las componentesSwing 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 siguienteinfraestructura:ü 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 mitadde 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 detamaño de las componentes dentro de un contenedor. Java proveevarias clases que implementan estas interfaces.üClase Graphics: es una clase abstracta que define métodos para

realizar operaciones gráficas sobre una componente (mostrarimágenes, texto, establecer colores y fonts). Toda componente AWTtiene 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 objetosComponent y Container: los containers pueden contener components.

üTodos los containers tienen asociado un layout manager (excepto laclase java.awt.Container) que establece la ubicación y la forma de lascomponentes del Container.

üLas responsabilidades del layout manager las definen las interfacesjava.awt.LayoutManager y java.awt.LayoutManager2.

La clase java.awt.Component es una clase abstracta queprovee una amplia funcionalidad, heredada por todas sussubclases. Los controles de la interfaz de usuario comobotones, scrollbars, labels, text, fields, etc. son subclase dejava.awt.Component. Cada componente AWT tiene asociadala 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

Componentes AWT estándaresPanel

Button

TextArea

Choice

Label

ScrollBar

Checkbox

List

TextField

Canvas

ScrollPane

Componentes AWT y Peers

üEl AWT original (versión 1.0) basó el diseñode sus componentes de GUI en peers.üLos peers son componentes de GUI nativas

(del sistema donde se ejecutan) manipuladaspor componentes AWT. Las clases AWTencapsulan a los peers.üLas componentes AWT estándares delegan en

los peers la mayor parte de su funcionalidad.

üCada componente AWT tiene una componente peer (nativa)equivalente.üEjemplo: cuando se usa el AWT para crear una instancia de la claseMenu, la JVM crea una instancia de un menu peer. Es el peer el que haceel trabajo real de desplegarse y manejar el comportamiento del menú.En este caso, el JDK de Solaris creará un objeto menú peer Motif; elJDK de Windows’95 creará menú peer Windows’95; el JDK de Macintoshcreará menú peer Macintosh, etc.


El programa JAVA crea y despliega una componente AWT, quien a su vez crea y despliega una componentesnativa -peer-.

Programa Java Java AWTSistema deVentanas

Nativo, Peers

Presentación Windows’95MACMotif


Ventajas y desventajas del diseño basado enpeers:

El diseño basado enpeers no es escalable.

Desventajas

Retiene el “lookand feel” de laplataformadonde seejecuta elapplet ó laaplicación.

Evita reimplementar lafuncionalidad provistapor las componentesnativas de GUI.

Ventajas

Componentes AWTHeavyweigth

ü 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) implicabaextender la clase java.awt.Canvas (ó java.awt.Container paraimplementar un contener). No se podían extenderjava.awt.Component ni java.awt.Container. Estas clasessolamente podían ser subclaseadas por clases del paquetejava.awt ya que sus constructores tenían alcance de paquete.

Componentes AWTLightweigth

üEl AWT 1.1 introduce componentes de GUI lightweigth:üNo están basadas en peers.üSe pintan en la ventana de su contenedorheavyweigth (en el objeto graphic del contenedor).Tienen forma inorgánica y son transparentes.üSe implementan extendiendo las clasesjava.awt.Component ó java.awt.Container.

ü Las componentes lightweigth necesitan un contenedorheavyweigth donde dibujarse (por eso sontransparentes). Esto no es un inconveniente ya que lascomponentes residen en un Applet ó en un Frame que soncontenedores heavyweigth (en el caso de aplicaciones).

Componentes AWTLightweigth

ü La manipulación de las componentes lightweigth es igual ala de las heavyweigth. Esto es, se establece la posición, seagregan a los contenedores, se pintan, etc..

ü Las componentes lightweigth NO tienen un objeto gráficopropio donde pintarse.

ü Los contenedores lightweigth NO tienen layout managerpreestablecido. Es necesario establecer un layoutmanager ó ubicar en forma manual cada una de suscomponentes.

ü Las componentes Swing provistas en el JDK 1.2 sonlightweigth y reemplazan a las componentes AWTheavyweigth. Además proveen componentes de GUIadicionales como tablas, árboles, cajas de diálogo.

üEn AWT las componentes se pintan de acuerdo aun:üRequerimiento del sistema:

El sistema le pide a la componente que despliegue sucontenido, usualmente porque la componente es laprimera vez que se muestra en la pantalla ó cambia detamaño ó necesita ser reparada (por ej. un objeto queantes la tapaba parcialmente se movió).üRequerimiento de la aplicación:

La componente decide que necesita actualizar sucontenido debido a que su estado interno cambió (por ej.al presionar un botón mostrarlo con apariencia dehundido).

Pintar componentes en AWT

üAWT usa un mecanismo de “callback” para pintarlas componentes. Esto significa que el programadebe sobreescribir un método particular ubicandoallí el código para pintar y el AWT se encarga deinvocar este método en el momento preciso(cuando se necesita pintar la componente).üEste mecanismo es similar para las componentesheavyweigth 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 elestado apropiado: color, fonts, área que

necesita ser reparada


üNo es recomendado desde un programa invocardirectamente 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 unrequerimiento explícito de pintado en formaasincrónica.üEl método repaint() causa que TODA lacomponente se pinte. Los métodos repaint conargumentos permiten definir la región que necesitarepararse.


Requerimiento de pintado decomponentes

El AWT causa que un thread invoque almétodo update() sobre la componente.

Si la componente no sobreescribe el métodoupdate(), la implementación por defectolimpia el background de la componente einvoca al método paint().

El programa invoca al método repaint() sobrela componente. Esto causa que se registre unpedido asincrónico al AWT para que se vuelvaa pintar la componente.

El AWT causa que un thread invoque almétodo paint() sobre la componente

El programa determina que toda ó parte deuna componente necesita volver a pintarse inrespuesta a un cambio de estado interno.

El AWT determina que toda ó parte deuna componente necesita ser pintada.El AWT causa un PaintEvent

Originado desde una aplicaciónOriginado desde el sistema

Si la componente heavyweigthnecesita actualizarse

continuamente (por ej. unaanimación ), el método update()

debe sobreescribirse para invocarsólo al paint(). Eliminando el

borrado de la componente, sereduce el papadeo

Requerimiento de pintado decomponentes

üSi la componente es lightweigth, cuando elcontenedor padre pinta su ventana, debe propagar lainvocación al método paint() sobre todos susdescencientes lightweigth visibles. El método paint()de java.awt.Container (definido en AWT 1.1), es elencargado de invocar al método paint() sobre todossus componentes lightweigth visibles.üEs fundamental que toda subclase de Container(lightweigth ó heavyweigth) que sobreescriba elmétodo paint() invoque al super.paint() paraasegurar que sus componentes lightweigth se pinten.En otro caso, las componentes ligthweigth no se ven.

Paquetes del AWT

soporte de impresiónjava.awt.printinterfaces peers para componentes peersjava.awt.peermétodos inputjava.awt.imgeometría 2Djava.awt.geomfonts 2Djava.awt.fontsoporte de drag and dropjava.awt.dndmanejo de coloresjava.awt.colortecnologías para asistir al usuariojava.awt.accessibilityclases para manipulación de imágenesjava.awt.image

soporte para clipboard y transferencia dedatos

java.awt.datatransferclases de eventos e interfaces listenersjava.awt.event

funcionalidad de las componentes básicas deGUI

java.awtDescripciónPaquetes AWT

üLa clase java.awt.Container es una clase abstracta, subclase dejava.awt.Component. Los objetos Container son simplemente componentesAWT que pueden contener otras componentes.

üTodo objeto Container tiene una referencia a un objetoLayoutManager, que es el responsable de ubicar y distribuir lascomponentes. Cada vez que ocurre un evento que provoca que elcontenedor tenga que acomodar sus componentes (por ej. cambió eltamaño de la ventana), el layout manager del contenedor es invocado parareacomodar las componentes. Diferentes layout managers implementandiferentes algoritmos para reubicar componentes.

üLa clase Applet es subclase de Panel, que a su vez es subclase deContainer, por lo tanto las applets heredan toda la capacidad de contenery acomodar componentes sobre la pantalla. Así se simplifica el diseño delas applets.

AWT - Containers

AWT - Containers

No tiene menubar ni borde.Es la superclase de Frame y Dialog.

Window

Permite hacer “Scroll” de unacomponente.

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

AWT - Layout ManagerüLos containers delegan en el layout manager todo lorelacionado a la ubicación, tamaño, espaciado y distribución desus componentes en la pantalla.

üLa interfaz LayoutManager define métodos para calculartamaños mínimos y preferidos de sus contenedores y ubicarlas componentes en un contenedor.

üUn contenedor tiene exactamente un Layout Manager y unLayout Manager resuelve el trabajo de más de un contenedor.

üEl AWT define cinco clases que implementan las interfacesLayoutManager o LayoutManager2 (son los layouts queestablecen restricciones sobre las componentes):BorderLayout, CardLayout, FlowLayout, GridBagLayout yGridLayout

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 unagrilla de filas y columnas, permitiendo que algunas componentes usen másde una celda. No todas las filas tienen la misma altura, ni todas lascolumnas el mismo ancho.

GridBagLayout

Es el layout por defecto de objetos Panel. Ubica las componentes deizquierda a derecha, usando nuevas filas si es necesario. Es posiblealinear las componentes y establecer el espaciado entre las componentes.

FlowLayout:

Es usado para contener en una misma área diferentes componentes enmomentos diferentes. Frecuentemente es controlado por un objetoChoice.

CardLayout

Es el layout por defecto de objetos Window. Establece restriccionesespecificadas mediante strings sobre las componentes : North, South,East, West, Center. Además es posible especificar el espaciado entre lascomponentes.

BorderLayout

AWT - FlowLayoutü Es el layout manager por defecto de Panel.ü El FlowLayout acomoda las componentes del container en una fila, centradasy con su tamaño preferido. Si el espacio horizontal del container no essuficiente para ubicar a todas las componentes en una fila, el FlowLayoututiliza 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 espaciadohorizontal 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 delcontainer: North, South, East, West y Center. Al agrandar la ventana, el áreacentral es la que ocupará la mayor parte del espacio disponible, las restantesáreas se expanden solamente lo necesario como para completar el espacio. Pordefecto, 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”));

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

ü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 delAWT 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 delevento y objetos que escuchan y atienden esos eventosllamados listeners del evento.üLos objetos que disparán eventos son las componentes deGUI (fuentes generadoras de eventos) y, delegan el manejode los mismos a los objetos listeners.üLos objetos listeners son registrados sobre las componentesinvocando al método: addXYZListenter(XYZListener).üLuego de la registración, los métodos apropiados del listenerserán invocados cuando el tipo de evento correspondienteocurra sobre la componente.

Manejo de Eventos en AWT 1.1

Manejo de Eventos en AWT 1.1üLas componentes que generan eventos implementan un método para laregistración de listeners (por ej. Button.addActionListener(ActionListener)y Button.removeActionListener(ActionListener)). De esta manera, losobjetos 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 eventoapropiado que es pasado al/los listeners que se registraron sobre lacomponente.üLos listeners son los responsables de implementar métodos para el manejode eventos. Estos métodos tienen como parámetro un objeto evento quecontiene 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)

AWT - Clases de Eventos

MOUSE_CLICKEDMOUSE_ENTEREDMOUSE_EXITEDMOUSE_PRESSEDMOUSE_RELEASED...................

EventObject

AWTEvent

ActionEvent AdjustmentEvent ItemEvent TextEvent

ContainerEvent FocusEvent PaintEvent WindowEvent

KeyEventMouseEvent

Objeto que generó el evento

A

CompomentEvent

InputEvent

WINDOW_ACTIVATEDWINDOW_DEACTIVATEDWINDOW_OPENEDWINDOW_CLOSEDWINDOW_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 maximizarventanas.

AWT - Interfaces EventListener

EventListener

Action-Listener

AdjustmentListener

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)

ü 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áninvocados cuando ocurre un evento específico. Porejemplo, la interfaz ActionListener define un métodoactionPerformed() que es invocado cuando un eventoaction es disparado por una componente (por ej. unbotón).

ü Los listeners asociados a una componente son losencargados de interceptar y atender los eventosgenerados por la componente para los que el listenerregistró interés.

AWT - Interfaces EventListener

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ónEl botónoriginaeventoscon elmouse

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 claseMouseAdapter,implementa la interfazMoudeListener

Claseinternasubclase deAdapter

}

Jfc java

Documents

Transcript of Jfc java