UNIVERSIDAD CATÓLICA DE CUENCA UNIDAD ACADÉMICA DE...
80
UNIVERSIDAD CATÓLICA DE CUENCA UNIDAD ACADÉMICA DE INGENIERÍA DE SISTEMAS, ELÉCTRICA Y ELECTRÓNICA COMPONENTE SWING DE JAVA: ADMINISTRADORES DE DISEÑO Trabajo de Investigación previo a la obtención del Título de Ingeniero de Sistemas. Aspirante: TNLG. ANL. FREDDY E. QUEZADA B. Director: ING. ALÌ MÉNDEZ.
Transcript of UNIVERSIDAD CATÓLICA DE CUENCA UNIDAD ACADÉMICA DE...
UNIVERSIDAD CATÓLICA DE CUENCA
UNIDAD ACADÉMICA DE INGENIERÍA DE SISTEMAS, ELÉCTRICA Y ELECTRÓNICA
COMPONENTE SWING DE JAVA: ADMINISTRADORES DE DISEÑO
Trabajo de Investigación previo a la obtención del Título de Ingeniero de Sistemas.
Aspirante:
TNLG. ANL. FREDDY E. QUEZADA B. Director:
ING. ALÌ MÉNDEZ.
Certifico que esta investigación ha sido desarrollada en su totalidad por el
Tnlg. Freddy Edwin Quezada Bermeo bajo mi coordinación.
F)……………………………………………………………….
ING. ALI MÉNDEZ.
La información de la presente investigación 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 razón de mi esfuerzo y
por acompañarme incondicionalmente en los momentos de
mi vida ; a mis queridos Padres que supieron educarme con
valores y acercar cada vez más las metas propuestas en la
vida profesional como en la vida cotidiana.
AGRADECIMIENTO:
A las personas que supieron ayudarme para que esta
investigación fuera realizada, Mis queridos hermanos; y un
agradecimiento especial al ING. ALI MÉNDEZ por guiarme en
el proceso de elaboración de esta monografía.
1
ÍNDICE
UNIVERSIDAD CATÓLICA DE CUENCA .......................................................... 1
CAPÍTULO I ........................................................................................................ 2
1.1 Historia .......................................................................................................... 2
1.2 Ventajas y Características ............................................................................ 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 métodos. .............................................................................. 10
1.4 Descripción de algunos componentes Swing.............................................. 10
CAPÍTULO II ..................................................................................................... 13
2.1. Layouts ...................................................................................................... 13
2.2. Look &Feel ................................................................................................. 13
2.3. Nuevas características ............................................................................... 15
2.3.1 Action Con objetos Action ........................................................................ 15
2.4. Modelos de datos y estados separados ..................................................... 15
2.5. Soporte para tecnologías 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 Distribución ............................................................................... 21
3.2.1. Seleccionar el Controlador de Distribución ............................................. 23
3.2.2. Proporcionar Consejos sobre un Componente ...................................... 24
3.2.3 Poner Espacio entre Componentes ......................................................... 25
3.2.3.1. El controlador de distribución. .............................................................. 25
3.2.3.3. Bordes vacíos ...................................................................................... 25
3.2.4. Cómo Ocurre el Control de Distribución ................................................. 26
3.3. Construcción de GUI en Swing .................................................................. 27
3.3.1 Ventanas .................................................................................................. 27
3.3.2. Menús ..................................................................................................... 28
3.3.3. Paneles ................................................................................................... 28
3.3.4. Diseños ................................................................................................... 28
3.3.5. Iconos ..................................................................................................... 29
2
3.3.6. Bordes..................................................................................................... 29
3.3.7. Información 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 activación ....................... 33
3.5. 1. Etiquetas y cuadros de texto .................................................................. 34
3.5. 2. Botones .................................................................................................. 34
3.5.3. Casillas de activación y botones de opción............................................. 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 diálogo ................................................................................. 42
3.9. Creación 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. Implementación parcial de una interfaz .................................................. 46
3.9.5. Crear un archivo JAR ............................................................................. 48
3.9.6. Obtener los contenidos del archivo JAR ................................................ 50
3
3.9.7. Extraer archivos desde un archivo JAR ................................................ 51
3.10. SwingUtilities ............................................................................................ 51
3.10.1. Métodos de cálculo .............................................................................. 52
3.10.2. Métodos de conversión ......................................................................... 52
3.10.3. Métodos de accesibilidad ...................................................................... 54
3.10.4 Métodos de recuperación ....................................................................... 54
3.10.5.Métodos relacionados con la multitarea y los eventos ........................... 55
3.10.6. Métodos para los botones del ratón ...................................................... 56
3.10.7 Métodos de disposición/dibujo/UIString ................................................. 56
4. Conclusiones .............................................................................................. 58
5. Recomendaciones ....................................................................................... 59
6. Bibliografía .................................................................................................... 61
Anexos. ............................................................................................................. 62
INTRODUCCIÓN. ............................................................................................. 62
DATOS INFORMATIVOS. ................................................................................ 63
LUGARES DE CONSULTA. ............................................................................. 63
JUSTIFICACIÓN Y PROPUESTA. ................................................................... 63
4.1. ANÁLISIS DE LA SITUACIÓN ACTUAL ................................................ 64
4.2. PROPUESTA. ........................................................................................ 64
OBJETIVOS. ..................................................................................................... 65
5.1. Objetivo General. ................................................................................... 65
5.2 Objetivos Específicos: ............................................................................. 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 METODOLÓGICAS. ............................................................... 69
RECURSOS...................................................................................................... 70
Recursos Humanos. ...................................................................................... 70
Recursos Tecnológicos. ................................................................................ 70
Recursos Materiales. ..................................................................................... 70
Recursos Económicos. .................................................................................. 71
BIBLIOGRAFÍA. ................................................................................................ 71
CRONOGRAMA ............................................................................................... 72
1
INTRODUCCIÓN
Esta Investigación pretende ser una introducción a Swing, con la que se
intenta mostrar una visión general sobre herramientas de interfaces gráficas
de usuario, y más concretamente, sobre el desarrollo de éstas con Java y
sus APIs, lo que se pretende mostrar las ventajas que ofrece éste tipo de
programación.
En primer lugar, se realiza una introducción 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 introducción, se describirá brevemente el paquete
Swing, para dar una idea de la jerarquía de componentes que se puede
utilizar con Swing y de sus utilidades.
También 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, sería muy extenso hacer una
descripción detallada.
2
CAPÍTULO I
1.1 Historia
AWT era una herramienta poderosa que impulsó la popularidad de Java.
Ahora Swing, que tiene aproximadamente cuatro veces el número de
componentes de la interfaz de usuario de AWT, es parte de la distribución
estándar 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 estándares de hoy, una implementación limitada, no diseñada
para proporcionar una UI seria y básica para las necesidades de millones de
programadores.El conjunto de componentes AWT no fue diseñado para
soportar la popularidadcon la que fue recibido y dentro de las necesidades
de programación dehoy, está limitado en el rango, tiene muchos bugs y
consume gran cantidad derecursos del sistema.Como se mencionó
anteriormente en este libro, el AWT original se tardóen escribir sólo 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 libreríade clases
ZnternetFoundationClasses para usar con Java, éstas fueron muypopulares,
Sun decidió actuar y la unión de los esfuerzos de Sun y Netscapedio lugar al
conjunto de componentes Swing como parte de las ClasesFoundation de
Java (JFC).
3
Muchos programadores creen que JFC y Swing son lo mismo, pero no esasí;
JFC contiene Swing y otro gran número 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 1.1.Java 2D:
Soporte mejorado del color, imagen y texto.
Impresión: Originalmente disponible en Java 1.1.
Swing introdujo tres avances significativos:
Utiliza pocos recursos delsistema, añade gran cantidad de componentes
más sofisticados y permiteconstruir la apariencia de los programas.
1.2 Ventajas y Características
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 noción 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 también lo
es, sesuperpondrá por definición a todos los componentes ligeros del
contenedor.Lo 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, sólo que tenemos que tener cuidado y
saber qué situaciones son seguras ycuáles no. Puesto que probablemente
4
no seremos capaces de prescindir completamente del uso decomponentes
pesados en un breve espacio de tiempo, debemos encontrar formas de que
las dostecnologías trabajen juntas de manera aceptable.
La regla más importante a seguir es que no deberíamos colocar
componentes pesados dentro decontenedores ligeros, que comúnmente
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 específica
deJPopupMenu podemos usar su método setLightWeightPopupEnabled().
Alternativamente podemos llamar al método estático
setDefaultLightWeightPopupEnabled()de JPopupMenu y pasarle un valor
false para forzar a todos los menús emergentes de una sesión deJava a ser
pesados. Tenga en cuenta que sólo afectará a los menús emergentes
creados a partir de que seha hecho la llamada. Es por eso una buena idea
llamar a este método durante la inicialización.
1.2.2 Independencia de la plataforma
La característica más notable de los componentes Swing es que están
escritos al 100% en Java y nodependen de componentes nativos, como
sucede con casi todos los componentes AWT. Esto significaque un botón
Swing y un área de texto se verán y funcionarán idénticamente en las
plataformasMacintosh, Solaris, Linux y Windows. Este diseño elimina la
necesidad de comprobar y depurar lasaplicaciones en cada plataforma
destino.
1.2.3 Paquete Swing
javax.swingContiene la mayor parte de los componentes básicos de Swing,
modelos de componente pordefecto, e interfaces.
javax.swing.borderClases e interfaces que se usan para definir estilos de
bordes específicos. Observe que los bordespueden ser compartidos por
5
cualquier número de componentes Swing, ya que no soncomponentes por si
mismos.
javax.swing.colorchooserClases e interfaces que dan soporte al
componente JColorChooser, usado para selección decolores.
javax.swing.eventEl paquete contiene todos los oyentes y eventos
específicos de Swing. Los componentes Swingtambién soportan eventos y
oyentes definidos en java.awt.event y java.beans.
javax.swing.filechooser
Clases e interfaces que dan soporte al componente JFileChooser, usado
para selección deficheros.
javax.swing.plaf
Contiene el API del comportamiento y aspecto conectable usado para definir
componentes deinterfaz de usuario personalizados. La mayoría 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 están orientadas a desarrolladores que, por una razón u otra,
nopueden usar uno de los look-and-feel existentes.
javax.swing.plaf.basic
Consiste en la implementación 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.
javax.swing.plaf.metal
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á diseñado para ser
consistente con una plataforma específica.
6
javax.swing.plaf.multi
Este es el Multiplexing look-and-feel.No se trata de una implementación
normal de look-andfeelya que no define ni el aspecto ni el comportamiento
de ningún componente. Más bienofrece la capacidad de combinar varios
look-and-feels para usarlos simultáneamente. Unejemplo típico podría ser un
look-and-feel de audio combinado con metal o motif. ActualmenteJava 2 no
viene con ninguna implementación de multiplexing look-and-feel.
javax.swing.table
Clases e interfaces para dar soporte al control de JTable. Este componente
se usa para manejardatos en forma de hoja de cálculo. Soporta un alto
grado de personalización sin requerir mejorasde look-and-
feel.javax.swing.textClases 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 personalizacióndel
teclado.
javax.swing.text.html
Esta extensión 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.)
javax.swing.text.html.parser
Soporte para analizar gramaticalmente HTML.
javax.swing.text.rtf
Contiene soporte para documents RTF.
7
javax.swing.tree
Clases e interfaces que dan soporte al componente JTree. Este componente
se usa para mostrary manejar datos que guardan alguna jerarquía. Soporta
un alto grado de personalización sin
requerir mejoras de look-and-feel.
javax.swing.undo
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, añadiendoalgunos nuevos eventos para los nuevos componentes.
Utilizando igualmente las interfacesListener, las clases Adapter o las clases
anónimas para registrar los objetos que se encargaran de
gestionar los eventos.Algunos de los nuevos eventos son:
a.) Eventos de bajo nivel
MenuKeyEventç
MenuDragMouseEvent
b.) Eventos de alto nivel
AncestorEvent: Antecesor añadido desplazado o eliminado.
CaretEvent: El signo de intercalación 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 vínculo hipermedia ha cambiado.
8
InternalFrameEvent: Un AWTEvent que añade soporte para
objetosJInternalFrame.
ListDataEvent: El contenido de una lista ha cambiado o se ha añadido o
eliminadoun intervalo.
ListSelectionEvent: La selección 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 selección de un árbol ha cambiado de estado.
UndoableEditEvent: Ha ocurrido una operación que no se puede realizar.
1.3 Modelos de componentes Swing
En principio implementa de nuevo todos los componentes gráficos existente
en el AWT, pero en este caso con implementaciones ligeras, o lighweight,
con todas las ventajas que esto implica.
Además añade nuevas y útiles funcionalidades a estos componentes, tales
como la posibilidad de presentar imágenes o animaciones en botones,
etiquetas, listas o casi cualquier elemento gráfico.
9
Este paquete nuevo está enteramente basado en AWT y más
específicamente 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 ningún problema con la JVM de dicha
plataforma, así como con la incluida junto con los navegadores más
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
reimplementación de todos los componentes gráficos 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 están implementados sin nada de código nativo. Esto
significa que los componentes Swing pueden tener más funcionalidad que
los componentes AWT, porque no están restringidos al denominador común,
es decir las características presentes en cada plataforma. El no tener código
nativo también permite que los componentes Swing sean vendidos como
añadidos al JDK 1.1, en lugar de sólo formar parte del JDK 1.2. Incluso el
más sencillo de los componentes Swing tiene capacidades que van más allá
de lo
que ofrecen los componentes AWT.
Por ejemplo:
Los botones y las etiquetas Swing pueden mostrar imágenes en
lugar de o además deltexto.
10
Se pueden añadir o modificar fácilmente los bordes dibujados
alrededor de casicualquier componente Swing. Por ejemplo, es fácil
poner una caja alrededor de uncontenedor o una etiqueta.
Se puede modificar fácilmente el comportamiento o la apariencia de
un componente
Swing llamando a métodos.
Los componentes Swing no tienen porque ser rectangulares. Por ejemplo,
los botonespueden ser redondos.
Bordes complejos: Los componentes pueden presentar nuevos tipos de
bordes. Ademásel usuario puede crear tipos de bordes personalizados.
Otro mejora importante es que ahora todos los componentes pueden
presentar una pequeñaleyenda de texto con una breve explicación, que es
conocida como tooltip.
1.4 Descripción de algunos componentes Swing
Se da una descripción breve de cada componente por la diversidad de
métodos que contienen.
Jframe: se trata de la implementación de la clase Frame añadiendo nuevas
funcionalidades y una nueva filosofía, ya que ahora un Frame contiene
varios tipos de paneles.
Jpanel: es el nuevo contenedor básico de componentes gráficos.
JscrollPane: esta nueva implementación de un panel con barra de
desplazamiento no se limita sólo a proporcionar barras de desplazamiento
en caso de que los componentes que contengan no entren en él área de
11
visualización, sino que también se encarga de proporcionar barras de
desplazamiento a todo el resto de componentes gráficos existente.
Japplet: Se trata de la reimplementación de la clase applet para que ésta
pueda aprovechar todas las nuevas características existentes.
Jbutton: botón que además de texto puede contener imágenes en cualquier
posición en relación con el texto.
JtoggleButton: se trata de una clase que no tiene equivalentes en AWT.
Representa un botón que se mantiene presionado aunque dejemos de
presionar connuestro ratón sobre él, pero visualmente no se difiere de un
Jbutton cuando no está activado.
Jlabel: etiqueta de texto que puede contener imágenes en cualquier
posición en relación con el texto.
JtextField: Componente que sirve para conseguir la entrada de texto por
parte del usuario.
JtextPane: se trata también de un panel para visualizar texto, con la
salvedad de quetiene la capacidad de mutar en relación 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 simultáneamente.
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.
12
JcheckBox: es similar al componente checkbox que encontramos en
cualquierlenguaje y que permite mostrar al usuario si la opción está
seleccionada o no.
JpasswordField: se encuentra justo por debajo de Jtextfield en la jerarquía
decomponentes, y permite la edición de texto sin realizar un eco de los
caracterestecleados en pantalla, que son sustituidos por un carácter .
JtextArea: hereda de JtextComponent, con la diferencia es que un área de
texto permite la edición de múltiples líneas. 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 gráfica la
evolución deuna tarea. Normalmente el avance se mide en porcentaje y la
barra se acompaña de la visualización 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 más sencilla que las barras.
Además 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 opción con
setEditable(true)). Este control deSwing presenta una facilidad añadida:
cuando pulsamos la inicial de la opción que buscamos, nos lleva
directamente al primer término de la lista que empiece por dicha letra.
13
CAPÍTULO II
2.1. Layouts
Swing incorpora nuevos gestores de impresión, 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 opción en otros componentes.
OverlayLayout: Todos los componentes se añaden encima de
cada componenteprevio.
SpringLayout: El espacio se asigna en función de una serie de
restriccionesasociadas con cada componente.
ScrollPaneLayout.
ViewportLayout.
2.2. Look &Feel
Otra característica 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 código de la aplicación o
applet Swing se puede exportar un Look &Feel diferente al nativo de la
plataforma con el método UIManager.setLookAndFeel.
En las siguientes figuras podremos observar tres de los L&F de Swing en la
misma aplicación.
14
15
2.3. Nuevas características
2.3.1 Action Con objetos Action, el API Swing proporciona un soporte
especial para compartir datos y estados entre dos o más componentes que
pueden generar eventos Action. Por ejemplo, si tenemos un botón y un ítem
de menú que realizan la misma función, podríamos considerar la
Utilización 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 mayoría de los componentes Swing no-contenedores tienen modelos. Por
ejemplo, un botón (JButton) tiene un modelo (ButtonModel) que almacena el
estado del botón - cuál es su mnemónico de teclado, si está activado,
seleccionado o pulsado, etc. Algunos componentes tienen múltiples
modelos. Por ejemplo, una lista (JList) usa un ListModel que almacenalos
contenidos de la lista y un ListSelectionModel que sigue la pista de la
selecciónactual 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 más eficientemente y para
compartir fácilmente datos y estados entre componentes. Un caso común es
cuando un componente, como una lista o una tabla, contiene muchos datos.
Puede ser mucho más rápido manejar los datos trabajando directamente con
un modelo de datos que tener que esperar a cada petición de datos al
16
modelo. Se puede usar el modelo por defecto del componente o implementar
uno propio.
Las clases Model son una importante innovación que facilita la programación
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 podría controlar todo totalmente sin
ayuda del modelo de datos de ese componente.
2.5. Soporte para tecnologías asistivas
Las tecnologías asistivas para minusválidos como los lectores de pantallas
pueden usar el API de accesibilidad para obtener información sobre los
componentes Swing. Incluso sin hacer nada, un programa Swing
probablemente funcionará correctamente con tecnologías asistivas, ya que
el API de accesibilidad está construido internamente en los componentes
Swing. Sin embargo, con un pequeño esfuerzo extra, se puede hacer que
nuestro programa funcione todavía mejor con tecnologías asistivas, lo que
podría expandir el mercado de nuestro programa.
2.6. Applets
Los applets son pequeños programas Java que se incluyen en páginas Web
y cuyo código se descarga desde el sevidor para ser ejecutado localmente
por un navegador. Por tanto, para trabajar con applets es necesario conocer
algunas de las características de las páginas Web y del lenguaje en que
éstas están escritas, y el capítulo comienza exponiendo conocimientos
básicos sobre HTML. También se explicará la estructura fundamental de un
applet. Teniendo en cuenta que las applets trabajan con IGU y están guiadas
17
por eventos, el capítulo se apoya en los conocimientos aportados por otros
anteriores para la creación 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, proporcionándose así a las
upplets todas las herramientas necesarias en la programación IGU (Znterfuz
Gráfica de Usuario) y, al igual que todos los programas que trabajan con
IGU, las upplets están guiadas por eventos.
Las upplets disponen de cinco métodos que pueden sobre escribir, aunque
no es obligatorio que lo hagan, pues tienen implementaciones por defecto
que se invocarán automáticamente durante la ejecución de la misma. Cuatro
de estos métodos son proporcionados por la clase App 1 et :
publicvoidinit ( ) Inicializa el applet y es invocado por elAppletviexlev o el
navegador cuando se carga el applet.publicvoidstart ( ) Se ejecuta a
continuación de init y también cada vez que el usuario del navegador
regresa a lapágina HTML donde reside el upplet y debe contenerlas tareas
que deban llevarse a cabo en estas ocasiones.publicvoid stop() Se ejecuta
cuando el usuario abandona la páginaHTML en la que reside el
applet.publicvoiddestroy ( ) Libera todos los recursos que el applet está
utilizandoy se ejecuta antes de que el applet se descargue cuando el usuario
sale de la sesión de navegación.
18
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 travésdel método getContentPane(). La barra de
menús debe ser un objeto de la claseJMenuBar.
19
CAPITULO III
3.1. Herencia de Componentes y Contenedores
Esta sección presenta algunos de los componentes más 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 Rápida por el Código de una Aplicación 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 botón (JButton)
una etiqueta (JLabel)
El frame es un contenedor de alto nivel. Existe principalmente para
proporcionar espacio para que se dibujen otros componentes Swing.Los
otros contenedores de alto nivel más utilizados son los diálogos (JDialog) y
los applets (JApplet).
El panel es un contenedor intermedio. Su único propósito es simplificar el
posicionamiento del botón y la etiqueta.
Otros contenedores intermedios, como los paneles desplazables,
(JScrollPane) y los paneles con pestañas (JTabbedPane), típicamente
juegan un papelmás visible e interactivo en el GUI de un programa.
20
El botón y la etiqueta son componentes atómicos -- componentes que
existen no para contener otros componentes Swing, sino como entidades
auto-suficientes que representan bits de información para el usuario.
Frecuentemente, los componentes atómicos también obtienen entrada del
usuario. El API Swing proporciona muchos componentes atómicos,
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
añadimos una ventana - por ejemplo, un diálogo - la nueva ventana tendría
su propio árbol de contenidos, independiente del mostrado en esta figura
Como muestra la figura, incluso el programa Swing más sencillo tiene
múltiples niveles en su árbol de contenidos. La raíz 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.
21
todo contenedor de alto nivel contiene indirectamente un contenedor
intermedio conocido como panel de contenido. Para la mayoría 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 Cómo usar
Paneles Raíz.)Cómo regla general, el panel de contenido contiene,
directamente o indirectamente, todos los componentes visibles en el GUI de
la ventana. La gran excepción a esta regla es que si el contenedor de alto
nivel tiene una barra de menú, entonces ésta se sitúa en un lugar especial
fuera del panel de contenido.
Para añadir componentes a un contenedor, se usa una de las distintas
formas del método add. Este método tiene al menos una rgumento -- el
componente a añadir. Algunas veces se requiere un argumento adicional
para proporcionan información de distribución.
Por ejemplo, la última línea del siguiente código de ejemplo especifica que el
panel debería estar en el centro de su contenedor (el panel de contenido).
3.2. Control de Distribución
Las siguientes figuras muestran los GUIs de cinco programas, cada uno de
ellos muestra cinco botones. Los botones son idénticos, y el código de los
programas es casi idéntico. ¿Entonces por qué parecen tan diferentes?
Porque usan diferentes controladores de distribución para controlar el
tamaño y posición de los botones.
22
Control de Distribución es el proceso de determinar el tamaño y posición de
los componentes. Por defecto, cada contenedor tiene un controlador de
distribución -- un objeto que realiza el control de la distribución de los
componentes dentro del contenedor. Los componentes pueden
proporcionarle al controlador de disposición sus preferencias en cuanto a
tamaño y alineamiento, pero la última palabra la tiene el controlador de
disposición.
La plataforma Java suministra cinco controladores de disposición
comunmente utilizados: BorderLayout, BoxLayout,
FlowLayout,GridBagLayout, y GridLayout. Estos controladores de
distribución están diseñados para mostrar múltiples componentes a la vez, y
se han visto en la figura anterior. Una sexta clase proporcionada,
CardLayout, es un controlador de disposición de propósito general usadoen
combinación con otros controladores de distribución. Puedes encontrar
detalles sobre cada uno de estos seis controladores, incluyendo claves para
elegir el apropiado, en Usar Controladores de Distribución. Siempre que se
use el método add para poner un componente en un contenedor, debemos
tener en cuenta el controlador de distribución del contenedor. Algunos
23
controladores como BorderLayout requiere que especifiquemos la posición
relativa del componente en el contenedor, usando un argumento extra para
el método add. Ocasionalmente, un controlador de distribución
comoGridBagLayout requiere elaborados procesos de configuración. Sin
embargo, muchos controladores de distribución simplemente sitúan los
componentes en el orden en que fueron añadidos a su contenedor.
Todos esto probablemente suena más complicado de lo que es. Si quieres
puedes copiar el código de nuestros ejemplos de Usar Componentes Swing
o buscar el controlador de distribución individual en Usar Controladores de
Distribución. Generalmente, sólo tendrás que seleccionar el controlador de
distribución de dos tipos de contenedores: paneles de contenido (que usan
BorderLayout por defecto) y JPanel (que usan FlowLayout por defecto).
Esta sección describe algunas de las tareas más comunes de la distribución.
3.2.1. Seleccionar el Controlador de Distribución
Podemos cambiar fácilmente el controlador de distribución que usa un
contenedor. Sólo se debe llamar al método setLayout del contenedor. Por
ejemplo, aquí está el código que hace que un panel use BorderLayout.
JPanel pane = new JPanel();
pane.setLayout(new BorderLayout());
Aunque recomendamos que uses controladores de distribución, se puede
realizar la distribución sin ellos. Seleccionando una propiedad de distribución
del contenedor a nulo, podemos hacer que el contenedor no use ningún
controlador de distribución. Con este esquema, llamado posicionamiento
absoluto, podemos especificar el tamaño y posición de cada componente
dentro del contenedor. Una desventaja del posicionamiento absoluto es que
24
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 tamaños de fuente.
3.2.2. Proporcionar Consejos sobre un Componente
Algunas veces necesitamos personalizar el tamaño que un componente
proporciona al controlador de distribución del contenedor, para que el
componente se vea bien. Se puede hacer esto proporcionando los tamaños
mínimo, preferido y máximo del componente.
También podemos llamar a los métodos de selección de tamaño del
componente -- setMinimumSize, setPreferredSize, y setMaximumSize - o
podemos crear una subclase del componente que sobreescriba los métodos
apropiados -- getMinimumSize, getPreferredSize, y getMaximumSize.
Actualmente, el único controlador de distribución en la plataforma Java que
presta atención a la petición de tamaño máximo del componente es
BoxLayout.
Además de proporcionar preferencias de tamaño, podemos especificar
preferencias de alineamiento. Por ejemplo, podemos especificar que los
bordes superiores de dos componentes deberían estar alineados. Se
seleccionan los consejos de alineamiento llamando a los métodos
setAlignmentX y setAlignmentY del componente, o sobreescribiendo los
métodos, getAlignmentX y getAlignmentY del componente. Realmente
BoxLayout es el único controlador de distribución que presta atención a los
consejos de alineamiento.
25
3.2.3 Poner Espacio entre Componentes
Tres factores influyen en la cantidad de espacio entre los componentes
visibles de un contenedor.
3.2.3.1. El controlador de distribución.
Algunos controladores de distribución ponen automáticamente 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 distribución.
3.2.3.2. 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 Cómo
usar BoxLayout paraver ejemplos de uso de componentes invisibles.
3.2.3.3. Bordes vacíos
No importa cuál sea el controlador de distribución, podemos afectar la
aparente cantidad de espacio entre componentes añadiéndoles bordes. Los
mejores candidatos para los bordes vacíos son los que típicamente 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 código de dibujo. Para más información sobre los bordes
puedes ver Cómo usar Bordes.
26
3.2.4. Cómo Ocurre el Control de Distribución
Aquí hay un ejemplo de secuencia de control de distribución para un frame
(JFrame).
1.- Después de que el GUI está construido, se llama al método pack
sobre el JFrame. Esto especifica que el frame debería serde su
tamaño preferido.
2.- Para encontrar el tamaño preferido del frame, el controlador de
distribución añade el tamaño de los lados del frame al tamaño
preferido del componente directamente contenido por el frame. Esto
es la suma del tamaño preferido del panel decontenido, más el
tamaño de la barra de menú del frame, si existe.
3.- El controlador de disposición del panel de contenido es responsable
de imaginarse el tamaño preferido del panel de contenido. Por
defecto, este controlador de disposición 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 tamaño, e intenta hacerlos tan anchos como la
anchura preferida del componente más ancho, y tan altos como la
altura preferida del componente más alto. Primero, el controlador
gridlayout pregunta el panel de contenido por su inserts - el tamaño
del borde del panel de contenido, si existe. Luego, el controlador de
gridlayout le pregunta a cada componente del panel de contenido
sus tamaños preferidos, anotando la mayor anchura preferida y la
mayor altura preferida. Luego calcula el tamaño preferido del panel
de contenido.
27
4.- Cuando a cada botón se le pide su tamaño preferido, el botón
primero comprueba si el usuario ha especificado un tamaño
preferido. Si es así, reporta este tamaño. Si no es así, le pregunta a
su Aspecto y Comportamiento el tamaño preferido.
3.3. Construcción de GUI en Swing
La construcción de una GUI en Swing es muy similar a la construcción de
GUI en el AWT, exceptuando que la primera tendrá muchas más clases de
componentes con las que trabajar. A continuación se describen las clases
que se usan para la construcción de GUI y se señalan las mejoras que
Swing proporciona, comparando éstas clases con las de AWT.
3.3.1 Ventanas
Swing, al igual que AWT, proporciona una jerarquía de clases Window. Las
clases de laventana de Swing constituyen extensiones de la jerarquía de
clases Window del AWT. Laclase JWindow amplía la clase Window. La clase
JFrame amplía la clase JFrame delAWT y la clase JDialog amplía la clase
Dialog del AWT.Las clases JWindow, JFrame y JDialog difieren de sus
homólogos del AWT enque utilizan un panel de contenido separado para
agregar y diseñar componentes GUI. Este panel es un objeto Container al
que se accede a través del métodogetContentPane(). 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 ratón y del
teclado.
28
3.3.2. Menús
Los menús de Swing, al igual que las ventanas de Swing, son análogos a
sus homólogos delAWT. Las clases JMenuBar, JMenu, JMenuItem,
JCheckBoxMenuItem yJRadioButtonMenuItem se utilizan de la misma forma
que las clases MenuBar,Menu, MenuItem y CheckboxMenuItem del AWT,
sólo que con una diferenciafundamental. Las clases de menús de Swing son
todas ellas subclases de la claseJComponent y, por tanto, de la clase
Component. Esto implica que los menús de Swing, al contrario que sus
homólogos 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 característica
de los menús de Swing es la posibilidad de utilizar imágenes de iconos en
los menús. Se puede añadir 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. Diseños
Los contenedores de Swing admiten todos los diseños posibles del AWT,
entre los que seincluye el diseño null, además de admitir otros diseños
nuevos.
29
3.3.5. Iconos
Una de las características más ú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 métodos que las clases de iconos
deben implementar. La clase ImageIcon proporciona una implementación
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 java.awt.swing.border proporciona la interfaz Border, la cual
define los métodos 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. Información sobre herramientas
La clase JToolTip ofrece la posibilidad de agregar cuadros de texto
emergentes queaparecen cuando se posa el ratón sobre un componente.
Estos componentes, que admiteninformación sobre herramientas, permiten
que éstas vengan especificadas en sus respectivosconstructores. El método
setToolTipText() de la clase JComponent se puede usartambién para
especificar la información 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
30
contenedores de otros componentesSwing o del AWT. Los objetos JToolBar
típicos 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 implementación de Swing ofrece la
ventaja de poder usariconos a la vez que texto. Los constructores JLabel() y
JButton() permiten que se especifique un icono. Además, ambas clases
admiten el método 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.
Además,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 gráficas 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 múltiples en las que se
pueden ver muchos elementos.
31
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 típicamente 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 método getViewport() devuelve un objeto JViewport en el
que se pueden ir añadiendo componentes. En la mayoría de los casos, sólo
necesita agregar componentes al objeto JViewport para que uno se pueda
desplazar automáticamente por ellos.
3.3.14. Tablas
La clase JTable es otro componente de Swing que carece de equivalente en
AWT.JTable 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 TableModel.La interfaz
JTableModel define métodos para los objetos que especifican el
contenido de una tabla. La clase AbstractTableModel ofrece una
implementaciónpredeterminada de la interfaz JTableModel. Esta clase se
amplía típicamente para proporcionar una implementación personalizada de
modelo de tabla. La clase JTable ofrece la posibilidad de editar tablas. El
métodosetCellEditor() permite que un objeto de la interfaz TableCellEditor se
ha identificado como el editor de celdas de una tabla.
32
3.3.15. Árboles
Una de las clases nuevas más interesantes que ofrece Swing es la clase
JTree. Esta clase implementa una estructura en forma de árbol que se
puede usar para mostrar datos jerárquicos. La interfaz TreeNode define
métodos que tienen que implementar los nodos de un objeto JTree. La clase
DefaulMutableTreeNode proporciona una implementación predeterminada
de la interfaz TreeNode. Los árboles se crean construyendo objetos de la
interfaz TreeNode para luego añadirlos todos juntos (a través del método
add()). Cuando todos los objetos TreeNode se hayan juntado, el
objetoTreeNode resultante se pasa al constructor JTree.La presentación
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 método
setCellRenderer() de la claseJTree se usa para identificar una prestación de
árbol alternativa.
3.4. Manejo de eventos en Swing
Cada vez que el usuario teclea un carácter o pulsa un botón del ratón, 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
java.awt.swing.event define una serie de interfaces auditoras de eventos y
clases de eventos que se usan con los componentes Swing. Además,
muchos de los componentes Swing también utilizan eventos del AWT.
En la figura se muestra ejemplos de eventos:
33
Cada evento está representado por un objeto que ofrece información sobre
el evento e identifica la fuente. Las fuentes de los eventos normalmente son
componentes, pero otros tipos de objetos también pueden ser fuente de
eventos. Como muestra la siguiente figura, cada fuente de evento puede
tener varios oyentes registrados. Inversamente, un sólo oyente puede
registrarse con varias fuentes de eventos.
Figura relación evento - oyente
3.5. Swing: Cuadros de texto. Botones y casillas de activación
Este literal se analiza las etiquetas, botones, cuadros de texto, botones
toggle, casillas de activación y botones de opción en Swing. Todos ellos son
controles esenciales que ocupan gran parte de los fundamentos de Swing. A
excepción de los botones toggle, todos estos controles le deberían resultar
familiares de la programación AWT. Gran parte de la funcionalidad de estos
34
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 según 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 básicos Swing que sólo visualizan una línea de
texto. Sería razonable pensar que las etiquetas soportan varias líneas de
texto en Swing, pero sólo soportan una. Por otro lado, soportan algo que no
tienen las etiquetas AWT: imágenes. Veremos cómo utilizar la
claselmagelcon para añadir imágenes a las etiquetas. La gestión del texto en
los componentes Swing es uno de los apartados que veremos más tarde en
este libro. Ahora, iniciaremos este tema con los cuadros de texto, viendo
cómo funcionan en este capítulo y más adelante.
3.5. 2. Botones
En Swing, cualquier botón se construye con la clase AbstractButton, y en
este capítulo veremos esta clase. Como se podía esperar, los botones Swing
tienen más capacidad que sus correspondientes en AWT, incluyendo la
capacidad de visualizar imágenes, usar mnemónicos (combinación de
teclas), diseñar un botón como botón por defecto de una ventana y fijar los
márgenes y alineación del texto de un botón. Además, a un botón se le
pueden asignar múltiples imágenes para gestionar el caso en que el ratón se
mueva sobre el botón, y más cosas. Lo veremos a continuación. 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.
35
Los botones toggle son como las casillas de activación y botones de opción
que parecen botones estándar; de hecho, la clase JToggleButton, es la clase
base para las clases de estos controles en Swing, y además se pueden
instanciar objetos de esta clase directamente. Al igual que ocurre con las
casillas de activación y botones de opción, se pueden agrupar botones
toggle y usar imágenes en ellos.
3.5.3. Casillas de activación y botones de opción
AWT tiene casillas de activación y botones de opción, pero los gestiona de
diferente forma que Swing. En Swing, los botones de opción tienen su propia
clase (los botones de opción, son casillas de activación en AWT), y con ellos
se pueden usar imágenes. De hecho, veremos que cuando se utilizan las
imágenes con las casillas de activación y los botones de opción, 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. 1ang.Object Ijava.awt.Component 1 j a v a .a w t . C o n t a i n e r Ijavax.swing.JComponent
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
métodos en la tabla 1.2.
36
Constructor Descripción
Jlable Construye un objeto JLabel
sin imagen.
JLabel(1con imagen) Construye un objeto JLabelcon la
imagen indicada.
JLabel(lconimagen, int alineación
horizontal)
Construye un objeto JLabelcon la
imagen y la alineaciónhorizontal
especificadas.
JLabel(String texto) Construye un objeto JLabelcon el
texto indicado.
JLabel(String texto, /con icono, int
alineación-horizontal)
Construye un objeto JLabel con el
texto imagen y alineación horizontal
indicados.
JLabel(Stringtext0,
intalineaciónhorizontal)
Construye un objeto JLabel con el
texto y alineación horizontal
indicado.
Tabla 1.2
3.6. Swing: viewports. Desplazamiento. Deslizadores y listas
En esta sección se indica algunos temas importantes de la Swing:
Viewport, paneles de desplazamiento, deslizadores, barras de
desplazamiento y cuadros de lista. Los controles de este capítulo tienen
todos una cosa en común: 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 cómo funciona con
desplazamiento antes de trabajar con vistas y muchos otros controles de la
Swing.
37
3.6.1. Viewports
La clase JViewport es el corazón del desplazamiento en la Swing. Un
viewport es una ventana dentro de una vista, que visualizará una sección 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 imágenes.
3.6.2. Paneles de desplazamiento
Una forma común 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 explícitamente 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
38
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 hacía el AWT. Utilizaremos la
claseJScrollBar en esta sección desplazando texto en un applet. Cuando el
cuadro de desplazamiento (también 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
también 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 cómo desplazar largas listas y veremos
diversos temas de la Swing. Por ejemplo, puede realizar selecciones
múltiples de diversas formas en los cuadros de lista de la Swing. También
puede visualizar imágenes, manejar eventos de clics de ratón dobles y
triples e incluso aún más.
39
3.7. Swing: barras. Herramientas. Cuadros. Separadores y selectores
3.7.1. Cuadros combinados
Los cuadros combinados son uno de los controles más importantes en la
programación 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 también son controles
muy compactos, debido a que muestran únicamente un elemento y un botón
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 aún más 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 razón. 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 sería 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 indicación
del progreso de una operación larga. Las barras de progreso, originalmente
introducidas como mecanismo para mostrar el progreso de un programa de
instalación, se utilizan ahora para todo tipo de operaciones de consumo de
40
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 termómetro, para
mostrar visualmente cómo progresa una operación. Puede orientar las
barras de progreso tanto horizontal como verticalmente, seleccionar los
colores y etiquetas que use en ellas y manejar sus eventos. Y aún más, las
barras de progreso siguen siendo controles sencillos, ya que tienen
únicamente una función: mostrar el progreso de una tarea.
3.7.3. Selectores
Como en la AWT, la Swing soporta cuadros de diálogo. Al contrario que la
AWT, la Swing también soporta adicionalmente varios cuadros de diálogo
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 diálogo de archivos estándar. Los selectores de color
permiten al usuario seleccionar un color entre muchos. Ambos selectores
representan cuadros de diálogo estándar y Sun únicamente nos ahorra
tiempo al crearlos. Trabajaremos con ambos selectores en este capítulo.
Podemos utilizar inmediatamente en los programas el selector de color, pero
para utilizar los archivos que devuelve el selector de archivos, tendremos
41
3.7.4. Herramientas de ayuda
Las herramientas de ayuda son esas ventanas pequeñas que aparecen y
muestran un texto de explicación (como por ejemplo Descargar ahora o Abrir
nueva carpeta) cuando se detiene el ratón 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 ratón 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 menús para dividir elementos de menú en agrupaciones lógicas, podrá
utilizar separadores en componentes JApplet y JFrame como cualquier otro
control.
42
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 propósito. Puede utilizar la
claseJWindow para crear una ventana simple; de hecho, no es más que un
rectángulo blanco. Aunque puede añadir bordes y controles a los objetos
JWindow, normalmente utilizará la clase JFrame para crear ventanas que
presente al usuario.Las clases JDesktopPane y JInternalFrame son nuevas
en Swing, aunquejuntas representan algo que ha llegado a ser muy común
en las IU: una interfaz de documentos múltiple. Los objetos de la clase
JDesktopPane presentan un espacio en el que puede visualizar múltiples
marcos internos de la clase JInternalFrame. Por ejemplo, una aplicación de
procesamiento de textos podría permitir al usuario abrir varias vistas del
mismo documento, o de múltiples 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 también son componentes de poco peso, derivados de
JLayeredPane. Puede añadir ventanas de marcos internos a las capas
seleccionadas de un panel de escritorio.
3.8.2. Cuadros de diálogo
La Swing proporciona bastante soporte para cuadros de diálogo con la clase
JOptionPane. Mediante el uso de métodos de esta clase, puede visualizar
toda clase de cuadros de diálogo (cuadros de diálogo de mensaje, cuadros
de diálogo de confirmación, cuadros de diálogo de entrada y muchos
43
más).Como verá aquí, es sencillo crear cuadros de diálogo utilizando
JOptionPane. Además de JOption Pane, la Swing también posee la clase
JDialog, que puede utilizar como base para sus propias clases de cuadro de
diálogo personalizadas.
3.9. Creación de paquetes. Interfaces. Archivos JAR y Java Beans
3.9.1. Crear un paquete
La creación de los paquete es debido que la instauración de las clases se las
coloca de forma desordenada. ¿Cómo se puede resolver este desorden? La
solución está en la división 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 jerarquía de directorios. De hecho, los paquetes Javaf ueron
diseñados originalmente para reflejar esa organización de archivos. Puede
distribuir archivos de clase en una jerarquía de directorios y permitirque Java
sepa lo que sucede con los paquetes. Por ejemplo, si se tiene un paquete
llamado package, que contiene una claseapp.class, el archivo de clase iría
en un directorio llamado package, como sigue:
package -app
Múltiples archivos de clase en el mismo paquete irán en el mismo directorio:
packagel
-app
-app3
44
Como el directorio package se encuentra en una localización 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 código. Aquí tiene
un ejemplo donde creamos app.class e indicamos que forma parte de
packagel utilizando la sentencia
package: packagepackagel; publicclasc app public static void main (String args) System.out.println ("Hola desde Java!");
Una vez compilada app.class y almacenada en el directorio packagel,
podemos entonces importar la clase app en el código con sentencias como
lasiguiente, como haríamos con cualquier otro paquete Java:
importpackagel.*;
importpackagel.app;
La herramienta de tiempo de ejecución de Java también conoce los
paquetes; por tanto, debido a que la clase app.class es una aplicación en sí,
podemos ejecutar esta clase con una línea de comando que especifique el
paquete de la clase app y utilizando un punto (.) para el separador de
directorios:
c:\> java packagel.app
De hecho, el separador de paquetes punto es útil cuando creamos paquetes
dentro de paquetes; examine el siguiente tema para más detalles.
45
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 código, basta utilizar
el separador de paquetes punto.
ejemplo:
package packagel.package2; public class app I public static void rnain (String[l args) { Systern.out.println ("iHola desde Java! " ) ;
Ahora puede importar la clase app en su código con sentencias como éstas:
import packagel.package2.*;
irnport packagel.package2.app;
Debido a que en este caso app ya es una aplicación clase, también puede
ejecutarla como sigue, especificando la estructura de directorios de paquete:
c:\> java packagel.package2.app
;Hola desde Java!
3.9.3 Crear una interfaz
Cuando creamos una interfaz, especificamos los métodos de la interfaz y
cuando la implementamos, proporcionamos el código de estosmétodos.Aquí
tiene un ejemplo en el que creamos una interfaz llamada Printem quetiene
46
un método: 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 métodos 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 ( ystam.out.println(HoladesdeJavaln);
3.9.4. Implementación 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 métodos,
printText 1 y printText2: interfacePrintem voidprintTextl(1; void printText2 ( ) ;
A continuación, se crea una nueva clase, class1, que implementa la interfaz
pero únicamente define un método, printText2 (observe que debido a que
47
estaclase no es una implementación completa de la interfaz, debemos
declararlaabstracta):
interfacePrintem ( voidprintTextl ( ) ; void printText2 ( ) ; abstract class classl implements Printem { public void printTextl0 I system.out.println("~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 System.out.println(" ¡Holadesde Java!"); class class2 extends classl f public void printText20 System.out.println(~ola desde los interfaces Java!");
48
3.9.5. Crear un archivo JAR
El uso de los archivos JAR es por el aumento archivos de clase están
aumentando de tamaño 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 conexión en
vez de nuevas conexiones para cada nuevo archivo, lo que puede mejorar
los tiempos de descarga. También 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 vacío en la salida estándar.
t. Muestra la tabla de contenidos en la salida estándar.
x file. Extrae todos los archivos o sólo los nombres de archivos. caso,
únicamente se extraen los archivos especificados.
49
f. El segundo argumento especifica un archivo JAR para trabajar.
v. Genera una salida "duplicada" en stderr.
m. Incluye información manifiesta de un archivo manifest especificado.
O. Indica "sólo almacenar", sin utilizar compresión ZIP
M. Especifica que un archivo manifest no debería crearse por las
entradas.
u. Actualiza un archivo JAR existente añadiendo o cambiando los
archivos del manifest.
-C. Cambia los directorios durante la ejecución del comando jar. Por
Ejemplo, jar añadiría todos los archivos dentro del directorio clases, pero
no el propio directorio clases, al archivo jarfile.jar.
Truco: Puede utilizar un argumento comenzando por el carácter para
especificar un archivo que contiene argumentos adicionales Estos
argumentos se insertan en la líneas en la posición del argumento
@filen:"@"
S, con
Aquí se tiene el uso típico 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 sitúan en el
archivo llamado jarfile.jar. La herramienta JAR genera automáticamente un
archivo manifest predeterminado y es siempre la primera entrada del archivo
Java (por defecto, se llama META-INF/MANIFEST.MF). Si tiene un archivo
manifest y quiere que utilice la herramienta jar para un nuevo archivo JAR,
se puede utilizar la opción -m y especificarlo como sigue:
c:\>jar cm£ manifest.m£t jarfile.jar *.class
50
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. jarmanifest.mft *.class
Observe también 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 jarfile.jar manifest.mft * . *
Si los nombres de archivo que quiere empaquetar incluían 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 información empaquetada para la visualización
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/MANIFEST.MF
applet.class
jpanel.class
newButton.class
testPanel.class
51
3.9.7. Extraer archivos desde un archivo JAR
Cuando se programa se utiliza los archivos JAR paraarchivar los archivos;
pero, ¿cómo 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,también
creamos su estructura original de directorio. En este caso, la herramientajar
desempaqueta los archivos de clase y también crea un directoriollamado
META-INF donde coloca el archivo predeterminado manifest
MANIFEST.MF. También podemos extraer archivos especificando sus
nombres. Aquí tieneun ejemplo en el que extraemos applet.class:
c: \> jar xfjarfile. jarapplet.class
3.10. Swing Utilities
clasajavax.swing.SwingUtilities
Estos son sólo 2 de los 36 métodos de utilidad genérica definidos en
SwingUtilities, que se dividen en siete grupos: métodos de cálculo, métodos
de conversión, métodos de accesibilidad, métodos de recuperación, métodos
relacionados con la multitarea y los eventos, métodos para los botones del
ratón, y métodos de disposición/dibujo/UI. Todos estos métodos son
estáticos y se describen muy brevemente en esta sección (para una
comprensión más avanzada vea el código fuente de SwingUtilities.java).
52
3.10.1. Métodos de cálculo
Rectangle[] computeDifference(RectanglerectA, RectanglerectB):
devuelvelas regiones rectangulares que representan la porción de rectA que
no intersecciona con rectB.RectanglecomputeIntersection(int x, int y,
intwidth, intheight,Rectangledest): devuelve la intersección de dos áreas
rectangulares. La primera región sedefine con los parámetros de tipo int y la
segunda por con el parámetro de tipo Rectangle. Elparámetro de tipo
Rectangle se modifica y se devuelve como resultado del cálculo de forma
queno se tiene que instanciar un nuevo Rectangle.
RectanglecomputeUnion(int x, inty, intwidth, intheight, Rectangledest):
devuelve la unión de dos áreas rectangulares. La primera región se define
con losparámetros de tipo int y la segunda por con el parámetro de tipo
Rectangle. El parámetro detipo Rectangle se modifica y se devuelve como
resultado del cálculo de forma que no se tieneque instanciar un nuevo
Rectangle.
isRectangleContainingRectangle(Rectangle a, Rectangle
b): devuelve true si el Rectangle a contiene completamente al
Rectangleb.computeStringWidth(FontMetricsfm, Stringstr): devuelve la
achura del String de acuerdo al objeto FontMetrics.
3.10.2. Métodos de conversión
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
53
al sistema de coordenadas de source, y se pone source como fuente del
evento. Siambos son null el MouseEvent devuelto es idéntico al evento que
se pasa.Point 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 idéntico al Point pasado.
Point convertPoint(Componentsource, int x, int y, Componentdestination):
este método funciona igual que el anterior método convertPoint() exceptoque
recibe parámetros de tipo int que representan las coordenadas del Point a
convertir en lugar de una instancia de
Point.RectangleconvertRectangle(Componentsource, RectangleaRectangle,
Componentdestination): devuelve un Rectangle convertido del sistema de
coordenadasdel componente source al sistema de coordenadas del
componente destination. Este métodose 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 dado.voidconvertPointToScreen(Point p,
Component c): convierte el Point dado en el sistema de coordenadas del
Component dado al sistema de coordenadas de la pantalla.
54
3.10.3. Métodos 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
javax.accessibility.Accessible.AccessiblegetAccessibleChild(Component c,
int i): devuelve el décimo hijoAccessible del Component dado.int
getAccessibleChildrenCount(Component c): devuelve el número 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
Accessible.AccessibleStateSetgetAccessibleStateSet (Component c):
devuelve el conjunto de A ccessibleStates que no están activos para el
Component dado.
3.10.4 Métodos de recuperación
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 ancestormás 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
métodos setName() y getName ()respectivamente.)
55
ContainergetAncestorOfClass(Class c, Componentcomp): devuelve el
ancestro máscercano del Component dado que es una instancia de c. En
otro caso se devuelve null.ComponentgetDeepestComponentAt
(Componentparent, int x, int y): devuelve elhijo más profundo del Component
dado que contiene el punto (x,y) en términos del sistema decoordenadas del
Component dado. Si el Component no es un Container este método
terminainmediatamente.
RectanglegetLocalBounds(Component c): devuelve un Rectagle que
representa los límites 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 método devuelve el último ancestro que es
un Applet.JRootPanegetRootPane(Component c): devuelve el primer
JRootPane que es padre de c, o c si es un
JRootPane.WindowwindowForComponent (Component c): devuelve el
primer ancestro de c que es una Window. En otro caso devuelve
null.booleanisDescendingFrom(ComponentallegedDescendent,
ComponentallegedAncestor): devulve true si allegedAncestor contiene a
allegedDescendent.
3.10.5. Métodos relacionados con la multitarea y los eventos
voidinvokeAndWait(Runnableobj): envía el Runnable a la cola de despacho
de eventos y bloquea el hilo actual.voidinvokeLater(Runnableobj): envía el
Runnable a la cola de despacho de eventos y continúa.
booleanisEventDispatchThread(): devuelve true si el hilo actual es el hilo de
despacho de eventos.
56
3.10.6. Métodos para los botones del ratón
booleanisLeftMouseButton(MouseEvent): devuelve true si el MouseEvent
correspondea una pulsación del botón izquierdo del ratón.
booleanisMiddleMouseButton(MouseEvent): devuelve true si el
MouseEventcorresponde a una pulsación del botón de en medio del ratón.
booleanisRightMouseButton(MouseEvent): devuelve true si el
MouseEventcorresponde a una pulsación del botón derecho del ratón.
3.10.7 Métodos de disposición/dibujo/UIString
layoutCompoundLabel (FontMetricsfm, Stringtext, iconicon,
intverticalAlignment, inthorizontalAlignment, intverticalTextPosition,
inthorizontalTextPosition, RectangleviewR, RectangleiconR,RectangletextR,
inttextIconGap): Este método 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 cabría. Los RectanglestextR e iconR se modifican para reflejar
la nuevadisposición, y se devuelve el String resultante de esta
disposición.StringlayoutCompoundLabel (JComponent c, FontMetricsfm,
Stringtext,iconicon, intverticalAlignment, inthorizontalAlignment,
intverticalTextPosition, inthorizontalTextPosition, RectangleviewR,
RectangleiconR, RectangletextR, inttextIconGap): este método es idéntico al
anterior, pero recibe el componente destino para comprobar si él la
orientación 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
57
dado en el contexto gráfico dado, usando el rectángulo definido por los
cuatro parámetros de tipo int como área de recorte. El Container se usa para
que actúe como el padre del Component de forma que cualquier petición de
validación sucedan en ese componente no se propaguen por el árbol de
ancestros del componente al que pertenece el contexto gráfico dado. Esta es
la misma metodología 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 idéntica al método anterior, pero
recibe un Rectangle como parámetro en lugar de cuatro
ints.voidupdateComponentTreeUI(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.
58
4. Conclusiones
A lo largo de este trabajo investigativo se han comprobado las similitudes y
diferencias entre ambosAPI’s para la creación de interfaces gráficas.
Básicamente, Swing viene a ser una ampliación y revisión de AWT. Ambas
bibliotecas de clases comparten aspectos como el manejo de eventos,
jerarquías similares de componentes, la representación de gráficas básicas e
imágenes... Además, Swing añade nuevas funcionalidades a los antiguos
componentes, añade 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 construcción de software de las buenas prácticas
de la ingeniería del software, que facilitan conceptos tan útiles como la
reutilización, 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 prácticas de la ingeniería del software y de
la orientación a objeto.
59
5. Recomendaciones
En la aplicación sólo debe haber un único JFrame, correspondiente a la
aplicación 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 jerarquía
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 también sea modal y sea hijo del anterior. Si
pones visibles a la vez dos JDialog modales y no son el uno hijo del otro,
tendrás 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, podrás 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 botón, al
apretarlo, visualiza un JDialog, no hagas un new de JDialog cada vez que
pulsas el botón. Es mejor hacer sólo 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, además de lo habitual, hay
como mínimo que llamar al método dispose() de dicha ventana -cosa que
mucha gente no sabe- , para que el sistema de eventos de teclado y ratón
60
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 sólo debía haber un JFrame principal, no tenía sentido
liberarlo.
Los layouts para situar componentes no son tan complicados, sólo 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.
61
6. Bibliografía
A. “Java Swing”
http://jungla.dit.upm.es/~santiago/docencia/apuntes/Swing/
B. Sun “The Swing Tutorial”
http://java.sun.com/docs/books/tutorial/uiswing
C. Sun, Traductor : Juan Antonio Palos “Swing y JFC”
http://programacion.com/java/tutorial/swing/
Universidad de Navarra “Aprenda Java como si estuviera en primero”
San Sebastián,Marzo 1999
D. Universidad de Las Palmas de Gran Canaria “Tutorial de Java –
AWT”http://www.ulpgc.es/otros/tutoriales/java/Cap4/awt.html
62
Anexos.
Anteproyecto
INTRODUCCIÓN.
Esta Investigación pretende ser una introducción a Swing, con la que se
intenta mostrar una visión general sobre herramientas de interfaces gráficas
de usuario, y más concretamente, sobre el desarrollo de éstas con Java y
sus APIs, lo que se pretende mostrar las ventajas que ofrece éste tipo de
programación.
En primer lugar, se realiza una introducción 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 introducción, se describirá brevemente el paquete
Swing, para dar una idea de la jerarquía de componentes que se puede
utilizar con Swing y de sus utilidades.
También 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, sería muy extenso hacer una
descripción detallada.
63
DATOS INFORMATIVOS.
2.1.1. Tema General
ADMINISTRADOR DE DISEÑO DE JAVA
2.1.2. Tema Específico.
COMPONENTE SWING
Universidad.
Universidad Católica de Cuenca
Unidad Académica de Ingeniería de
Sistemas, Eléctrica y Electrónica
Facultad de Ingeniería de Sistemas.
Investigador.
Tnlg. Anl. Freddy E. Quezada B.
Director.
Ing. Ali Méndez.
Lugar.
Universidad Católica de Cuenca.
Fecha.
10 de Octubre del 2011.
LUGARES DE CONSULTA.
http://zarza.usal.es/~fgarcia/docencia/poo/02-03/trabajos/S2T4.pdf
http://www.programacion.com/articulo/swing_y_jfc_java_foundation_classes_94
http://jungla.dit.upm.es/~santiago/docencia/apuntes/Swing/
http://www.programacion.net/java/tutorial/swing/
http://www.programacionfacil.com/java/indice.htm
JUSTIFICACIÓN Y PROPUESTA.
64
4.1. ANÁLISIS DE LA SITUACIÓN ACTUAL.
La programación en Java ha comenzado a despegar simplemente debido a
su capacidad de hacer programas en múltiples plataformas. Esto es no sólo
cierto para computadoras portátiles pero Java también está presente en las
PC de bolsillo e incluso en los teléfonos móviles estándar. Debido a esto,
existe un gran interés en programar con Java y aprovechar este gran y
creciente mercado.
La programación en Java significa que tener las herramientas adecuadas a
fin de terminar proyecto rápido y eficientemente. Una de las herramientas
esenciales es el componente de GUI (interfaz gráfica de usuario). Esto
permite agregar fácilmente el componente gráfico sin la mayor parte de la
programación necesaria. En esta categoría, hay dos de las que puedes
elegir. La primera es la AWT (AbstractWindowToolkit) y el segundo es el
swing, que apareció más tarde.
Estos kits de herramientas tienen sus propias ventajas y desventajas que los
hacen adecuados para los distintos tipos de necesidades de programación.
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 código Java puro, haciéndolo muy portátil con el costo de
velocidad y rendimiento a través de plataformas.
4.2. PROPUESTA.
Dar a conocer a través de métodos investigativos la aplicación y uso de de
las herramientas del lenguaje Java para un diseño y desarrollo de
aplicaciones dedicadas al usuario.
65
OBJETIVOS.
5.1. Objetivo General.
Analizar los componentes de Java swing
5.2 Objetivos Específicos:
Lograr conocimiento de los paquetes de Swing de java.
Ilustrar al usuario con guía de uso que se refiere a la aplicación de
componentes dedicados a la interface de usuario
Adquirir competencias para la aplicación 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
66
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 javax.swing. Esta versión de lasJFC fue publicada como
JFC 1.1, que algunas veces es llamada 'Versión Swing'. El API delJFC 1.1
es conocido como el API Swing.
Swing constituye la característica más importante que se ha añadido a la
plataforma 1.2, como Sun ha preferido llamarla, Java2. Con esta última
incorporación por fin se completa totalmente la parte gráfica de la
programación en Java, ofreciendo al programador acceso a todas las
características existentes en un entorno gráfico actual, así como un conjunto
de componentes gráficos completo y fácilmente ampliable con el que
construir la interfaz gráfica de usuario, o GUI, de nuestras aplicaciones y
applets, de una forma totalmente transparente e independiente de la
plataforma en la que ejecutemos nuestro código.
7.2. Marco Conceptual.
Swing es una de las mejoras principales que ha experimentado el JDK en su
versión 1.2 con respecto a la versión 1.1, y representa la nueva generación
de AWT. También es una de las API de las Clases de Fundamentos de Java
(JFC), lo cual es el resultado de un esfuerzo de colaboración muy grande
entre Sun, Netscape, IBM y otras empresas. Lo que da a Swing su
importancia es el poder que ofrece para desarrollar interfaces gráficas de
usuario (GUI) para applets y aplicaciones. La cantidad y calidad de los
controles GUI que ofrece Swing no tiene rival en ningún otro juego de
herramientas GUI.
67
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 más 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
también la posibilidad de cambiar fácil y rápidamente el aspecto y sensación
(L&F) de un único componente o grupo de componente. Esta posibilidad,
que se conoce como aspecto y sensación conectables (PL&F), es un sello
distintivo de Swing
TEMARIO.
I INTRODUCCIÓN
CAPITULO I
Swing
1.1 historia
1.2 Ventajas - Desventajas
1.2 Eventos Swing
1.3 Modelos de componentes Swing
1.4 Descripción de algunos componentes Swing
CAPITULO II
Layouts
2.1. Look &Feel
2.2. Otras nuevas características
2.3. Action
2.4. Modelos de datos y estados separados
2.5. Soporte para tecnologías asistivas
2.6. Applets en Swing
CAPITULO III
3.1. Herencia de Componentes y Contenedores
3.2. Control de Distribución
3.3. Construcción de GUI en Swing
68
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 activación
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. Creación de paquetes. interfaces. archivos JAR y Java Beans
4. Conclusiones
4.2 Recomendaciones
I. Bibliografía
II. Anexos.
69
ESTRATEGIAS METODOLÓGICAS.
Etapa de
investigación
Métodos Técnicas Resultados
Empíricos Teóricos
ANÁLISIS DE LA SITUACIÓN ACTUAL
Analítico – sintético.
Revisión por Internet
Bases teóricas de la Investigación.
PROPUESTA DE SOLUCIÓN
Histórico- Lógico Revisión Documental
Recolección de Información
Analítico – sintético.
Hipotético – Deductivo
Observación
Investigar los elementos del paquete swing
de java
MARCO REFERENCIAL
Y CONCEPTUAL
Analítico – sintético
Sistémico
Propuesta fundamentada Teóricamente.
70
Instrumentos.
Las Herramientas que se utilizarán en el Desarrollo de la Investigación son:
El Internet, constituye la fuente y base fundamental de donde se extraerá
la Información requerida.
El programa Netbeans 7.0, el mismo que nos ofrecerá mayor soporte
Técnico para el desarrollo del presente proyecto.
RECURSOS.
Recursos Humanos.
Catedráticos del Plantel.
Autor.
Recursos Tecnológicos.
Uno de los Recursos Tecnológicos importantes es la Red de Redes (el
Internet), la cual ofrece la mayor parte de la Información acerca de estas
herramientas
Recursos Materiales.
Computadora portátil
Netbeas 7.0 (win - linux)
Útiles de oficina
Internet
71
Recursos Económicos.
Para la realización del Presente Trabajo se destina los siguientes rubros:
Detalle Rubro
Equipo Portátil $ 600
Útiles de Oficina $ 35
Consumo de internet prepago $ 35
Impresiones y Empastado $ 60
TOTAL 730
BIBLIOGRAFÍA.
“Java Swing” http://jungla.dit.upm.es/~santiago/docencia/apuntes/Swing/
Sun “The Swing Tutorial” http://java.sun.com/docs/books/tutorial/uiswing
Sun, Traductor : Juan Antonio Palos “Swing y JFC”
http://programacion.com/java/tutorial/swing/
Universidad de Navarra “Aprenda Java como si estuviera en primero” San
Sebastián, Marzo 1999
Universidad de Las Palmas de Gran Canaria “Tutorial de Java - AWT”
http://www.ulpgc.es/otros/tutoriales/java/Cap4/awt.html
72
CRONOGRAMA
SEMANA 1 SEMANA 2 SEMANA 3 SEMANA 4 SEMANA 5 SEMANA 6 SEMANA 7 SEMANA 8
LUN 17 A
VIE 21 DE
OCT
LUN 24 A
VIE 28 DE
OCT
LUN 31
OCT A
VIE 21 DE
NOV
LUN 7 A
VIE 11 DE
NOV
LUN 14 A
VIE18 DE
NOV
LUN 21 A
VIE 25 DE
NOV
LUN 28
NOV A
VIE 2 DE
DIC
LUN 05 A
VIE 09 DE
DIC
CAPITULO I X X X X
CAPITULO II X X X
CAPITULO III X X X X X
