UNIVERSIDAD CATLICA DE CUENCA

UNIDAD ACADMICA DE INGENIERA DE

SISTEMAS, ELCTRICA Y ELECTRNICA

COMPONENTE SWING DE JAVA: ADMINISTRADORES DE DISEO

Trabajo de Investigacin previo a la obtencin del

Ttulo de Ingeniero de Sistemas.

Aspirante:

TNLG. ANL. FREDDY E. QUEZADA B.

Director:

ING. AL MNDEZ.
Certifico que esta investigacin ha sido desarrollada en su totalidad por el

Tnlg. Freddy Edwin Quezada Bermeo bajo mi coordinacin.

F).

ING. ALI MNDEZ.

La informacin de la presente investigacin es de absoluta responsabilidad y

propiedad del autor.

F).

TNLG. ANL. FREDDY EDWIN QUEZADA BERMEO

 DEDICATORIA:

Este trabajo investigativo tengo el honor de dedicar a mi

esposa Adriana a mi hijo que son la razn de mi esfuerzo y

por acompaarme incondicionalmente en los momentos de

mi vida ; a mis queridos Padres que supieron educarme con

valores y acercar cada vez ms las metas propuestas en la

vida profesional como en la vida cotidiana.

 AGRADECIMIENTO:

A las personas que supieron ayudarme para que esta

investigacin fuera realizada, Mis queridos hermanos; y un

agradecimiento especial al ING. ALI MNDEZ por guiarme en

el proceso de elaboracin de esta monografa.

 NDICE

UNIVERSIDAD CATLICA DE CUENCA .......................................................... 1

CAPTULO I ........................................................................................................ 2
1.1 Historia .......................................................................................................... 2
1.2 Ventajas y Caractersticas ............................................................................ 3
1.2.1 componentes ligeros .................................................................................. 3
1.2.2 Independencia de la plataforma ................................................................. 4
1.2.3 Paquete Swing ........................................................................................... 4
1.2 Eventos Swing .............................................................................................. 7
1.3 Modelos de componentes Swing .................................................................. 8
Swing llamando a mtodos. .............................................................................. 10
1.4 Descripcin de algunos componentes Swing.............................................. 10
CAPTULO II ..................................................................................................... 13
2.1. Layouts ...................................................................................................... 13
2.2. Look &Feel ................................................................................................. 13
2.3. Nuevas caractersticas ............................................................................... 15
2.3.1 Action Con objetos Action ........................................................................ 15
2.4. Modelos de datos y estados separados ..................................................... 15
2.5. Soporte para tecnologas asistivas ............................................................ 16
2.6. Applets ....................................................................................................... 16
Estructura De Un Applet ................................................................................... 17
2.6.1. Applets en Swing .................................................................................... 18
CAPITULO III .................................................................................................... 19
3.1. Herencia de Componentes y Contenedores .............................................. 19
3.2. Control de Distribucin ............................................................................... 21
3.2.1. Seleccionar el Controlador de Distribucin ............................................. 23
3.2.2. Proporcionar Consejos sobre un Componente ...................................... 24
3.2.3 Poner Espacio entre Componentes ......................................................... 25
[Link]. El controlador de distribucin. .............................................................. 25
[Link]. Bordes vacos ...................................................................................... 25
3.2.4. Cmo Ocurre el Control de Distribucin ................................................. 26
3.3. Construccin de GUI en Swing .................................................................. 27
3.3.1 Ventanas .................................................................................................. 27
3.3.2. Mens ..................................................................................................... 28
3.3.3. Paneles ................................................................................................... 28
3.3.4. Diseos ................................................................................................... 28
3.3.5. Iconos ..................................................................................................... 29
1
3.3.6. Bordes..................................................................................................... 29
3.3.7. Informacin sobre herramientas ............................................................. 29
3.3.8. Barras de herramientas........................................................................... 29
3.3.9. Etiquetas y botones ................................................................................ 30
3.3.10. Componentes de texto .......................................................................... 30
3.3.11. Listas y cuadros combinados ................................................................ 30
3.3.12. Deslizadores y barras de progreso ....................................................... 31
3.3.13. Barras de desplazamiento .................................................................... 31
3.3.14. Tablas ................................................................................................... 31
3.3.15. rboles .................................................................................................. 32
3.4. Manejo de eventos en Swing ..................................................................... 32
3.5. Swing: Cuadros de texto. Botones y casillas de activacin ....................... 33
3.5. 1. Etiquetas y cuadros de texto .................................................................. 34
3.5. 2. Botones .................................................................................................. 34
3.5.3. Casillas de activacin y botones de opcin............................................. 35
3.5.4. Usar etiquetas ......................................................................................... 35
3.6. Swing: viewports. desplazamiento. deslizadores y listas ........................... 36
3.6.1. Viewports ................................................................................................ 37
3.6.2. Paneles de desplazamiento .................................................................... 37
3.6.3. Deslizadores ........................................................................................... 37
3.6.4. Barras de desplazamiento ...................................................................... 38
3.6.5. Listas....................................................................................................... 38
3.7. Swing: barras. Herramientas. Cuadros. Separadores y selectores ............ 39
3.7.1. Cuadros combinados .............................................................................. 39
3.7.2. Barras de progreso ................................................................................. 39
3.7.3. Selectores ............................................................................................... 40
3.7.4. Herramientas de ayuda ........................................................................... 41
3.7.5. Separadores ........................................................................................... 41
3.8. Swing: ventanas. Paneles. Marcos internos y cuadros de dialogo ............ 42
3.8.1. Ventanas ................................................................................................. 42
3.8.2. Cuadros de dilogo ................................................................................. 42
3.9. Creacin de paquetes. Interfaces. archivos JAR y Java Beans ................. 43
3.9.1. Crear un paquete .................................................................................... 43
3.9.2. Crear paquetes que contienen paquetes ................................................ 45
3.9.3 Crear una interfaz .................................................................................... 45
3.9.4. Implementacin parcial de una interfaz .................................................. 46
3.9.5. Crear un archivo JAR ............................................................................. 48
3.9.6. Obtener los contenidos del archivo JAR ................................................ 50

2
3.9.7. Extraer archivos desde un archivo JAR ................................................ 51
3.10. SwingUtilities ............................................................................................ 51
3.10.1. Mtodos de clculo .............................................................................. 52
3.10.2. Mtodos de conversin ......................................................................... 52
3.10.3. Mtodos de accesibilidad ...................................................................... 54
3.10.4 Mtodos de recuperacin....................................................................... 54
[Link] relacionados con la multitarea y los eventos ........................... 55
3.10.6. Mtodos para los botones del ratn ...................................................... 56
3.10.7 Mtodos de disposicin/dibujo/UIString ................................................. 56
4. Conclusiones .............................................................................................. 58
5. Recomendaciones ....................................................................................... 59
6. Bibliografa .................................................................................................... 61
Anexos. ............................................................................................................. 62
INTRODUCCIN. ............................................................................................. 62
DATOS INFORMATIVOS. ................................................................................ 63
LUGARES DE CONSULTA. ............................................................................. 63
JUSTIFICACIN Y PROPUESTA. ................................................................... 63
4.1. ANLISIS DE LA SITUACIN ACTUAL ................................................ 64
4.2. PROPUESTA. ........................................................................................ 64
OBJETIVOS. ..................................................................................................... 65
5.1. Objetivo General. ................................................................................... 65
5.2 Objetivos Especficos: ............................................................................. 65
ALCANCE Y LIMITACIONES. .......................................................................... 65
6.1 Alcances. ................................................................................................. 65
6.2. Limitaciones. .......................................................................................... 65
MARCO REFERENCIAL Y CONCEPTUAL. ..................................................... 66
7.1. Marco Referencial. ................................................................................. 66
7.2. Marco Conceptual. ................................................................................. 66
TEMARIO.......................................................................................................... 67
ESTRATEGIAS METODOLGICAS. ............................................................... 69
RECURSOS...................................................................................................... 70
Recursos Humanos. ...................................................................................... 70
Recursos Tecnolgicos. ................................................................................ 70
Recursos Materiales. ..................................................................................... 70
Recursos Econmicos. .................................................................................. 71
BIBLIOGRAFA. ................................................................................................ 71
CRONOGRAMA ............................................................................................... 72

3
 INTRODUCCIN

Esta Investigacin pretende ser una introduccin a Swing, con la que se

intenta mostrar una visin general sobre herramientas de interfaces grficas

de usuario, y ms concretamente, sobre el desarrollo de stas con Java y

sus APIs, lo que se pretende mostrar las ventajas que ofrece ste tipo de

programacin.

En primer lugar, se realiza una introduccin a Swing, el AWT y las interfaces

de usuario, tratando de sta forma de centrar al lector en el tema a tratar.

Una vez realizada dicha introduccin, se describir brevemente el paquete

Swing, para dar una idea de la jerarqua de componentes que se puede

utilizar con Swing y de sus utilidades.

Tambin se mencionar el manejo de eventos en Swing, as como los

Applets, aunque de una forma muy superficial, ya que debido a la gran

amplitud de variaciones que pueden darse, sera muy extenso hacer una

descripcin detallada.

1
 CAPTULO I

1.1 Historia

AWT era una herramienta poderosa que impuls la popularidad de Java.

Ahora Swing, que tiene aproximadamente cuatro veces el nmero de

componentes de la interfaz de usuario de AWT, es parte de la distribucin

estndar de Java y est tan de moda que ha llegado a desplazar a AWT. Sin

embargo, AWT tuvo un avance significativo durante su existencia, aunque

es, para los estndares de hoy, una implementacin limitada, no diseada

para proporcionar una UI seria y bsica para las necesidades de millones de

[Link] conjunto de componentes AWT no fue diseado para

soportar la popularidadcon la que fue recibido y dentro de las necesidades

de programacin dehoy, est limitado en el rango, tiene muchos bugs y

consume gran cantidad derecursos del [Link] se mencion

anteriormente en este libro, el AWT original se tarden escribir slo seis

semanas, fue modelado con controles HTML y asignadauna ventana del

sistema operativo por componente. Dado que los programadoresllegaban a

utilizar gran cantidad de controles, los colaboradores empezarona producir

sus propios conjuntos de controles, lo que hizo que en SunMicrosystems se

pusieran nerviosos. Cuando Netscape introdujo su librerade clases

ZnternetFoundationClasses para usar con Java, stas fueron muypopulares,

Sun decidi actuar y la unin de los esfuerzos de Sun y Netscapedio lugar al

conjunto de componentes Swing como parte de las ClasesFoundation de

Java (JFC).

2
Muchos programadores creen que JFC y Swing son lo mismo, pero no esas;

JFC contiene Swing y otro gran nmero de elementos. Esto es lo que hayen

JFC:

Swing: El gran paquete UI.

Cortar y pegar: Soporte de portapapeles. Accesibilidad: Ayuda a los usuarios

con aquello que no es posible hacer.

Colores del escritorio: Primero se introdujo en Java [Link] 2D:

Soporte mejorado del color, imagen y texto.

Impresin: Originalmente disponible en Java 1.1.

Swing introdujo tres avances significativos:

Utiliza pocos recursos delsistema, aade gran cantidad de componentes

ms sofisticados y permiteconstruir la apariencia de los programas.

1.2 Ventajas y Caractersticas

1.2.1 componentes ligeros

A los componentes Swing se les denomina ligeros mientras que a los

componentes AWT se lesdenominados pesados. La diferencia entre
componentes ligeros y pesados es su orden: la nocin deprofundidad. Cada
componente pesado ocupa su propia capa de orden Z. Todos los
componentes ligerosse encuentran dentro de componentes pesados y
mantienen su propio esquema de capas definido porSwing. Cuando
colocamos un componente pesado dentro de un contenedor que tambin lo
es, sesuperpondr por definicin a todos los componentes ligeros del
[Link] que esto significa es que debemos intentar evitar el uso de
componentes ligeros y pesados en unmismo contenedor siempre que sea
posible. Esto no significa que no podamos mezclar nunca con
xitocomponentes AWT y Swing, slo que tenemos que tener cuidado y
saber qu situaciones son seguras ycules no. Puesto que probablemente
3
no seremos capaces de prescindir completamente del uso decomponentes
pesados en un breve espacio de tiempo, debemos encontrar formas de que
las dostecnologas trabajen juntas de manera aceptable.
La regla ms importante a seguir es que no deberamos colocar
componentes pesados dentro decontenedores ligeros, que comnmente
soportan hijos que se superponen. Algunos ejemplos de este tipode
contenedores son JInternalFrame, JScrollPane, JLayeredPane, y
JDesktopPane. Ensegundo lugar, si usamos un men emergente en un
contenedor que posee un componente pesado,tenemos que forzar a dicho
men a ser pesado. Para controlar esto en una instancia especfica
deJPopupMenu podemos usar su mtodo setLightWeightPopupEnabled().
Alternativamente podemos llamar al mtodo esttico
setDefaultLightWeightPopupEnabled()de JPopupMenu y pasarle un valor
false para forzar a todos los mens emergentes de una sesin deJava a ser
pesados. Tenga en cuenta que slo afectar a los mens emergentes
creados a partir de que seha hecho la llamada. Es por eso una buena idea
llamar a este mtodo durante la inicializacin.

1.2.2 Independencia de la plataforma

La caracterstica ms notable de los componentes Swing es que estn

escritos al 100% en Java y nodependen de componentes nativos, como
sucede con casi todos los componentes AWT. Esto significaque un botn
Swing y un rea de texto se vern y funcionarn idnticamente en las
plataformasMacintosh, Solaris, Linux y Windows. Este diseo elimina la
necesidad de comprobar y depurar lasaplicaciones en cada plataforma
destino.

1.2.3 Paquete Swing

[Link] la mayor parte de los componentes bsicos de Swing,

modelos de componente pordefecto, e interfaces.
[Link] e interfaces que se usan para definir estilos de
bordes especficos. Observe que los bordespueden ser compartidos por

4
cualquier nmero de componentes Swing, ya que no soncomponentes por si
mismos.
[Link] e interfaces que dan soporte al
componente JColorChooser, usado para seleccin decolores.
[Link] paquete contiene todos los oyentes y eventos
especficos de Swing. Los componentes Swingtambin soportan eventos y
oyentes definidos en [Link] y [Link].
[Link]

Clases e interfaces que dan soporte al componente JFileChooser, usado

para seleccin deficheros.

[Link]

Contiene el API del comportamiento y aspecto conectable usado para definir

componentes deinterfaz de usuario personalizados. La mayora de las clases

de este paquete son abstractas. Lasimplementaciones de look-and-feel,

como metal, motif y basic, crean subclases e implementanlas clases de este

paquete. stas estn orientadas a desarrolladores que, por una razn u otra,

nopueden usar uno de los look-and-feel existentes.

[Link]

Consiste en la implementacin del Basic look-and-feel, encima del cual se

construyen loslookand-feels que provee Swing. Normalmente deberemos

usar las clases de este paquete siqueremos crear nuestro look-and-feel

personal.

[Link]

Metal es el look-and-feel por defecto de los componentes Swing. Es el nico

look-and-feel queviene con Swing y que no est diseado para ser

consistente con una plataforma especfica.

5
[Link]

Este es el Multiplexing [Link] se trata de una implementacin

normal de look-andfeelya que no define ni el aspecto ni el comportamiento

de ningn componente. Ms bienofrece la capacidad de combinar varios

look-and-feels para usarlos simultneamente. Unejemplo tpico podra ser un

look-and-feel de audio combinado con metal o motif. ActualmenteJava 2 no

viene con ninguna implementacin de multiplexing look-and-feel.

[Link]

Clases e interfaces para dar soporte al control de JTable. Este componente

se usa para manejardatos en forma de hoja de clculo. Soporta un alto

grado de personalizacin sin requerir mejorasde look-and-

[Link] e interfaces usadas por los componentes de

texto, incluyendo soporte para documentoscon o sin estilo, las vistas de

estos documentos, resaltado, acciones de editor y personalizacindel

teclado.

[Link]

Esta extensin del paquete text contiene soporte para componentes de texto

HTML. (El soportede HTML est siendo ampliado y reescrito completamente

mientras escribimos este libro. Espor ello que la cobertura que le damos es

muy limitada.)

[Link]

Soporte para analizar gramaticalmente HTML.

[Link]

Contiene soporte para documents RTF.

6
 [Link]

Clases e interfaces que dan soporte al componente JTree. Este componente

se usa para mostrary manejar datos que guardan alguna jerarqua. Soporta

un alto grado de personalizacin sin

requerir mejoras de look-and-feel.

[Link]

El paquete undo contiene soporte para implementar y manejar la

funcionalidaddeshacer/rehacer.

1.2 Eventos Swing

El modelo de eventos que utiliza Swing es el mismo que AWT, el de Java

1.1, aadiendoalgunos nuevos eventos para los nuevos componentes.

Utilizando igualmente las interfacesListener, las clases Adapter o las clases

annimas para registrar los objetos que se encargaran de

gestionar los [Link] de los nuevos eventos son:

a.) Eventos de bajo nivel

MenuKeyEvent

MenuDragMouseEvent

b.) Eventos de alto nivel

AncestorEvent: Antecesor aadido desplazado o eliminado.

CaretEvent: El signo de intercalacin del texto ha cambiado.

ChangeEvent: Un componente ha sufrido un cambio de estado.

DocumentEvent: Un documento ha sufrido un cambio de estado.

HyperlinkEvent: Algo relacionado con un vnculo hipermedia ha cambiado.

7
 InternalFrameEvent: Un AWTEvent que aade soporte para

objetosJInternalFrame.

ListDataEvent: El contenido de una lista ha cambiado o se ha aadido o

eliminadoun intervalo.

ListSelectionEvent: La seleccin de una lista ha cambiado.

MenuEvent: Un elemento de men ha sido seleccionado o mostrado o bien

noseleccionado o cancelado.

PopupMenuEvent: Algo ha cambiado en JPopupMenu.

TableColumnModelEvent: El modelo para una columna de tabla ha

cambiando.

TableModelEvent: El modelo de una tabla ha cambiado.

TreeExpansionEvent: El nodo de un rbol se ha extendido o se ha

colapsado.

TreeModelEvent: El modelo de un rbol ha cambiado.

TreeSelectionEvent: La seleccin de un rbol ha cambiado de estado.

UndoableEditEvent: Ha ocurrido una operacin que no se puede realizar.

1.3 Modelos de componentes Swing

En principio implementa de nuevo todos los componentes grficos existente

en el AWT, pero en este caso con implementaciones ligeras, o lighweight,

con todas las ventajas que esto implica.

Adems aade nuevas y tiles funcionalidades a estos componentes, tales

como la posibilidad de presentar imgenes o animaciones en botones,

etiquetas, listas o casi cualquier elemento grfico.

8
Este paquete nuevo est enteramente basado en AWT y ms

especficamente en el soporte para interfaz de usuario ligero. Debido a ello y

a ser puro Java, es posible hacer aplicaciones basadas en Swing desde la

plataforma 1.1.5 y que funcione sin ningn problema con la JVM de dicha

plataforma, as como con la incluida junto con los navegadores ms

actuales, lo que asegura que un applet realizado usando estos nuevos

componentes funcionar sin problemas en dichos navegadores.

Entre los componentes que se incorporan en Swing est la

reimplementacin de todos los componentes grficos existentes en AWT y

que, para no confundir con los antiguos, ahora empiezan todos por J. As en

vez de Button, tenemos JButton.

La mayor diferencia entre los componentes AWT y los componentes Swing

es que stos ltimos estn implementados sin nada de cdigo nativo. Esto

significa que los componentes Swing pueden tener ms funcionalidad que

los componentes AWT, porque no estn restringidos al denominador comn,

es decir las caractersticas presentes en cada plataforma. El no tener cdigo

nativo tambin permite que los componentes Swing sean vendidos como

aadidos al JDK 1.1, en lugar de slo formar parte del JDK 1.2. Incluso el

ms sencillo de los componentes Swing tiene capacidades que van ms all

de lo

que ofrecen los componentes AWT.

Por ejemplo:

Los botones y las etiquetas Swing pueden mostrar imgenes en

lugar de o adems deltexto.

9
 Se pueden aadir o modificar fcilmente los bordes dibujados

alrededor de casicualquier componente Swing. Por ejemplo, es fcil

poner una caja alrededor de uncontenedor o una etiqueta.

Se puede modificar fcilmente el comportamiento o la apariencia de

un componente

Swing llamando a mtodos.

Los componentes Swing no tienen porque ser rectangulares. Por ejemplo,

los botonespueden ser redondos.

Bordes complejos: Los componentes pueden presentar nuevos tipos de

bordes. Ademsel usuario puede crear tipos de bordes personalizados.

Otro mejora importante es que ahora todos los componentes pueden

presentar una pequealeyenda de texto con una breve explicacin, que es

conocida como tooltip.

1.4 Descripcin de algunos componentes Swing

Se da una descripcin breve de cada componente por la diversidad de

mtodos que contienen.

Jframe: se trata de la implementacin de la clase Frame aadiendo nuevas

funcionalidades y una nueva filosofa, ya que ahora un Frame contiene

varios tipos de paneles.

Jpanel: es el nuevo contenedor bsico de componentes grficos.

JscrollPane: esta nueva implementacin de un panel con barra de

desplazamiento no se limita slo a proporcionar barras de desplazamiento

en caso de que los componentes que contengan no entren en l rea de

10
visualizacin, sino que tambin se encarga de proporcionar barras de

desplazamiento a todo el resto de componentes grficos existente.

Japplet: Se trata de la reimplementacin de la clase applet para que sta

pueda aprovechar todas las nuevas caractersticas existentes.

Jbutton: botn que adems de texto puede contener imgenes en cualquier

posicin en relacin con el texto.

JtoggleButton: se trata de una clase que no tiene equivalentes en AWT.

Representa un botn que se mantiene presionado aunque dejemos de

presionar connuestro ratn sobre l, pero visualmente no se difiere de un

Jbutton cuando no est activado.

Jlabel: etiqueta de texto que puede contener imgenes en cualquier

posicin en relacin con el texto.

JtextField: Componente que sirve para conseguir la entrada de texto por

parte del usuario.

JtextPane: se trata tambin de un panel para visualizar texto, con la

salvedad de quetiene la capacidad de mutar en relacin al tipo de texto que

se desee mostrar para poder visualizarlo correctamente.

Jlist: presenta una lista de elementos de entre los que se puede elegir uno o

varios simultneamente.

JdesktopPane: se trata de un panel base para el desarrollo de aplicaciones

MDI.

JinternalFrame: este panel no es una ventana en s, sino que simula una

ventanainterior a un JdesktopPane. Como ventana interior puede ser

movida, cerrada, organizada.

Jtable: este componente presenta una rejilla en la que se puede colocar

cualquiercomponente Swing.

11
JcheckBox: es similar al componente checkbox que encontramos en

cualquierlenguaje y que permite mostrar al usuario si la opcin est

seleccionada o no.

JpasswordField: se encuentra justo por debajo de Jtextfield en la jerarqua

decomponentes, y permite la edicin de texto sin realizar un eco de los

caracterestecleados en pantalla, que son sustituidos por un carcter .

JtextArea: hereda de JtextComponent, con la diferencia es que un rea de

texto permite la edicin de mltiples lneas. Hay que tener en cuenta que si

queremos tener la capacidad de desplazarnos a lo largo de un texto que no

cabe en el componente tendremos que colocar el JtextArea en un

JscrollPane.

JprogressBar: las barras de progreso permiten ver de forma grfica la

evolucin deuna tarea. Normalmente el avance se mide en porcentaje y la

barra se acompaa de la visualizacin en texto del valor de dicho porcentaje.

Java incorpora otra posibilidad para esta tarea: un monitor de progreso, que

permite ver el avance de un proceso de forma ms sencilla que las barras.

Adems al ser mostradas en un cuadro de dialogo, el usuario puede

cerrarlas en cualquier momento e incluso llegar a cancelar el proceso.

JcomboBox: es similar al Choice de AWT. Dispone de una lista desplegable

deposibles valores, pero si no encontramos entre ellos el valor que

buscamos, podemosteclearlo(si hemos habilitado la opcin con

setEditable(true)). Este control deSwing presenta una facilidad aadida:

cuando pulsamos la inicial de la opcin que buscamos, nos lleva

directamente al primer trmino de la lista que empiece por dicha letra.

12
 CAPTULO II

2.1. Layouts

Swing incorpora nuevos gestores de impresin, ampliando los cinco que

AWT incorporaba.

Entre ellos conviene destacar los siguientes:

BoxLayout: Es similar al FlowLayout de AWT, con la diferencia de

que con l se pueden especificar los ejes (x o y). Viene

incorporada en el componente Box, pero est disponible como

una opcin en otros componentes.

OverlayLayout: Todos los componentes se aaden encima de

cada componenteprevio.

SpringLayout: El espacio se asigna en funcin de una serie de

restriccionesasociadas con cada componente.

ScrollPaneLayout.

ViewportLayout.

2.2. Look &Feel

Otra caracterstica que introduce Swing es que se puede especificar el

Aspecto y Comportamiento (Look &Feel o L&F) que utilice el GUI de nuestro

programa. Por el contrario, los componentes AWT siempre tienen el aspecto

y comportamiento de la plataforma nativa. Desde el cdigo de la aplicacin o

applet Swing se puede exportar un Look &Feel diferente al nativo de la

plataforma con el mtodo [Link].

En las siguientes figuras podremos observar tres de los L&F de Swing en la

misma aplicacin.

13
14
2.3. Nuevas caractersticas

2.3.1 Action Con objetos Action, el API Swing proporciona un soporte

especial para compartir datos y estados entre dos o ms componentes que

pueden generar eventos Action. Por ejemplo, si tenemos un botn y un tem

de men que realizan la misma funcin, podramos considerar la

Utilizacin de un objeto Action para coordinar el texto, el icono y el estado de

activado de los dos componentes.

2.4. Modelos de datos y estados separados

La mayora de los componentes Swing no-contenedores tienen modelos. Por

ejemplo, un botn (JButton) tiene un modelo (ButtonModel) que almacena el

estado del botn - cul es su mnemnico de teclado, si est activado,

seleccionado o pulsado, etc. Algunos componentes tienen mltiples

modelos. Por ejemplo, una lista (JList) usa un ListModel que almacenalos

contenidos de la lista y un ListSelectionModel que sigue la pista de la

seleccinactual de la lista.

Normalmente no se necesita conocer los modelos que usa un componente.

Por ejemplo,casi todos los programas que usan botones tratan directamente

con el objeto JButton, y no lo hacen en absoluto con el objeto ButtonModel.

Entonces Por qu existen modelos separados? Porque ofrecen la

posibilidad de trabajar con componentes ms eficientemente y para

compartir fcilmente datos y estados entre componentes. Un caso comn es

cuando un componente, como una lista o una tabla, contiene muchos datos.

Puede ser mucho ms rpido manejar los datos trabajando directamente con

un modelo de datos que tener que esperar a cada peticin de datos al

15
modelo. Se puede usar el modelo por defecto del componente o implementar

uno propio.

Las clases Model son una importante innovacin que facilita la programacin

siguiendo la arquitectura MVC (modelo-vista-controlador) ya que separa para

cada componente una clase de modelo de datos y otra de interfaz, aunque

con la funcionalidad de la interfaz se podra controlar todo totalmente sin

ayuda del modelo de datos de ese componente.

2.5. Soporte para tecnologas asistivas

Las tecnologas asistivas para minusvlidos como los lectores de pantallas

pueden usar el API de accesibilidad para obtener informacin sobre los

componentes Swing. Incluso sin hacer nada, un programa Swing

probablemente funcionar correctamente con tecnologas asistivas, ya que

el API de accesibilidad est construido internamente en los componentes

Swing. Sin embargo, con un pequeo esfuerzo extra, se puede hacer que

nuestro programa funcione todava mejor con tecnologas asistivas, lo que

podra expandir el mercado de nuestro programa.

2.6. Applets

Los applets son pequeos programas Java que se incluyen en pginas Web

y cuyo cdigo se descarga desde el sevidor para ser ejecutado localmente

por un navegador. Por tanto, para trabajar con applets es necesario conocer

algunas de las caractersticas de las pginas Web y del lenguaje en que

stas estn escritas, y el captulo comienza exponiendo conocimientos

bsicos sobre HTML. Tambin se explicar la estructura fundamental de un

applet. Teniendo en cuenta que las applets trabajan con IGU y estn guiadas

16
por eventos, el captulo se apoya en los conocimientos aportados por otros

anteriores para la creacin de los primeros applets.

Estructura De Un Applet

La clase Applet extiende la clase Panel del AWT y Panel extiende Container

que, a su vez, extiende Component, proporcionndose as a las

upplets todas las herramientas necesarias en la programacin IGU (Znterfuz

Grfica de Usuario) y, al igual que todos los programas que trabajan con

IGU, las upplets estn guiadas por eventos.

Las upplets disponen de cinco mtodos que pueden sobre escribir, aunque

no es obligatorio que lo hagan, pues tienen implementaciones por defecto

que se invocarn automticamente durante la ejecucin de la misma. Cuatro

de estos mtodos son proporcionados por la clase App 1 et :

publicvoidinit ( ) Inicializa el applet y es invocado por elAppletviexlev o el

navegador cuando se carga el [Link] ( ) Se ejecuta a

continuacin de init y tambin cada vez que el usuario del navegador

regresa a lapgina HTML donde reside el upplet y debe contenerlas tareas

que deban llevarse a cabo en estas [Link] stop() Se ejecuta

cuando el usuario abandona la pginaHTML en la que reside el

[Link] ( ) Libera todos los recursos que el applet est

utilizandoy se ejecuta antes de que el applet se descargue cuando el usuario

sale de la sesin de navegacin.

17
2.6.1. Applets en Swing

La clase JApplet es el equivalente de Swing de la clase Applet. JApllet se

parece aJFrame en que admite un panel de contenido separado. A este

contenedor se accede a travsdel mtodo getContentPane(). La barra de

mens debe ser un objeto de la claseJMenuBar.

18
 CAPITULO III

3.1. Herencia de Componentes y Contenedores

Esta seccin presenta algunos de los componentes ms utilizados de Swing

y explica como los componentes de un GUI entran juntos en un contenedor.

Para ilustrarlo, usaremos el programa SwingApplication presentado en Una

Ruta Rpida por el Cdigo de una Aplicacin Swing. Y aqu est su aspecto

de nuevo.

SwingApplication crea cuatro componentes Swing muy utilizados.

un frame, o ventana principal (JFrame)

un panel, algunas veces llamado pane (JPanel)

un botn (JButton)

una etiqueta (JLabel)

El frame es un contenedor de alto nivel. Existe principalmente para

proporcionar espacio para que se dibujen otros componentes [Link]

otros contenedores de alto nivel ms utilizados son los dilogos (JDialog) y

los applets (JApplet).

El panel es un contenedor intermedio. Su nico propsito es simplificar el

posicionamiento del botn y la etiqueta.

Otros contenedores intermedios, como los paneles desplazables,

(JScrollPane) y los paneles con pestaas (JTabbedPane), tpicamente

juegan un papelms visible e interactivo en el GUI de un programa.

19
El botn y la etiqueta son componentes atmicos -- componentes que

existen no para contener otros componentes Swing, sino como entidades

auto-suficientes que representan bits de informacin para el usuario.

Frecuentemente, los componentes atmicos tambin obtienen entrada del

usuario. El API Swing proporciona muchos componentes atmicos,

incluyendo combo boxes (JComboBox),campos de texto (JTextField), y

tablas (JTable).

Aqu podemos ver un diagrama con el rbol de contenidos de la ventana

mostrada por Swing Application.

Este diagrama muestra todos los contenedores creados o usados por el

programa, junto con los componentes que contienen. Observa que si

aadimos una ventana - por ejemplo, un dilogo - la nueva ventana tendra

su propio rbol de contenidos, independiente del mostrado en esta figura

Como muestra la figura, incluso el programa Swing ms sencillo tiene

mltiples niveles en su rbol de contenidos. La raz del rbol de contenidos

es siempre un contenedor de alto nivel. Este contenedor proporciona

espacio para que sus componentes Swing descendentes se dibujen a s

mismo.

20
todo contenedor de alto nivel contiene indirectamente un contenedor

intermedio conocido como panel de contenido. Para la mayora de los

programas no necesitas saber qu pasa entre el contenedor de alto nivel y

su panel de contenido. (Si realmente quieres verlo, puedes ver Cmo usar

Paneles Raz.)Cmo regla general, el panel de contenido contiene,

directamente o indirectamente, todos los componentes visibles en el GUI de

la ventana. La gran excepcin a esta regla es que si el contenedor de alto

nivel tiene una barra de men, entonces sta se sita en un lugar especial

fuera del panel de contenido.

Para aadir componentes a un contenedor, se usa una de las distintas

formas del mtodo add. Este mtodo tiene al menos una rgumento -- el

componente a aadir. Algunas veces se requiere un argumento adicional

para proporcionan informacin de distribucin.

Por ejemplo, la ltima lnea del siguiente cdigo de ejemplo especifica que el

panel debera estar en el centro de su contenedor (el panel de contenido).

3.2. Control de Distribucin

Las siguientes figuras muestran los GUIs de cinco programas, cada uno de

ellos muestra cinco botones. Los botones son idnticos, y el cdigo de los

programas es casi idntico. Entonces por qu parecen tan diferentes?

Porque usan diferentes controladores de distribucin para controlar el

tamao y posicin de los botones.

21
Control de Distribucin es el proceso de determinar el tamao y posicin de

los componentes. Por defecto, cada contenedor tiene un controlador de

distribucin -- un objeto que realiza el control de la distribucin de los

componentes dentro del contenedor. Los componentes pueden

proporcionarle al controlador de disposicin sus preferencias en cuanto a

tamao y alineamiento, pero la ltima palabra la tiene el controlador de

disposicin.

La plataforma Java suministra cinco controladores de disposicin

comunmente utilizados: BorderLayout, BoxLayout,

FlowLayout,GridBagLayout, y GridLayout. Estos controladores de

distribucin estn diseados para mostrar mltiples componentes a la vez, y

se han visto en la figura anterior. Una sexta clase proporcionada,

CardLayout, es un controlador de disposicin de propsito general usadoen

combinacin con otros controladores de distribucin. Puedes encontrar

detalles sobre cada uno de estos seis controladores, incluyendo claves para

elegir el apropiado, en Usar Controladores de Distribucin. Siempre que se

use el mtodo add para poner un componente en un contenedor, debemos

tener en cuenta el controlador de distribucin del contenedor. Algunos

22
controladores como BorderLayout requiere que especifiquemos la posicin

relativa del componente en el contenedor, usando un argumento extra para

el mtodo add. Ocasionalmente, un controlador de distribucin

comoGridBagLayout requiere elaborados procesos de configuracin. Sin

embargo, muchos controladores de distribucin simplemente sitan los

componentes en el orden en que fueron aadidos a su contenedor.

Todos esto probablemente suena ms complicado de lo que es. Si quieres

puedes copiar el cdigo de nuestros ejemplos de Usar Componentes Swing

o buscar el controlador de distribucin individual en Usar Controladores de

Distribucin. Generalmente, slo tendrs que seleccionar el controlador de

distribucin de dos tipos de contenedores: paneles de contenido (que usan

BorderLayout por defecto) y JPanel (que usan FlowLayout por defecto).

Esta seccin describe algunas de las tareas ms comunes de la distribucin.

3.2.1. Seleccionar el Controlador de Distribucin

Podemos cambiar fcilmente el controlador de distribucin que usa un

contenedor. Slo se debe llamar al mtodo setLayout del contenedor. Por

ejemplo, aqu est el cdigo que hace que un panel use BorderLayout.

JPanel pane = new JPanel();

[Link](new BorderLayout());

Aunque recomendamos que uses controladores de distribucin, se puede

realizar la distribucin sin ellos. Seleccionando una propiedad de distribucin

del contenedor a nulo, podemos hacer que el contenedor no use ningn

controlador de distribucin. Con este esquema, llamado posicionamiento

absoluto, podemos especificar el tamao y posicin de cada componente

dentro del contenedor. Una desventaja del posicionamiento absoluto es que

23
no se ajusta bien cuando se redimensiona el contenedor de alto nivel.

Tampoco se ajusta bien a las diferencias entres usuarios y sistemas, como

los diferentes tamaos de fuente.

3.2.2. Proporcionar Consejos sobre un Componente

Algunas veces necesitamos personalizar el tamao que un componente

proporciona al controlador de distribucin del contenedor, para que el

componente se vea bien. Se puede hacer esto proporcionando los tamaos

mnimo, preferido y mximo del componente.

Tambin podemos llamar a los mtodos de seleccin de tamao del

componente -- setMinimumSize, setPreferredSize, y setMaximumSize - o

podemos crear una subclase del componente que sobreescriba los mtodos

apropiados -- getMinimumSize, getPreferredSize, y getMaximumSize.

Actualmente, el nico controlador de distribucin en la plataforma Java que

presta atencin a la peticin de tamao mximo del componente es

BoxLayout.

Adems de proporcionar preferencias de tamao, podemos especificar

preferencias de alineamiento. Por ejemplo, podemos especificar que los

bordes superiores de dos componentes deberan estar alineados. Se

seleccionan los consejos de alineamiento llamando a los mtodos

setAlignmentX y setAlignmentY del componente, o sobreescribiendo los

mtodos, getAlignmentX y getAlignmentY del componente. Realmente

BoxLayout es el nico controlador de distribucin que presta atencin a los

consejos de alineamiento.

24
3.2.3 Poner Espacio entre Componentes

Tres factores influyen en la cantidad de espacio entre los componentes

visibles de un contenedor.

[Link]. El controlador de distribucin.

Algunos controladores de distribucin ponen automticamente espacio entre

los componentes; otros no. Algunos permiten incluso especificar la cantidad

de espacio entre los componentes. Puedes ver Distribuir Componentes

dentro de un contenedor sobre el soporte de espaciado de cada controlador

de distribucin.

[Link]. Componentes invisibles.

Se pueden crear componentes de peso ligero que no realicen dibujo, pero

que ocupen espacio en el GUI. Frecuentemente se usan los componentes

invisibles en contenedores controlados por BoxLayout. Puedes ver Cmo

usar BoxLayout paraver ejemplos de uso de componentes invisibles.

[Link]. Bordes vacos

No importa cul sea el controlador de distribucin, podemos afectar la

aparente cantidad de espacio entre componentes aadindoles bordes. Los

mejores candidatos para los bordes vacos son los que tpicamente no tienen

bordes, como los paneles y las etiquetas. Algunos otros componentes, como

paneles desplazables, no funcionan bien con bordes en algunas

implementaciones del Aspecto y Comportamiento, debido a la forma en que

implementan su cdigo de dibujo. Para ms informacin sobre los bordes

puedes ver Cmo usar Bordes.

25
3.2.4. Cmo Ocurre el Control de Distribucin

Aqu hay un ejemplo de secuencia de control de distribucin para un frame

(JFrame).

1.- Despus de que el GUI est construido, se llama al mtodo pack

sobre el JFrame. Esto especifica que el frame debera serde su

tamao preferido.

2.- Para encontrar el tamao preferido del frame, el controlador de

distribucin aade el tamao de los lados del frame al tamao

preferido del componente directamente contenido por el frame. Esto

es la suma del tamao preferido del panel decontenido, ms el

tamao de la barra de men del frame, si existe.

3.- El controlador de disposicin del panel de contenido es responsable

de imaginarse el tamao preferido del panel de contenido. Por

defecto, este controlador de disposicin es un objeto BorderLayout.

Sin embargo, asumamos que lo hemos reemplazado con un objeto

GridLayout que se ha configurado para crear dos columnas. Lo

interesante de gridlayout es que fuerza a que todos los componentes

sean del mismo tamao, e intenta hacerlos tan anchos como la

anchura preferida del componente ms ancho, y tan altos como la

altura preferida del componente ms alto. Primero, el controlador

gridlayout pregunta el panel de contenido por su inserts - el tamao

del borde del panel de contenido, si existe. Luego, el controlador de

gridlayout le pregunta a cada componente del panel de contenido

sus tamaos preferidos, anotando la mayor anchura preferida y la

mayor altura preferida. Luego calcula el tamao preferido del panel

de contenido.

26
 4.- Cuando a cada botn se le pide su tamao preferido, el botn

primero comprueba si el usuario ha especificado un tamao

preferido. Si es as, reporta este tamao. Si no es as, le pregunta a

su Aspecto y Comportamiento el tamao preferido.

3.3. Construccin de GUI en Swing

La construccin de una GUI en Swing es muy similar a la construccin de

GUI en el AWT, exceptuando que la primera tendr muchas ms clases de

componentes con las que trabajar. A continuacin se describen las clases

que se usan para la construccin de GUI y se sealan las mejoras que

Swing proporciona, comparando stas clases con las de AWT.

3.3.1 Ventanas

Swing, al igual que AWT, proporciona una jerarqua de clases Window. Las

clases de laventana de Swing constituyen extensiones de la jerarqua de

clases Window del AWT. Laclase JWindow ampla la clase Window. La clase

JFrame ampla la clase JFrame delAWT y la clase JDialog ampla la clase

Dialog del [Link] clases JWindow, JFrame y JDialog difieren de sus

homlogos del AWT enque utilizan un panel de contenido separado para

agregar y disear componentes GUI. Este panel es un objeto Container al

que se accede a travs del mtodogetContentPane(). El panel de contenido

es una parte de un objeto JRootPane quecontiene otros paneles que se

usan para sobreponerse a componentes e interceptar eventos del ratn y del

teclado.

27
3.3.2. Mens

Los mens de Swing, al igual que las ventanas de Swing, son anlogos a

sus homlogos delAWT. Las clases JMenuBar, JMenu, JMenuItem,

JCheckBoxMenuItem yJRadioButtonMenuItem se utilizan de la misma forma

que las clases MenuBar,Menu, MenuItem y CheckboxMenuItem del AWT,

slo que con una diferenciafundamental. Las clases de mens de Swing son

todas ellas subclases de la claseJComponent y, por tanto, de la clase

Component. Esto implica que los mens de Swing, al contrario que sus

homlogos del AWT, constituyen componentes de primera clase y se

pueden usar con cualquiera de las clases Container. La clase JPopupMenu

es equivalente a la clase PopupMenu del AWT. Otra atractiva caracterstica

de los mens de Swing es la posibilidad de utilizar imgenes de iconos en

los mens. Se puede aadir una imagen a un elemento de men por medio

de su constructor.

3.3.3. Paneles

La clase JPanel es el equivalente de Swing a la clase Panel del AWT. Esta

clase, al igual que sucede en otras clases de JComponent, ofrece la

posibilidad de agregar un borde.

3.3.4. Diseos

Los contenedores de Swing admiten todos los diseos posibles del AWT,

entre los que seincluye el diseo null, adems de admitir otros diseos

nuevos.

28
3.3.5. Iconos

Una de las caractersticas ms tiles que Swing ofrece es la posibilidad de

agregar iconos a los componentes, como etiquetas, botones, elementos de

men, etc. La interfaz Icon define los mtodos que las clases de iconos

deben implementar. La clase ImageIcon proporciona una implementacin

predeterminada de esta interfaz. Los objetos ImageIcon

se pueden construir a partir de archivos de imagen, URL que apuntan a

archivos de imagenu objetos Image del AWT.

3.3.6. Bordes

El paquete [Link] proporciona la interfaz Border, la cual

define los mtodos que necesitan ser implementados por todas las clases de

bordes. La claseAbstractBorder implementa la interfaz Border y es la

superclase de las clases debordes de Swing.

3.3.7. Informacin sobre herramientas

La clase JToolTip ofrece la posibilidad de agregar cuadros de texto

emergentes queaparecen cuando se posa el ratn sobre un componente.

Estos componentes, que admiteninformacin sobre herramientas, permiten

que stas vengan especificadas en sus respectivosconstructores. El mtodo

setToolTipText() de la clase JComponent se puede usartambin para

especificar la informacin sobre herramientas de un componente.

3.3.8. Barras de herramientas

La clase JToolBar ofrece la posibilidad de utilizar barras de herramientas

movibles y acoplables con Swing. Los objetos de esta clase son

29
contenedores de otros componentesSwing o del AWT. Los objetos JToolBar

tpicos contienen objetos JButton que se construyen por medio de iconos de

imagen.

3.3.9. Etiquetas y botones

Las clases JLabel y JButton proporcionan los equivalentes de Swing a las

clasesLabel y Button del AWT. La implementacin de Swing ofrece la

ventaja de poder usariconos a la vez que texto. Los constructores JLabel() y

JButton() permiten que se especifique un icono. Adems, ambas clases

admiten el mtodo setIcon() para establecer un icono una vez que se ha

construido el objeto.

3.3.10. Componentes de texto

Las clases JTextComponent, JTextField y JTextArea son los equivalentes

deSwing de las clases TextCompoenent, TextField y TextArea del AWT.

Adems,Swing proporciona la clase TextPane para trabajar con documentos

de texto, que se pueden marcar con estilos de texto diferentes.

3.3.11. Listas y cuadros combinados

Las clases JComboBox y JList ofrecen la posibilidad de presentarle al

usuario una listade selecciones grficas de texto. La clase JComboBox

implementa una lista desplegable,parecida a una lista de opciones Motif. La

clase JList es una lista de selecciones individuales o mltiples en las que se

pueden ver muchos elementos.

30
3.3.12. Deslizadores y barras de progreso

Las clases JSlider y JProgressBar carecen de equivalentes en el AWT.

Ambasclases admiten orientaciones horizontales y verticales. La clase

JProgressBar se utiliza tpicamente para mostrar el progreso de una tarea,

como la carga de una imagen. La claseJSlider se usa para ajustar o

controlar el valor de una variable dentro del intervalo admisible.

3.3.13. Barras de desplazamiento

El JScrollPane simplifica en gran medida el uso de las barras de

desplazamiento. El mtodo getViewport() devuelve un objeto JViewport en el

que se pueden ir aadiendo componentes. En la mayora de los casos, slo

necesita agregar componentes al objeto JViewport para que uno se pueda

desplazar automticamente por ellos.

3.3.14. Tablas

La clase JTable es otro componente de Swing que carece de equivalente en

[Link] ofrece una posibilidad muy flexible para crear y mostrar tablas.

Permite construir tablas a partir de arrays o vectores de objetos, o bien a

partir de objetos que implementan lainterfaz [Link] interfaz

JTableModel define mtodos para los objetos que especifican el

contenido de una tabla. La clase AbstractTableModel ofrece una

implementacinpredeterminada de la interfaz JTableModel. Esta clase se

ampla tpicamente para proporcionar una implementacin personalizada de

modelo de tabla. La clase JTable ofrece la posibilidad de editar tablas. El

mtodosetCellEditor() permite que un objeto de la interfaz TableCellEditor se

ha identificado como el editor de celdas de una tabla.

31
3.3.15. rboles

Una de las clases nuevas ms interesantes que ofrece Swing es la clase

JTree. Esta clase implementa una estructura en forma de rbol que se

puede usar para mostrar datos jerrquicos. La interfaz TreeNode define

mtodos que tienen que implementar los nodos de un objeto JTree. La clase

DefaulMutableTreeNode proporciona una implementacin predeterminada

de la interfaz TreeNode. Los rboles se crean construyendo objetos de la

interfaz TreeNode para luego aadirlos todos juntos (a travs del mtodo

add()). Cuando todos los objetos TreeNode se hayan juntado, el

objetoTreeNode resultante se pasa al constructor [Link] presentacin

predeterminada de un objeto JTree utiliza un icono de carpeta con el fin de

identificar los nodos de rbol que tienen nodos inferiores y un icono de

archivo para identificar las ramificaciones del rbol. El mtodo

setCellRenderer() de la claseJTree se usa para identificar una prestacin de

rbol alternativa.

3.4. Manejo de eventos en Swing

Cada vez que el usuario teclea un carcter o pulsa un botn del ratn, ocurre

un evento. Cualquier componente puede ser notificado del evento. Todo lo

que tiene que hacer es implementar el interface apropiado y ser registrado

como un oyente de evento del evento fuente apropiado. Los componentes

Swing pueden generar muchas clases de evento. El paquete

[Link] define una serie de interfaces auditoras de eventos y

clases de eventos que se usan con los componentes Swing. Adems,

muchos de los componentes Swing tambin utilizan eventos del AWT.

En la figura se muestra ejemplos de eventos:

32
Cada evento est representado por un objeto que ofrece informacin sobre

el evento e identifica la fuente. Las fuentes de los eventos normalmente son

componentes, pero otros tipos de objetos tambin pueden ser fuente de

eventos. Como muestra la siguiente figura, cada fuente de evento puede

tener varios oyentes registrados. Inversamente, un slo oyente puede

registrarse con varias fuentes de eventos.

Figura relacin evento - oyente

3.5. Swing: Cuadros de texto. Botones y casillas de activacin

Este literal se analiza las etiquetas, botones, cuadros de texto, botones

toggle, casillas de activacin y botones de opcin en Swing. Todos ellos son

controles esenciales que ocupan gran parte de los fundamentos de Swing. A

excepcin de los botones toggle, todos estos controles le deberan resultar

familiares de la programacin AWT. Gran parte de la funcionalidad de estos

33
controles Swing tiene su correspondencia en la de AWT, y aqu resaltaremos

lo que es diferente. (Hay que tener en cuenta que todos los controles Swing

aparecen de diferentes formas segn las diversas apariencias; es importante

recordar esto cuando se empiece a programar con ellos).

3.5. 1. Etiquetas y cuadros de texto

Las etiquetas son controles bsicos Swing que slo visualizan una lnea de

texto. Sera razonable pensar que las etiquetas soportan varias lneas de

texto en Swing, pero slo soportan una. Por otro lado, soportan algo que no

tienen las etiquetas AWT: imgenes. Veremos cmo utilizar la

claselmagelcon para aadir imgenes a las etiquetas. La gestin del texto en

los componentes Swing es uno de los apartados que veremos ms tarde en

este libro. Ahora, iniciaremos este tema con los cuadros de texto, viendo

cmo funcionan en este captulo y ms adelante.

3.5. 2. Botones

En Swing, cualquier botn se construye con la clase AbstractButton, y en

este captulo veremos esta clase. Como se poda esperar, los botones Swing

tienen ms capacidad que sus correspondientes en AWT, incluyendo la

capacidad de visualizar imgenes, usar mnemnicos (combinacin de

teclas), disear un botn como botn por defecto de una ventana y fijar los

mrgenes y alineacin del texto de un botn. Adems, a un botn se le

pueden asignar mltiples imgenes para gestionar el caso en que el ratn se

mueva sobre el botn, y ms cosas. Lo veremos a continuacin. Botones

toggle Swing introduce los botones toggle, que son botones que, cuando se

hace clic sobre ellos, permanecen pulsados hasta que volvemos a hacer clic.

34
Los botones toggle son como las casillas de activacin y botones de opcin

que parecen botones estndar; de hecho, la clase JToggleButton, es la clase

base para las clases de estos controles en Swing, y adems se pueden

instanciar objetos de esta clase directamente. Al igual que ocurre con las

casillas de activacin y botones de opcin, se pueden agrupar botones

toggle y usar imgenes en ellos.

3.5.3. Casillas de activacin y botones de opcin

AWT tiene casillas de activacin y botones de opcin, pero los gestiona de

diferente forma que Swing. En Swing, los botones de opcin tienen su propia

clase (los botones de opcin, son casillas de activacin en AWT), y con ellos

se pueden usar imgenes. De hecho, veremos que cuando se utilizan las

imgenes con las casillas de activacin y los botones de opcin, hay algunos

asuntos que considerar.

3.5.4. Usar etiquetas

La clase de las etiquetas peso pesado en Swing es JLabel. Este es el

diagrama de herencia de esta clase:

java. [Link]
[Link]
1 j a v a .a w t . C o n t a i n e r
[Link]
I j a v a x .s w i n g . J L a b e l

Los constructores de la clase JLabel se encuentran en la tabla 1.1 y sus

mtodos en la tabla 1.2.

35
 Constructor Descripcin
Construye un objeto JLabel
Jlable
sin imagen.
Construye un objeto JLabelcon la
JLabel(1con imagen)
imagen indicada.
Construye un objeto JLabelcon la
JLabel(lconimagen, int alineacin
imagen y la alineacinhorizontal
horizontal)
especificadas.
Construye un objeto JLabelcon el
JLabel(String texto)
texto indicado.
Construye un objeto JLabel con el
JLabel(String texto, /con icono, int
texto imagen y alineacin horizontal
alineacin-horizontal)
indicados.
JLabel(Stringtext0, Construye un objeto JLabel con el
intalineacinhorizontal) texto y alineacin horizontal
indicado.

Tabla 1.2

3.6. Swing: viewports. Desplazamiento. Deslizadores y listas

En esta seccin se indica algunos temas importantes de la Swing:

Viewport, paneles de desplazamiento, deslizadores, barras de

desplazamiento y cuadros de lista. Los controles de este captulo tienen

todos una cosa en comn: el desplazamiento. El de lista, en concreto, es un

control muy importante en la Swing, pero no procesa el desplazamiento por

s mismo, por lo que necesitamos comprender cmo funciona con

desplazamiento antes de trabajar con vistas y muchos otros controles de la

Swing.

36
3.6.1. Viewports

La clase JViewport es el corazn del desplazamiento en la Swing. Un

viewport es una ventana dentro de una vista, que visualizar una seccin de

nuestros datos. Podremos desplazar manualmente los Viewports. Utilizando

Viewports, podemos desplazarnos por los datos visualizados, de forma

similar a aquella en que realizamos nosotros mismos el desplazamiento.

Examinaremos el uso de la clase JViewport para desplazar imgenes.

3.6.2. Paneles de desplazamiento

Una forma comn de implementar el desplazamiento en la Swing es utilizar

paneles de desplazamiento, puesto que permiten desplazar componentes.

Varios controles de la Swing, como el control JList, implementan la

interfazScrollable para trabajar con paneles de desplazamiento. De hecho,

stos seutilizan habitualmente con controles JList para crear listas

desplazables.

3.6.3. Deslizadores

Otro control desplazable es el control deslizador de la Swing, soportado por

la clase JSlider. Los deslizadores son similares a los controles que vemos en

los dispositivos de audio que permiten deslizar un mando a lo largo de una

pista. De hecho, los deslizadores son como barras de desplazamiento,

excepto porque explcitamente utilizamos deslizadores para permitir al

usuario seleccionar un valor dentro de un rango continuo.

Puede hacer lo mismo, por supuesto, con barras de desplazamiento, pero

37
los deslizadores se introducen aqu debido a que los usuarios actualmente

esperan que las barras de desplazamiento se utilicen para desplazar otros

controles, como las reas de texto.

3.6.4. Barras de desplazamiento

Cada usuario de una UI conoce las barras de desplazamiento, por supuesto,

y la Swing las soporta al igual que haca el AWT. Utilizaremos la

claseJScrollBar en esta seccin desplazando texto en un applet. Cuando el

cuadro de desplazamiento (tambin llamado burbuja o marcador) se mueva,

el valor de la barra de desplazamiento cambiar. Puede hacer clic sobre los

botones de flecha en los extremos de la barra de desplazamiento para

cambiar el valor de la barra de desplazamiento en el incremento de bloque, y

tambin puede hacer clic sobre la pista de la barra de desplazamiento para

cambiar su valor en su incremento unitario.

3.6.5. Listas

Las listas, soportadas por la clase JList en la Swing, son unos controles muy

populares, debido a que permiten presentar una lista de elementos sencilla

de manejar, ocultando una larga lista de elementos al hacer que el cuadro de

lista sea desplazable. Mostraremos cmo desplazar largas listas y veremos

diversos temas de la Swing. Por ejemplo, puede realizar selecciones

mltiples de diversas formas en los cuadros de lista de la Swing. Tambin

puede visualizar imgenes, manejar eventos de clics de ratn dobles y

triples e incluso an ms.

38
3.7. Swing: barras. Herramientas. Cuadros. Separadores y selectores

3.7.1. Cuadros combinados

Los cuadros combinados son uno de los controles ms importantes en la

programacin de la UI, pero el AWT no tiene un cuadro combinado. La

Swing rectifica esto. Los cuadros combinados con combinaciones de

campos de texto y listas desplazables. Son muy tiles, ya que permiten al

usuario tanto seleccionar un elemento de la lista como introducir su propio

valor en el campo de texto. Los cuadros combinados tambin son controles

muy compactos, debido a que muestran nicamente un elemento y un botn

que el usuario puede utilizar para desplegar la lista de otros elementos. Los

cuadros combinados pueden funcionar como listas desplegables,

proporcionando al usuario un mecanismo incluso an ms compacto para

visualizar los elementos de una lista que el que proporciona un cuadro de

lista, y han pasado a ser muy populares por esa razn. De hecho, la Swing

tiene como valor predeterminado del cuadro combinado que muestre

nicamente una lista desplegable, ya que el valor predeterminado para los

cuadros combinados sera hacerlos no editables, lo que los convierte en

listas desplegables.

3.7.2. Barras de progreso

Las barras de progresos son controles relativamente nuevos, que se han

hecho populares como mecanismo para proporcionar al usuario la indicacin

del progreso de una operacin larga. Las barras de progreso, originalmente

introducidas como mecanismo para mostrar el progreso de un programa de

instalacin, se utilizan ahora para todo tipo de operaciones de consumo de

39
tiempo, como descargas de archivos desde la red Internet. Las barras de

progreso muestran una barra coloreada dentro de ellas que crece (o se

reduce), de forma similar a como lo hace el mercurio en un termmetro, para

mostrar visualmente cmo progresa una operacin. Puede orientar las

barras de progreso tanto horizontal como verticalmente, seleccionar los

colores y etiquetas que use en ellas y manejar sus eventos. Y an ms, las

barras de progreso siguen siendo controles sencillos, ya que tienen

nicamente una funcin: mostrar el progreso de una tarea.

3.7.3. Selectores

Como en la AWT, la Swing soporta cuadros de dilogo. Al contrario que la

AWT, la Swing tambin soporta adicionalmente varios cuadros de dilogo

que no tenemos que crear o personalizar nosotros mismos: selectores de

archivos y selectores de color. Los selectores de archivos permiten al

usuario seleccionar un archivo para abrir o guardar algo, muy similar a

cualquier cuadro de dilogo de archivos estndar. Los selectores de color

permiten al usuario seleccionar un color entre muchos. Ambos selectores

representan cuadros de dilogo estndar y Sun nicamente nos ahorra

tiempo al crearlos. Trabajaremos con ambos selectores en este captulo.

Podemos utilizar inmediatamente en los programas el selector de color, pero

para utilizar los archivos que devuelve el selector de archivos, tendremos

40
3.7.4. Herramientas de ayuda

Las herramientas de ayuda son esas ventanas pequeas que aparecen y

muestran un texto de explicacin (como por ejemplo Descargar ahora o Abrir

nueva carpeta) cuando se detiene el ratn sobre un control. Las

herramientas de ayuda pueden ser muy tiles debido a que los usuarios de

la UI tienen una gran resistencia a leer los manuales. Lo nico que tiene que

hacer el usuario es dejar el ratn sobre su programa para ver qu es lo que

hacen los distintos controles. Por otro lado, tenga en cuenta que muchas

herramientas de ayuda (conectadas con muchos elementos de texto en un

control de texto, por ejemplo) pueden ser contraproducentes y dar una

apariencia de dificultad a un programa.

3.7.5. Separadores

Los separadores son barras horizontales o verticales que le permiten

organizar sus controles en grupos. Aunque se utilizan mayoritariamente en

los mens para dividir elementos de men en agrupaciones lgicas, podr

utilizar separadores en componentes JApplet y JFrame como cualquier otro

control.

41
3.8. Swing: ventanas. Paneles. Marcos internos y cuadros de dialogo

3.8.1. Ventanas

Las clases JWindow y JFrame son el equivalente de las clases Window

yFrame en AWT y sirven para el mismo propsito. Puede utilizar la

claseJWindow para crear una ventana simple; de hecho, no es ms que un

rectngulo blanco. Aunque puede aadir bordes y controles a los objetos

JWindow, normalmente utilizar la clase JFrame para crear ventanas que

presente al [Link] clases JDesktopPane y JInternalFrame son nuevas

en Swing, aunquejuntas representan algo que ha llegado a ser muy comn

en las IU: una interfaz de documentos mltiple. Los objetos de la clase

JDesktopPane presentan un espacio en el que puede visualizar mltiples

marcos internos de la clase JInternalFrame. Por ejemplo, una aplicacin de

procesamiento de textos podra permitir al usuario abrir varias vistas del

mismo documento, o de mltiples documentos, utilizando un escritorio con

varias ventanas de marcos internos. Los marcos internos son de poco peso,

y dibujan ventanas que aparecen dentro de otras ventanas. De hecho, los

paneles de escritorio tambin son componentes de poco peso, derivados de

JLayeredPane. Puede aadir ventanas de marcos internos a las capas

seleccionadas de un panel de escritorio.

3.8.2. Cuadros de dilogo

La Swing proporciona bastante soporte para cuadros de dilogo con la clase

JOptionPane. Mediante el uso de mtodos de esta clase, puede visualizar

toda clase de cuadros de dilogo (cuadros de dilogo de mensaje, cuadros

de dilogo de confirmacin, cuadros de dilogo de entrada y muchos

42
ms).Como ver aqu, es sencillo crear cuadros de dilogo utilizando

JOptionPane. Adems de JOption Pane, la Swing tambin posee la clase

JDialog, que puede utilizar como base para sus propias clases de cuadro de

dilogo personalizadas.

3.9. Creacin de paquetes. Interfaces. Archivos JAR y Java Beans

3.9.1. Crear un paquete

La creacin de los paquete es debido que la instauracin de las clases se las

coloca de forma desordenada. Cmo se puede resolver este desorden? La

solucin est en la divisin de las clases en paquetes? Eso permitir

distribuirlos archivos de clase en una estructura de directorios de forma

similar acuando distribuye los archivos porque tiene demasiados. Cuando

se tiene varios archivos de clase, es buena idea distribuirlos en el disco

utilizando una jerarqua de directorios. De hecho, los paquetes Javaf ueron

diseados originalmente para reflejar esa organizacin de archivos. Puede

distribuir archivos de clase en una jerarqua de directorios y permitirque Java

sepa lo que sucede con los paquetes. Por ejemplo, si se tiene un paquete

llamado package, que contiene una [Link], el archivo de clase ira

en un directorio llamado package, como sigue:

package
-app
Mltiples archivos de clase en el mismo paquete irn en el mismo directorio:

packagel

-app

-app3

43
Como el directorio package se encuentra en una localizacin que Java

Buscar, Java buscar los archivos de clase que utilice como parte del

paquete en ese directorio. Tiene que indicarle a qu paquete pertenece un

archivo de clase, utilizando la sentencia packagel en su cdigo. Aqu tiene

un ejemplo donde creamos [Link] e indicamos que forma parte de

packagel utilizando la sentencia

package:
packagepackagel;
publicclasc app
public static void main (String args)

[Link] ("Hola desde Java!");

Una vez compilada [Link] y almacenada en el directorio packagel,

podemos entonces importar la clase app en el cdigo con sentencias como

lasiguiente, como haramos con cualquier otro paquete Java:

importpackagel.*;

[Link];

La herramienta de tiempo de ejecucin de Java tambin conoce los

paquetes; por tanto, debido a que la clase [Link] es una aplicacin en s,

podemos ejecutar esta clase con una lnea de comando que especifique el

paquete de la clase app y utilizando un punto (.) para el separador de

directorios:

c:\> java [Link]

De hecho, el separador de paquetes punto es til cuando creamos paquetes

dentro de paquetes; examine el siguiente tema para ms detalles.

44
3.9.2. Crear paquetes que contienen paquetes

Cuando tenemos gran cantidad de archivos de clase, podemos organizarlos

en una estructura de paquetes bastante compleja, y lo hacemos creando la

estructura de directorios correspondiente en el disco, incluyendo las

estructuras de subdirectorios dadas.

Por ejemplo, si quiere que la clase app est en el paquete package2, que

asu vez est dentro del paquete package 1, sta ser la estructura de

directorios:Para crear esta estructura de paquetes en el cdigo, basta utilizar

el separador de paquetes punto.

ejemplo:

package packagel.package2;
public class app
I
public static void rnain (String[l args)
{
[Link] ("iHola desde Java! " ) ;

Ahora puede importar la clase app en su cdigo con sentencias como stas:

import packagel.package2.*;

irnport [Link];

Debido a que en este caso app ya es una aplicacin clase, tambin puede

ejecutarla como sigue, especificando la estructura de directorios de paquete:

c:\> java [Link]

;Hola desde Java!

3.9.3 Crear una interfaz

Cuando creamos una interfaz, especificamos los mtodos de la interfaz y

cuando la implementamos, proporcionamos el cdigo de [Link]

tiene un ejemplo en el que creamos una interfaz llamada Printem quetiene

45
un mtodo: printText. Implementamos esta interfaz en la clase llamada class.

Para crear una interfaz, utilizamos simplemente la sentencia interfacey

listamos los prototipos (declaraciones sin cuerpo) de los mtodos que

queremos en la interfaz, como sigue:

interfacePrintem
I
voidprintText ( ) ;
}
Ahora podemos implementar esta interfaz en class 1:
interfacePrintem
{
voidprintText ( ) ;
1
public class interfaces
(
public static void main(Stringr1 args)
I
classlobjectl = new classl0;
objectl.printText0;
1
}
classclassl implements Printem
I
public void printText0
(
[Link](HoladesdeJavaln);

3.9.4. Implementacin parcial de una interfaz

Puede crear clases que implementen parcialmente una interfaz, pero estas

clases deben declararse abstractas debido a que son nicamente

implementaciones parciales y, por tanto, no pueden instanciarse en objetos.

Aqu tiene un ejemplo en el que creamos una interfaz con dos mtodos,

printText 1 y printText2:
interfacePrintem
voidprintTextl(1;
void printText2 ( ) ;

A continuacin, se crea una nueva clase, class1, que implementa la interfaz

pero nicamente define un mtodo, printText2 (observe que debido a que

46
estaclase no es una implementacin completa de la interfaz, debemos

declararlaabstracta):

interfacePrintem
(
voidprintTextl ( ) ;
void printText2 ( ) ;

abstract class classl implements Printem

{
public void printTextl0
I
[Link]("~Hola desde Java!");

Finalmente, podemos crear una nueva clase, class2, que extienda class1 e

implemente printText2, lo que significa que podemos instanciar objetos de la

clase class2 como se muestra aqu:

interfacePrintem
void printText1 ( ) ;
void printText2 ( ) ;
public class interfaces2
{
public static void main(String[l args)
(
class2 object2 = new class2 O ;
object2.~rintText2();
abstract class classl implements Printem
(
public void printTextl0
[Link](" Holadesde Java!");
class class2 extends classl
f
public void printText20
[Link](~ola desde los interfaces Java!");

47
3.9.5. Crear un archivo JAR

El uso de los archivos JAR es por el aumento archivos de clase estn

aumentando de tamao y hay muchos los archivos JAR comprimen sus

contenidos utilizando el formato ZIP, por lo que si su applet necesita una

gran cantidad de archivos grandes, es conveniente crear un archivo JAR.

Los navegadores de la red Internet nicamente necesitan una conexin en

vez de nuevas conexiones para cada nuevo archivo, lo que puede mejorar

los tiempos de descarga. Tambin puede firmar digitalmente los archivos de

un archivo JAR para probar su origen.

Crear archivos JAR con la herramienta jar. Esta herramienta viene con Java

ya qu tiene su forma de uso:

jar [optionsl [manifest] destination input-file[additional input filesl

Aqu, options son las opciones que puede utilizar con la herramienta JAR y

son parecidas a las opciones que se utilizan con la herramienta UNIX tar. El

argumento opcional manifest consiste en el nombre de un archivo manifest,

que soporta la firma digital y muestra los contenidos del archivo Java.

Cuando cree un JavaBean, utilice un archivo manifest para indicar qu

clases sonBeans

Aqu se observa las opciones posibles que puede utilizar cuando use la

herramienta

jar:

c. Crea un archivo nuevo o vaco en la salida estndar.

t. Muestra la tabla de contenidos en la salida estndar.

x file. Extrae todos los archivos o slo los nombres de archivos. caso,

nicamente se extraen los archivos especificados.

48
 f. El segundo argumento especifica un archivo JAR para trabajar.

v. Genera una salida "duplicada" en stderr.

m. Incluye informacin manifiesta de un archivo manifest especificado.

O. Indica "slo almacenar", sin utilizar compresin ZIP

M. Especifica que un archivo manifest no debera crearse por las

entradas.

u. Actualiza un archivo JAR existente aadiendo o cambiando los

archivos del manifest.

-C. Cambia los directorios durante la ejecucin del comando jar. Por

Ejemplo, jar aadira todos los archivos dentro del directorio clases, pero

no el propio directorio clases, al archivo [Link].

Truco: Puede utilizar un argumento comenzando por el carcter para

especificar un archivo que contiene argumentos adicionales Estos

argumentos se insertan en la lneas en la posicin del argumento

@filen:"@"

S, con

Aqu se tiene el uso tpico de la herramienta jar:

c: \> jar cf j a r f i l e . jar * .class

En este caso, todos los archivos de clase del directorio actual se sitan en el

archivo llamado [Link]. La herramienta JAR genera automticamente un

archivo manifest predeterminado y es siempre la primera entrada del archivo

Java (por defecto, se llama META-INF/[Link]). Si tiene un archivo

manifest y quiere que utilice la herramienta jar para un nuevo archivo JAR,

se puede utilizar la opcin -m y especificarlo como sigue:

c:\>jar cm [Link] [Link] *.class

49
Observe que cuando especifica las opciones cfm en lugar de cmf, necesita

especificar el nombre del archivo JAR primero, seguido del nombre del

archivo manifest:

c:\>jarcfmjarfile. [Link] *.class

Observe tambin que los archivos JAR no son nicamente para archivos de

clase; pueden almacenar cualquier tipo de archivo. Aqu tiene la forma de

empaquetar todos los archivos de un directorio en un archivo JAR:

c:\>jarcfm [Link] [Link] * . *

Si los nombres de archivo que quiere empaquetar incluan directorios, los

directorios se buscan de forma recursiva y se almacenan en el JAR los

archivos. Cuando el archivo JAR se desempaqueta, se recrea de nuevo la

estructura de directorios.

3.9.6. Obtener los contenidos del archivo JAR

Los archivos JAR guardar informacin empaquetada para la visualizacin

del contenido. De esta manera se puede determinar el contenido de un

archivo JAR con las opciones tf, como en este caso, donde el archivo JAR

contiene un manifest predeterminado en el directorio interno META-INF y

varios archivos de clase:

c: \>jartfjarfile. jar

META- INF /

META-INF/[Link]

[Link]

[Link]

[Link]

[Link]

50
3.9.7. Extraer archivos desde un archivo JAR

Cuando se programa se utiliza los archivos JAR paraarchivar los archivos;

pero, cmo se extrae los archivos de un JAR?",

"Con las opciones xf".

Podemos extraer archivos desde un archivo JAR utilizando las opciones

xf. Por ejemplo, aqu tiene la forma de extraer todos los archivos del archivo

jarfile-jar introducido en el tema previo:

c: \>jarxfjarfile. jar

Al desempaquetar todos los archivos del archivo JAR de esta forma,tambin

creamos su estructura original de directorio. En este caso, la herramientajar

desempaqueta los archivos de clase y tambin crea un directoriollamado

META-INF donde coloca el archivo predeterminado manifest

[Link]. Tambin podemos extraer archivos especificando sus

nombres. Aqu tieneun ejemplo en el que extraemos [Link]:

c: \> jar xfjarfile. [Link]

3.10. Swing Utilities

[Link]

Estos son slo 2 de los 36 mtodos de utilidad genrica definidos en

SwingUtilities, que se dividen en siete grupos: mtodos de clculo, mtodos

de conversin, mtodos de accesibilidad, mtodos de recuperacin, mtodos

relacionados con la multitarea y los eventos, mtodos para los botones del

ratn, y mtodos de disposicin/dibujo/UI. Todos estos mtodos son

estticos y se describen muy brevemente en esta seccin (para una

comprensin ms avanzada vea el cdigo fuente de [Link]).

51
3.10.1. Mtodos de clculo

Rectangle[] computeDifference(RectanglerectA, RectanglerectB):

devuelvelas regiones rectangulares que representan la porcin de rectA que

no intersecciona con [Link](int x, int y,

intwidth, intheight,Rectangledest): devuelve la interseccin de dos reas

rectangulares. La primera regin sedefine con los parmetros de tipo int y la

segunda por con el parmetro de tipo Rectangle. Elparmetro de tipo

Rectangle se modifica y se devuelve como resultado del clculo de forma

queno se tiene que instanciar un nuevo Rectangle.

RectanglecomputeUnion(int x, inty, intwidth, intheight, Rectangledest):

devuelve la unin de dos reas rectangulares. La primera regin se define

con losparmetros de tipo int y la segunda por con el parmetro de tipo

Rectangle. El parmetro detipo Rectangle se modifica y se devuelve como

resultado del clculo de forma que no se tieneque instanciar un nuevo

Rectangle.

isRectangleContainingRectangle(Rectangle a, Rectangle

b): devuelve true si el Rectangle a contiene completamente al

[Link](FontMetricsfm, Stringstr): devuelve la

achura del String de acuerdo al objeto FontMetrics.

3.10.2. Mtodos de conversin

MouseEventconvertMouseEvent(Componentsource,

MouseEventsourceEvent, Componentdestination): devuelve un MouseEvent

nuevo con destination como fuentey las coordenadas x e y convertidas al

sistema de coordenadas de destination (asumiendo enambos casos que

destination no sea null). Si destination es null las coordenadas se convierten

52
al sistema de coordenadas de source, y se pone source como fuente del

evento. Siambos son null el MouseEvent devuelto es idntico al evento que

se [Link] convertPoint (Componentsource, Point aPoint,

Componentdestination): devuelve un Point que representa aPoint convertido

al sistema de coordenadas del componente destination como si se hubiese

generado en el componente source. Si uno de los componentes es null se

usa el sistema de coordenadas del otro, y si ambosson null el Point devuelto

es idntico al Point pasado.

Point convertPoint(Componentsource, int x, int y, Componentdestination):

este mtodo funciona igual que el anterior mtodo convertPoint() exceptoque

recibe parmetros de tipo int que representan las coordenadas del Point a

convertir en lugar de una instancia de

[Link](Componentsource, RectangleaRectangle,

Componentdestination): devuelve un Rectangle convertido del sistema de

coordenadasdel componente source al sistema de coordenadas del

componente destination. Este mtodose comporta de forma similar a

convertPoint().voidconvertPointFromScreen(Point p, Component c):

convierte el Point dado encoordenadas de la pantalla al sistema de

coordenadas del Component [Link](Point p,

Component c): convierte el Point dado en el sistema de coordenadas del

Component dado al sistema de coordenadas de la pantalla.

53
3.10.3. Mtodos de accesibilidad

AccessiblegetAccessibleAt(Component c, Point p): devuelve el

componenteAccessible en el determinado Point del sistema de coordenadas

del Component dado (sedevolver null si no se encuentra ninguno). Observe

que un componente Accessible es aquelque implementa el interface

[Link](Component c,

int i): devuelve el dcimo hijoAccessible del Component [Link]

getAccessibleChildrenCount(Component c): devuelve el nmero de

hijosAccessible que contiene el Component dado.

IntgetAccessibleIndexInParent(Component c): devuelve el ndice en su padre

delComponent dado descartando todos los componentes contenidos que no

implementen el interfaceAccessible. Se devolver -1 si el padre es null o no

implementa Accessible, o si el Component dado no implementa

[Link] (Component c):

devuelve el conjunto de A ccessibleStates que no estn activos para el

Component dado.

3.10.4 Mtodos de recuperacin

ComponentfindFocusOwner(Component c): devuelve el componente

contenido dentro del Component dado (o el Component dado) que tiene el

foco. Si no hay tal componente se devuelve

null. ContainergetAncestorNamed(Stringname, Componentcomp): devuelve

el ancestorms cercano del Component dado con el nombre que le

pasamos. En otro caso se devuelve null.(Observe que cada Component

tiene una propiedad name que se puede asignar y recuperar usando los

mtodos setName() y getName ()respectivamente.)

54
ContainergetAncestorOfClass(Class c, Componentcomp): devuelve el

ancestro mscercano del Component dado que es una instancia de c. En

otro caso se devuelve [Link]

(Componentparent, int x, int y): devuelve elhijo ms profundo del Component

dado que contiene el punto (x,y) en trminos del sistema decoordenadas del

Component dado. Si el Component no es un Container este mtodo

terminainmediatamente.

RectanglegetLocalBounds(Component c): devuelve un Rectagle que

representa los lmites de un Component determinado en su propio sistema

de coordenadas (de este modo siempre empieza en

0,0).ComponentgetRoot(Component c): devuelve el primer ancestro de c que

es una Window. Enotro caso este mtodo devuelve el ltimo ancestro que es

un [Link](Component c): devuelve el primer

JRootPane que es padre de c, o c si es un

[Link] (Component c): devuelve el

primer ancestro de c que es una Window. En otro caso devuelve

[Link](ComponentallegedDescendent,

ComponentallegedAncestor): devulve true si allegedAncestor contiene a

allegedDescendent.

3.10.5. Mtodos relacionados con la multitarea y los eventos

voidinvokeAndWait(Runnableobj): enva el Runnable a la cola de despacho

de eventos y bloquea el hilo [Link](Runnableobj): enva el

Runnable a la cola de despacho de eventos y contina.

booleanisEventDispatchThread(): devuelve true si el hilo actual es el hilo de

despacho de eventos.

55
3.10.6. Mtodos para los botones del ratn

booleanisLeftMouseButton(MouseEvent): devuelve true si el MouseEvent

correspondea una pulsacin del botn izquierdo del ratn.

booleanisMiddleMouseButton(MouseEvent): devuelve true si el

MouseEventcorresponde a una pulsacin del botn de en medio del ratn.

booleanisRightMouseButton(MouseEvent): devuelve true si el

MouseEventcorresponde a una pulsacin del botn derecho del ratn.

3.10.7 Mtodos de disposicin/dibujo/UIString

layoutCompoundLabel (FontMetricsfm, Stringtext, iconicon,

intverticalAlignment, inthorizontalAlignment, intverticalTextPosition,

inthorizontalTextPosition, RectangleviewR, RectangleiconR,RectangletextR,

inttextIconGap): Este mtodo se usa normalmente por el delegado UI de

JLabel para posicionar texto y/o un icono usando el FontMetrics, las

condiciones de alineamiento y las posiciones del texto dentro del

RectangleviewR . Si se determina que el texto de la etiqueta no cabr dentro

de este Rectangle, se usan puntos suspensivos (...) en lugar del

texto que no cabra. Los RectanglestextR e iconR se modifican para reflejar

la nuevadisposicin, y se devuelve el String resultante de esta

[Link] (JComponent c, FontMetricsfm,

Stringtext,iconicon, intverticalAlignment, inthorizontalAlignment,

intverticalTextPosition, inthorizontalTextPosition, RectangleviewR,

RectangleiconR, RectangletextR, inttextIconGap): este mtodo es idntico al

anterior, pero recibe el componente destino para comprobar si l la

orientacin del texto se debe tener en cuenta voidpaintComponent(Graphics

g, Component c, Container p, int x, int y,int w, int h): pinta el Component

56
dado en el contexto grfico dado, usando el rectngulo definido por los

cuatro parmetros de tipo int como rea de recorte. El Container se usa para

que acte como el padre del Component de forma que cualquier peticin de

validacin sucedan en ese componente no se propaguen por el rbol de

ancestros del componente al que pertenece el contexto grfico dado. Esta es

la misma metodologa que usan los pintores decomponentes de JList, JTree,

y JTable para mostrar correctamente el comportamiento de"sello de goma"

(rubberstamp). Este comportamiento se logra mediante el uso de

unCellRendererPanevoidpaintComponent(Graphics g, Component c,

Container p, Rectangle r):funciona de forma idntica al mtodo anterior, pero

recibe un Rectangle como parmetro en lugar de cuatro

[Link](Component c): notifica a todos los

componentes que contiene c, y a c, que actualicen su delegado UI para que

correspondan a los actuales UIManagery UIDefaults.

57
4. Conclusiones

A lo largo de este trabajo investigativo se han comprobado las similitudes y

diferencias entre ambosAPIs para la creacin de interfaces grficas.

Bsicamente, Swing viene a ser una ampliacin y revisin de AWT. Ambas

bibliotecas de clases comparten aspectos como el manejo de eventos,

jerarquas similares de componentes, la representacin de grficas bsicas e

imgenes... Adems, Swing aade nuevas funcionalidades a los antiguos

componentes, aade nuevos componentes, introduce el concepto de Look &

Feel, da soporte a el paradigma MVC; en resumen, aprovecha el camino

recorrido por AWT respondiendo a sus deficiencias y a las nuevas

necesidades. Esto pone de manifiesto que las capacidades y respuestas

que ofrece Swing son fruto de una suma de trabajos anteriores a l, lo que

indica la importancia en la construccin de software de las buenas prcticas

de la ingeniera del software, que facilitan conceptos tan tiles como la

reutilizacin, la portabilidad entre plataformas, la escalabilidad... en resumen

al software de calidad. En resumen, AWT y Swing son un gran ejemplo de la

buena puesta en marcha de las prcticas de la ingeniera del software y de

la orientacin a objeto.

58
 5. Recomendaciones

En la aplicacin slo debe haber un nico JFrame, correspondiente a la

aplicacin principal. Todas las ventanas secundarias deben ser JDialog.

Todas las ventanas secundarias deben tener una ventana padre, que es a

partir de la cual se despliega. Es decir, todos los JDialog secundarios deben

tener como padre al JFrame principal. Si desde un JDialog se va a visualizar

otro, este segundo debe tener como padre al primero, y as sucesivamente.

Evitar en lo posible los JDialog modales, o tener muy en cuenta su jerarqua

de padres. El primer JDialog modal no tiene problemas si le pones su padre

adecuadamente. Si tienes un JDialog modal visible, no muestres otro

JDialog secundario, salvo que tambin sea modal y sea hijo del anterior. Si

pones visibles a la vez dos JDialog modales y no son el uno hijo del otro,

tendrs problemas al intentar escribir en ellos o cerrarlos.

Nunca hereda de JFrame o JDialog o JApplet para hacer las ventanas. Se

puede hacer siempre de un componente que no sea ventana y que no

limite. Si las ventanas heredan de JPanel, podrs ponerlas siempre que

quieras dentro de un JFrame, un JDialog, un JInternalFrame, un JApplet o

incluso incrustarlas en otro JPanel. Si tu ventana hereda de JFrame, est

condenada a ser un JFrame toda su vida.

Reaprovechar las ventanas, no dejar al recolector de basura. Si un botn, al

apretarlo, visualiza un JDialog, no hagas un new de JDialog cada vez que

pulsas el botn. Es mejor hacer slo un new la primera vez y guardar. En las

siguientes veces bastar con hacer setVisible(true) y setVisible(false). Para

que el recolector de basura libere una ventana, adems de lo habitual, hay

como mnimo que llamar al mtodo dispose() de dicha ventana -cosa que

mucha gente no sabe- , para que el sistema de eventos de teclado y ratn

59
 eliminen todas las referencias que tienen a ella. De todas formas, incluso as

no tengo muy claro que los JDialog se liberen siempre y, desde luego, en

versiones anteriores de Java, los JFrame NUNCA se liberaban. La excusa

de SUN es que como slo deba haber un JFrame principal, no tena sentido

liberarlo.

Los layouts para situar componentes no son tan complicados, slo hay que

ponerse a ello. No usar el layoutnull, ya que la ventana no ser

redimensionable y puedes tener problemas si cambia la fuente de letra, si tu

programa se ejecuta en otro sistema operativo, se cambia el look &feel, etc.

60
6. Bibliografa

A. Java Swing

[Link]

B. Sun The Swing Tutorial

[Link]

C. Sun, Traductor : Juan Antonio Palos Swing y JFC

[Link]

Universidad de Navarra Aprenda Java como si estuviera en primero

San Sebastin,Marzo 1999

D. Universidad de Las Palmas de Gran Canaria Tutorial de Java

AWT[Link]

61
 Anexos.

Anteproyecto

INTRODUCCIN.

Esta Investigacin pretende ser una introduccin a Swing, con la que se

intenta mostrar una visin general sobre herramientas de interfaces grficas

de usuario, y ms concretamente, sobre el desarrollo de stas con Java y

sus APIs, lo que se pretende mostrar las ventajas que ofrece ste tipo de

programacin.

En primer lugar, se realiza una introduccin a Swing, el AWT y las interfaces

de usuario, tratando de sta forma de centrar al lector en el tema a tratar.

Una vez realizada dicha introduccin, se describir brevemente el paquete

Swing, para dar una idea de la jerarqua de componentes que se puede

utilizar con Swing y de sus utilidades.

Tambin se mencionar el manejo de eventos en Swing, as como los

Applets, aunque de una forma muy superficial, ya que debido a la gran

amplitud de variaciones que pueden darse, sera muy extenso hacer una

descripcin detallada.

62
DATOS INFORMATIVOS.

2.1.1. Tema General

ADMINISTRADOR DE DISEO DE JAVA

2.1.2. Tema Especfico.

COMPONENTE SWING
Universidad.
Universidad Catlica de Cuenca
Unidad Acadmica de Ingeniera de
Sistemas, Elctrica y Electrnica
Facultad de Ingeniera de Sistemas.

Investigador.

Tnlg. Anl. Freddy E. Quezada B.

Director.

Ing. Ali Mndez.

Lugar.
Universidad Catlica de Cuenca.
Fecha.
10 de Octubre del 2011.

LUGARES DE CONSULTA.

[Link]
[Link]
[Link]
[Link]
[Link]

JUSTIFICACIN Y PROPUESTA.

63
4.1. ANLISIS DE LA SITUACIN ACTUAL.
La programacin en Java ha comenzado a despegar simplemente debido a
su capacidad de hacer programas en mltiples plataformas. Esto es no slo
cierto para computadoras porttiles pero Java tambin est presente en las
PC de bolsillo e incluso en los telfonos mviles estndar. Debido a esto,
existe un gran inters en programar con Java y aprovechar este gran y
creciente mercado.

La programacin en Java significa que tener las herramientas adecuadas a

fin de terminar proyecto rpido y eficientemente. Una de las herramientas
esenciales es el componente de GUI (interfaz grfica de usuario). Esto
permite agregar fcilmente el componente grfico sin la mayor parte de la
programacin necesaria. En esta categora, hay dos de las que puedes
elegir. La primera es la AWT (AbstractWindowToolkit) y el segundo es el
swing, que apareci ms tarde.

Estos kits de herramientas tienen sus propias ventajas y desventajas que los
hacen adecuados para los distintos tipos de necesidades de programacin.
El AWT utiliza muchos de los comandos de la plataforma que le da una gran
cantidad de velocidad. Pero a fin de convertirlo para su uso en otras
plataformas, debe cambiar los comandos de la contraparte. Por otro lado,
Swing utiliza cdigo Java puro, hacindolo muy porttil con el costo de
velocidad y rendimiento a travs de plataformas.

4.2. PROPUESTA.

Dar a conocer a travs de mtodos investigativos la aplicacin y uso de de

las herramientas del lenguaje Java para un diseo y desarrollo de
aplicaciones dedicadas al usuario.

64
OBJETIVOS.

5.1. Objetivo General.

Analizar los componentes de Java swing

5.2 Objetivos Especficos:

Lograr conocimiento de los paquetes de Swing de java.

Ilustrar al usuario con gua de uso que se refiere a la aplicacin de
componentes dedicados a la interface de usuario
Adquirir competencias para la aplicacin del lenguaje java

ALCANCE Y LIMITACIONES.
6.1 Alcances.

Crea una alternativa para el desarrollo de aplicaciones dedicadas al

usuario
Establecer diferencias entre distintos lenguajes de desarrollo
orientado a objetos
Aplicar los componentes de Java. Swing

6.2. Limitaciones.

Ya que Swing es un extenso conjunto de componentes el tiempo para el

desarrollo de los mismos

65
MARCO REFERENCIAL Y CONCEPTUAL.
7.1. Marco Referencial.

Swing es el nombre clave del proyecto que desarroll los nuevos

componentes que vienen a sustituir o complementar a los de AWT.
Frecuentemente se usa para referirse a los nuevos componentes y al API
relacionado. Est inmortalizado en losn ombres de paquete del API Swing,
que empiezan con [Link]. Esta versin de lasJFC fue publicada como
JFC 1.1, que algunas veces es llamada 'Versin Swing'. El API delJFC 1.1
es conocido como el API Swing.

Swing constituye la caracterstica ms importante que se ha aadido a la

plataforma 1.2, como Sun ha preferido llamarla, Java2. Con esta ltima
incorporacin por fin se completa totalmente la parte grfica de la
programacin en Java, ofreciendo al programador acceso a todas las
caractersticas existentes en un entorno grfico actual, as como un conjunto
de componentes grficos completo y fcilmente ampliable con el que
construir la interfaz grfica de usuario, o GUI, de nuestras aplicaciones y
applets, de una forma totalmente transparente e independiente de la
plataforma en la que ejecutemos nuestro cdigo.

7.2. Marco Conceptual.

Swing es una de las mejoras principales que ha experimentado el JDK en su

versin 1.2 con respecto a la versin 1.1, y representa la nueva generacin

de AWT. Tambin es una de las API de las Clases de Fundamentos de Java

(JFC), lo cual es el resultado de un esfuerzo de colaboracin muy grande

entre Sun, Netscape, IBM y otras empresas. Lo que da a Swing su

importancia es el poder que ofrece para desarrollar interfaces grficas de

usuario (GUI) para applets y aplicaciones. La cantidad y calidad de los

controles GUI que ofrece Swing no tiene rival en ningn otro juego de

herramientas GUI.

66
 El origen de los controles GUI que presenta Swing lo encontramos en las

Clases de Fundamentos de Internet de Netscape (IFC). Los componentes

Swing van ms all de las IFC, hasta el punto de que no hay un parecido

apreciable entre los componentes Swing y los de las IFC. Swing ofrece

tambin la posibilidad de cambiar fcil y rpidamente el aspecto y sensacin

(L&F) de un nico componente o grupo de componente. Esta posibilidad,

que se conoce como aspecto y sensacin conectables (PL&F), es un sello

distintivo de Swing

TEMARIO.

I INTRODUCCIN
CAPITULO I
Swing
1.1 historia
1.2 Ventajas - Desventajas
1.2 Eventos Swing
1.3 Modelos de componentes Swing
1.4 Descripcin de algunos componentes Swing

CAPITULO II
Layouts
2.1. Look &Feel
2.2. Otras nuevas caractersticas
2.3. Action
2.4. Modelos de datos y estados separados
2.5. Soporte para tecnologas asistivas
2.6. Applets en Swing
CAPITULO III
3.1. Herencia de Componentes y Contenedores

3.2. Control de Distribucin

3.3. Construccin de GUI en Swing

67
 3.4. Manejo de eventos en Swing

3.5. Swing: Applets. aplicaciones y cambios de apariencia

3.6. Swing: Cuadros de texto. botones y casillas de activacin

3.7. Swing: viewports. desplazamiento. deslizadores y listas

3.8. Swing: barras. herramientas. cuadros. Se paradores y selectores

3.9. Swing: ventanas. paneles. marcos internos y cuadros de dialogo

3.10. Creacin de paquetes. interfaces. archivos JAR y Java Beans

4. Conclusiones
4.2 Recomendaciones

I. Bibliografa
II. Anexos.

68
ESTRATEGIAS METODOLGICAS.

Etapa de Mtodos
Tcnicas Resultados
investigacin Empricos Tericos

ANLISIS
DE LA Bases tericas
SITUACIN Analtico sinttico. Revisin por Internet de la
ACTUAL Investigacin.

Histrico- Lgico Investigar los

Revisin Documental elementos del
PROPUESTA DE Recoleccin de paquete swing
SOLUCIN Informacin Analtico sinttico. Observacin de java

Hipottico
Deductivo

MARCO REFERENCIAL Analtico sinttico

Y CONCEPTUAL Propuesta
fundamentada
Sistmico Tericamente.

69
 Instrumentos.
Las Herramientas que se utilizarn en el Desarrollo de la Investigacin son:
El Internet, constituye la fuente y base fundamental de donde se extraer
la Informacin requerida.
El programa Netbeans 7.0, el mismo que nos ofrecer mayor soporte
Tcnico para el desarrollo del presente proyecto.

RECURSOS.

Recursos Humanos.
Catedrticos del Plantel.
Autor.

Recursos Tecnolgicos.

Uno de los Recursos Tecnolgicos importantes es la Red de Redes (el

Internet), la cual ofrece la mayor parte de la Informacin acerca de estas
herramientas

Recursos Materiales.

Computadora porttil
Netbeas 7.0 (win - linux)
tiles de oficina
Internet

70
 Recursos Econmicos.
Para la realizacin del Presente Trabajo se destina los siguientes rubros:
Detalle Rubro
Equipo Porttil $ 600
tiles de Oficina $ 35
Consumo de internet prepago $ 35
Impresiones y Empastado $ 60
TOTAL 730

BIBLIOGRAFA.

Java Swing [Link]

Sun The Swing Tutorial [Link]
Sun, Traductor : Juan Antonio Palos Swing y JFC
[Link]
Universidad de Navarra Aprenda Java como si estuviera en primero San
Sebastin, Marzo 1999
Universidad de Las Palmas de Gran Canaria Tutorial de Java - AWT
[Link]

71
 CRONOGRAMA

SEMANA 1 SEMANA 2 SEMANA 3 SEMANA 4 SEMANA 5 SEMANA 6 SEMANA 7 SEMANA 8

LUN 31 LUN 28
LUN 17 A LUN 24 A LUN 7 A LUN 14 A LUN 21 A LUN 05 A
OCT A NOV A
VIE 21 DE VIE 28 DE VIE 11 DE VIE18 DE VIE 25 DE VIE 09 DE
VIE 21 DE VIE 2 DE
OCT OCT NOV NOV NOV DIC
NOV DIC

CAPITULO
I X X X X
CAPITULO
II X X X
CAPITULO
III X X X X X

72