Programacin Orientada a Objetos

Junio, 2005

Programacin con Swing

Noelia Mndez Fernndez
Jose Luis Garca Valiente

Departamento de Informtica y Automtica

Universidad de Salamanca

Jose Luis Garca y Noelia Mndez

RESUMEN
Este documento pretende hacer una descripcin de Swing, una de las APIs de Java, que se
incluye en las JFC 1.1.
En primer lugar se hace una introduccin a Swing, describiendo el entorno en el que se
encuentra, tratando por ello algunos aspectos relacionados con AWT, JFC 1.1 y JDK 1.2.
Adems, se realiza una breve descripcin de las interfaces de usuario.
Posteriormente, se describe Swing con ms profundidad, analizando su arquitectura y sus
componentes principales.
A continuacin, se hace una pequea introduccin al manejo de eventos en Swing y a los
Applets.
Finalmente, se analiza por qu es til convertir una aplicacin a Swing y se dan unas
indicaciones para facilitar la conversin.
Y por ltimo, se explican varios ejemplos de aplicaciones con Swing.

ABSTRACT
This document tries to make a description of Swing, one of the APIs of Java, which is included
in JFC 1.1.
First of all, this document makes an introduction to Swing, describing the IDE where it is,
dealing with some aspects related to AWT, JFC 1.1 and JDK 1.2. Besides, a short description
about the interfaces of user is made.
Afterwards, Swing is described more deeply, analysing its architecture and main
components.
Later, a small introduction about the management of events in Swing and the Applets is
made.
Eventually, why is useful to convert an application into Swing is analysed and some
indications are given to make easy the conversion.
Finally,

some

examples

about

applications

with

Swing

are

explained.

Programacin con Swing

LISTA DE CONTENIDOS
-

Introduccin al trabajo ................................................................................................. Pg. 6

Introduccin a Swing .................................................................................................. Pg. 6

Introduccin a las interfaces de usuario y el AWT ...................................................... Pg. 6

Swing, el AWT y las JFC............................................................................................. Pg. 7

La jerarqua de componentes Swing ............................................................................ Pg. 8

Panormica del paquete Swing .................................................................................... Pg. 8

Construccin de GUI en Swing .................................................................................. Pg. 10

Manejo de eventos en Swing ...................................................................................... Pg. 12

Applets en Swing ........................................................................................................ Pg. 13

Conversin a Swing .................................................................................................... Pg. 13

Ejemplos ..................................................................................................................... Pg. 14

Conclusiones ............................................................................................................... Pg. 24

Bibliografa ................................................................................................................. Pg. 26

Jose Luis Garca y Noelia Mndez

LISTA DE FIGURAS

Figura 1: Swing, IFC, JFC y AWT .............................................................................. Pg. 7

Figura 2: Jerarqua de componentes Swing ................................................................. Pg. 9

Figura 3: Ejemplos de eventos .................................................................................... Pg. 12

Figura 4: Relacin entre eventos y oyentes................................................................. Pg. 13

Figura 5: Ejemplo de ventana con pestaas ................................................................ Pg. 15

Figura 6: Componentes de mens............................................................................... Pg. 17

Figura 7: rbol de herencia de las clases relacionadas con mens............................. Pg. 17

Figura 8: Deteccin de eventos................................................................................... Pg. 19

Figura 9: Men personalizado..................................................................................... Pg. 22

Figura 10: Otra distribucin de un men .................................................................... Pg. 22

Programacin con Swing

LISTA DE TABLAS
-

Tabla 1: Crear y configurar un TabbedPane ............................................................... Pg. 15

Tabla 2: Insertar, Eliminar, Encontrar y Seleccionar Pestaas ................................... Pg. 16

Tabla 3: Cambiar la Apariencia de las Pestaas ......................................................... Pg. 16

Tabla 4: Crear y configurar barras de mens .............................................................. Pg. 22

Tabla 5: Crear y Rellenar Mens ................................................................................ Pg. 22

Tabla 6: Crear y Rellenar Mens Desplegables.......................................................... Pg. 23

Tabla 7: Implementar tems de Men ......................................................................... Pg. 23

Jose Luis Garca y Noelia Mndez

1.

INTRODUCCIN AL TRABAJO

Este trabajo pretende ser una pequea introduccin a Swing, con la que se intenta mostrar al
lector una visin general sobre el mundo de las interfaces grficas de usuario, y ms
concretamente, sobre el desarrollo de stas con Java y sus APIs. Puesto que tan slo se trata de
una breve introduccin al tema, lo que se pretende es captar la atencin del lector y mostrar las
ventajas que ofrece ste tipo de programacin.
En primer lugar, se realiza una introduccin a Swing, el AWT y las interfaces de usuario,
tratando de sta forma de centrar al lector en el tema a tratar.
Una vez realizada dicha introduccin, se describir brevemente el paquete Swing, para dar
una idea de la jerarqua de componentes que se puede utilizar con Swing y de sus utilidades.
Tambin se mencionar el manejo de eventos en Swing, as como los Applets, aunque de
una forma muy superficial, ya que debido a la gran amplitud de variaciones que pueden darse,
sera muy extenso hacer una descripcin detallada.
A continuacin, se exponen los motivos por los que resulta interesante convertir las
aplicaciones a Swing.
Para terminar, se examinarn ms concretamente dos de las clases que ofrece Swing: la
clase Tabbed Pane y la clase Menu.
Para aquellas personas que despus de leer este documento se sientan atradas por la
construccin de interfaces grficas de usuario con Swing, al final del documento se incluyen las
referencias, para facilitar la bsqueda de informacin a todo el que desee profundizar en el
tema.

2.

INTRODUCCIN A SWING

Swing es una de las mejoras principales que ha experimentado el JDK en su versin 1.2 con
respecto a la versin 1.1, y representa la nueva generacin de AWT. Tambin es una de las API
de las Clases de Fundamentos de Java (JFC), lo cual es el resultado de un esfuerzo de
colaboracin muy grande entre Sun, Netscape, IBM y otras empresas. Lo que da a Swing su
importancia es el poder que ofrece para desarrollar interfaces grficas de usuario (GUI) para
applets y aplicaciones. La cantidad y calidad de los controles GUI que ofrece Swing no tiene
rival en ningn otro juego de herramientas GUI.
El origen de los controles GUI que presenta Swing lo encontramos en las Clases de
Fundamentos de Internet de Netscape (IFC). Los componentes Swing van ms all de las IFC,
hasta el punto de que no hay un parecido apreciable entre los componentes Swing y los de las
IFC. Swing ofrece tambin la posibilidad de cambiar fcil y rpidamente el aspecto y sensacin
(L&F) de un nico componente o grupo de componente. Esta posibilidad, que se conoce como
aspecto y sensacin conectables (PL&F), es un sello distintivo de Swing.

3.

INTRODUCCIN A LAS INTERFACES DE USUARIO Y EL AWT

Para poder apreciar la importancia de Swing, haremos primero una introduccin a las interfaces
de usuario y al AWT.
El interfaz de usuario es la parte del programa que permite a ste interactuar con el usuario.
Las interfaces de usuario pueden adoptar muchas formas, que van desde la simple lnea de
comandos hasta las interfaces grficas que proporcionan las aplicaciones ms modernas. El
interfaz de usuario es el aspecto ms importante de cualquier aplicacin. Una aplicacin sin un
interfaz fcil, impide que los usuarios saquen el mximo rendimiento del programa. Java
proporciona los elementos bsicos para construir interfaces de usuario a travs del AWT, y
opciones para mejorarlas mediante Swing, que s permite la creacin de interfaces de usuario de
gran impacto y sin demasiados quebraderos de cabeza por parte del programador.
6

Programacin con Swing

Al nivel ms bajo, el sistema operativo transmite informacin desde el ratn y el teclado

como dispositivos de entrada al programa. El AWT fue diseado pensando en que el
programador no tuviese que preocuparse de detalles como controlar el movimiento del ratn o
leer el teclado, ni tampoco atender a detalles como la escritura en pantalla. El AWT constituye
una librera de clases orientada a objeto para cubrir estos recursos y servicios de bajo nivel.
Debido a que el lenguaje de programacin Java es independiente de la plataforma en que se
ejecuten sus aplicaciones, el AWT tambin es independiente de la plataforma en que se ejecute.
El AWT proporciona un conjunto de herramientas para la construccin de interfaces grficas
que tienen una apariencia y se comportan de forma semejante en todas las plataformas en que se
ejecute. Los elementos de interfaz proporcionados por el AWT estn implementados utilizando
toolkits nativos de las plataformas, preservando una apariencia semejante a todas las
aplicaciones que se creen para esa plataforma. Este es un punto fuerte del AWT, pero tambin
tiene la desventaja de que un interfaz grfico diseado para una plataforma, puede no
visualizarse correctamente en otra diferente. Estas carencias del AWT son subsanadas en parte
por Swing, y en general por las JFC.

4.

SWING, EL AWT Y LAS JFC

JFC
AWT
IFC

Swing

Figura 1 Swing, IFC, JFC y AWT

La Figura 1 muestra la relacin existente entre Swing, el AWT y las JFC. Las JFC subsumen y
amplan el AWT original, y constan de las siguientes API principales:
-

AWT.

Swing.

Java 2D.

Drag-and-Drop.

Accessibility.

Aunque Swing est separado del AWT, se implementa en trminos de clases AWT bsicas.
El AWT proporciona la interfaz entre el sistema de ventanas nativo subyacente y los
componentes GUI de Java. Swing utiliza esta interfaz, pero no se apoya en componentes del
AWT para hacer uso de objetos nativos. En lugar de ello, los componentes Swing estn escritos
en Java puro. Esto ofrece ventajas significativas. Permite a los componentes Swing ser
independientes del sistema de ventanas nativo, lo cual implica que pueden ejecutarse en
cualquier sistema de ventanas que admita el AWT. Tambin permite a los componentes Swing
ser independientes de cualquier limitacin de los sistemas de ventanas nativos. Esta
independencia permite a Swing controlar y adaptar su aspecto y sensacin (de ah la aparicin
de PL&F).
Entre los componentes nuevos que incluye Swing hay desde paneles tabulados y bordes
estilizados hasta barras deslizadoras y efectos giratorios. Estos componentes nuevos, en s
mismos, hacen que Swing constituya un agregado de primera magnitud a la API Java. La galera
de componentes Swing, que se encuentra en http://java.sun.com/products/jfc/swingdoc-

Jose Luis Garca y Noelia Mndez

current/comp_gal.html, muestra algunos de ellos. Swing tambin incorpora un programa de

demostracin llamado SwingSet.
Swing tambin ofrece una implementacin de Java puro de muchos de los componentes
tradicionales del AWT. Estos componentes tienen la misma funcionalidad que los componentes
del AWT y todas las ventajas de Swing. Swing es compatible con el AWT, y los componentes
Swing se pueden utilizar con los componentes del AWT. Sin embargo, los compenentes Swing
slo se pueden usar con el modelo de eventos del JDK 1.1. No admiten el modelo de eventos
del JDK 1.0.
La arquitectura PL&F de Swing facilita la personalizacin de tanto del aspecto como del
comportamiento de cualquier control Swing o de cualquier grupo de estos controles. Swing
tambin incorpora varios L&F predefinidos, entre los que reincluye el Metal L&F
predeterminado, el Motif L&F y el Windows L&F. Los L&F para Macintosh y otras
plataformas tambin se estn desarrollando.

5.

LA JERARQUA DE COMPONENTES SWING

Swing consta de nueve paquetes y cientos de clases e interfaces. No obstante, la clase

JComponent de java.awt.swing es la clase superior de la jerarqua de componentes
Swing. La clase JComponent es una subclase de la clase java.awt.container y, por
tanto, es a la vez un componente y un contenedor en el sentido del AWT. Dado que
JComponent es la superclase de todos los componentes Swing, todos ellos descienden de
java.awt.Container y java.awt.Component.
La Figura 2 muestra la jerarqua de componentes Swing. La primera cosa que se debe tener
en cuenta es que todos los componentes empiezan por la letra J, seguida por el tipo de
componente que admite la clase. Jcomponent consta de las subclases directas que se
muestran en la Figura 2.

6.

PANORMICA DEL PAQUETE SWING

Swing es una API grande que consta de nueve paquetes y de numerosas clases e interfaces. La
mayor parte de componentes Swing se incluyen en el paquete java.awt.swing, el cual
ofrece asimismo clases e interfaces que admiten y manejan los componentes GUI. El paquete
java.awt.swing.border ofrece una serie de interesantes bordes que se pueden usar con
los componentes Swing. Estos bordes le ayudan a adaptar el aspecto y sensacin de los
conjuntos de componentes.
El paquete java.awt.swing.event define los eventos y auditores de eventos que
utilizan los componentes Swing. Es sin duda una buena idea examinar la lista de eventos y de
auditores de eventos para tener una idea de las interacciones de usuario que admite Swing.
El paquete java.awt.swing.table ofrece clases e interfaces que admiten el objeto
JTable enriquecido y flexible. Estas clases e interfaces se usan para adaptar las caractersticas
de muestra de una tabla.
Los paquetes java.awt.swing.text ofrecen varias clases e interfaces que admiten
componentes de texto. Estas clases e interfaces controlan el signo de intercalacin, resaltado,
formato y dems aspectos del texto que se introduce y se modifica en los componentes del texto.
El
paquete
java.awt.swing.text.html
contiene
la
clase
nica
HTMLEditorKit. Esta clase admite la implementacin de un editor HTML sencillo pero
potente. El paquete
java.awt.swing.text.rtf es parecido al paquete
java.awt.swing.text.html. Contiene la clase nica RTFEditorKit, la cual ofrece
la posibilidad de modificar Texto con Formato Enriquecido (RTF).

Programacin con Swing

El paquete java.awt.swing.tree ofrece clases e interfaces que admiten el uso del

componente JTree.
El paquete java.awt.swing.undo admite operaciones hacer y rehacer.

JComponent

AbstractButton

JButton

JMenuItem

JCheckBoxMenuItem

JMenu

JRadioButtonMenuItem

JToggleButton

JCheckBox

JRadioButton

JComboBox

JInternalFrame

JLabel

DefaultTableCellRenderer(java.awt.swing.table)

JLayeredPane

JDesktopPane

JList

JMenuBar

JOptionPane

JPanel

ColorChooserPanel

JPopupMenu

JProgressBar

JRootPane

JScrollBar

JScrollPane

JSeparator

JSlider

JSplitPane

JTabbedPane

JTable

JTableHeader(java.awt.swingn.table)

JTextComponent(java.awt.swing.text)

JEditorPane
JTextPane

JTextArea

JTextField

JPasswordField

JToolBar

JToolTip

JTree

JViewport

Figura 2. La jerarqua de componentes Swing

Jose Luis Garca y Noelia Mndez

7.

CONSTRUCCIN DE GUI EN SWING

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

exceptuando que la primera tendr muchas ms clases de componentes con las que trabajar. A
continuacin se describen las clases que se usan para la construccin de GUI y se sealan las
mejoras que Swing proporciona, comparando stas clases con las de AWT.
- Ventanas
Swing, al igual que AWT, proporciona una jerarqua de clases Window. Las clases de la
ventana de Swing constituyen extensiones de la jerarqua de clases Window del AWT. La
clase JWindow ampla la clase Window. La clase JFrame ampla la clase JFrame del
AWT y la clase JDialog ampla la clase Dialog del AWT.
Las clases JWindow, JFrame y JDialog difieren de sus homlogos del AWT en
que utilizan un panel de contenido separado para agregar y disear componentes GUI. Este
panel es un objeto Container al que se accede a travs del mtodo
getContentPane(). El panel de contenido es una parte de un objeto JRootPane que
contiene otros paneles que se usan para sobreponerse a componentes e interceptar eventos
del ratn y del teclado.
- Mens
Los mens de Swing, al igual que las ventanas de Swing, son anlogos a sus homlogos del
AWT. Las clases JMenuBar, JMenu, JMenuItem, JCheckBoxMenuItem y
JRadioButtonMenuItem se utilizan de la misma forma que las clases MenuBar,
Menu, MenuItem y CheckboxMenuItem del AWT, slo que con una diferencia
fundamental. Las clases de mens de Swing son todas ellas subclases de la clase
JComponent y, por tanto, de la clase Component. Esto implica que los mens de Swing,
al contrario que sus homlogos del AWT, constituyen componentes de primera clase y se
pueden usar con cualquiera de las clases Container. La clase JPopupMenu es
equivalente a la clase PopupMenu del AWT. Otra atractiva caracterstica de los mens de
Swing es la posibilidad de utilizar imgenes de iconos en los mens. Se puede aadir una
imagen a un elemento de men por medio de su constructor.
- 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.
- Diseos
Los contenedores de Swing admiten todos los diseos posibles del AWT, entre los que se
incluye el diseo null, adems de admitir otros diseos nuevos.
- Iconos
Una de las caractersticas ms tiles que Swing ofrece es la posibilidad de agregar iconos a
los componentes, como etiquetas, botones, elementos de men, etc. La interfaz Icon define
los mtodos que las clases de iconos deben implementar. La clase ImageIcon
proporciona una implementacin predeterminada de esta interfaz. Los objetos ImageIcon
se pueden construir a partir de archivos de imagen, URL que apuntan a archivos de imagen
u objetos Image del AWT.
- Bordes
El paquete java.awt.swing.border proporciona la interfaz Border, la cual define
los mtodos que necesitan ser implementados por todas las clases de bordes. La clase

10

Programacin con Swing

AbstractBorder implementa la interfaz Border y es la superclase de las clases de

bordes de Swing.
- Informacin sobre herramientas
La clase JToolTip ofrece la posibilidad de agregar cuadros de texto emergentes que
aparecen cuando se posa el ratn sobre un componente. Estos componentes, que admiten
informacin sobre herramientas, permiten que stas vengan especificadas en sus respectivos
constructores. El mtodo setToolTipText() de la clase JComponent se puede usar
tambin para especificar la informacin sobre herramientas de un componente.
- 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 contenedores de otros componentes
Swing o del AWT. Los objetos JToolBar tpicos contienen objetos JButton que se
construyen por medio de iconos de imagen.
- Etiquetas y botones
Las clases JLabel y JButton proporcionan los equivalentes de Swing a las clases
Label y Button del AWT. La implementacin de Swing ofrece la ventaja de poder usar
iconos a la vez que texto. Los constructores JLabel() y JButton() permiten que se
especifique un icono. Adems, ambas clases admiten el mtodo setIcon() para
establecer un icono una vez que se ha construido el objeto.
- Componentes de texto
Las clases JTextComponent, JTextField y JTextArea son los equivalentes de
Swing de las clases TextCompoenent, TextField y TextArea del AWT. Adems,
Swing proporciona la clase TextPane para trabajar con documentos de texto, que se
pueden marcar con estilos de texto diferentes.
- Listas y cuadros combinados
Las clases JComboBox y JList ofrecen la posibilidad de presentarle al usuario una lista
de selecciones grficas de texto. La clase JComboBox implementa una lista desplegable,
parecida a una lista de opciones Motif. La clase JList es una lista de selecciones
individuales o mltiples en las que se pueden ver muchos elementos.
- Deslizadores y barras de progreso
Las clases JSlider y JProgressBar carecen de equivalentes en el AWT. Ambas
clases admiten orientaciones horizontales y verticales. La clase JProgressBar se utiliza
tpicamente para mostrar el progreso de una tarea, como la carga de una imagen. La clase
JSlider se usa para ajustar o controlar el valor de una variable dentro del intervalo
admisible.
- Barras de desplazamiento
El JScrollPane simplifica en gran medida el uso de las barras de desplazamiento. El
mtodo getViewport() devuelve un objeto JViewport en el que se pueden ir
aadiendo componentes. En la mayora de los casos, slo necesita agregar componentes al
objeto JViewport para que uno se pueda desplazar automticamente por ellos.
- 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 la
interfaz TableModel.

11

Jose Luis Garca y Noelia Mndez

La interfaz JTableModel define mtodos para los objetos que especifican el

contenido de una tabla. La clase AbstractTableModel ofrece una implementacin
predeterminada de la interfaz JTableModel. Esta clase se ampla tpicamente para
proporcionar una implementacin personalizada de modelo de tabla.
La clase JTable ofrece la posibilidad de editar tablas. El mtodo
setCellEditor() permite que un objeto de la interfaz TableCellEditor sea
identificado como el editor de celdas de una tabla.
- rboles
Una de las clases nuevas ms interesantes que ofrece Swing es la clase JTree. Esta clase
implementa una estructura en forma de rbol que se puede usar para mostrar datos
jerrquicos. La interfaz TreeNode define mtodos que tienen que implementar los nodos
de un objeto JTree. La clase DefaulMutableTreeNode proporciona una
implementacin predeterminada de la interfaz TreeNode. Los rboles se crean
construyendo objetos de la interfaz TreeNode para luego aadirlos todos juntos (a travs
del mtodo add()). Cuando todos los objetos TreeNode se hayan juntado, el objeto
TreeNode resultante se pasa al constructor JTree.
La presentacin predeterminada de un objeto JTree utiliza un icono de carpeta con el
fin de identificar los nodos de rbol que tienen nodos inferiores y un icono de archivo para
identificar las ramificaciones del rbol. El mtodo setCellRenderer() de la clase
JTree se usa para identificar una prestacin de rbol alternativa.

8.

MANEJO DE EVENTOS EN SWING

Cada vez que el usuario teclea un carcter o pulsa un botn del ratn, ocurre un evento.
Cualquier componente puede ser notificado del evento. Todo lo que tiene que hacer es
implementar el interface apropiado y ser registrado como un oyente de evento del evento fuente
apropiado. Los componentes Swing pueden generar muchas clases de evento.
El paquete java.awt.swing.event define una serie de interfaces auditoras de
eventos y clases de eventos que se usan con los componentes Swing. Adems, muchos de los
componentes Swing tambin utilizan eventos del AWT.
En la figura 3 mostramos unos pocos ejemplos:

Figura 3 Ejemplos de eventos

Cada evento est representado por un objeto que ofrece informacin sobre el evento e
identifica la fuente. Las fuentes de los eventos normalmente son componentes, pero otros tipos
de objetos tambin pueden ser fuente de eventos. Como muestra la siguiente figura, cada fuente

12

Programacin con Swing

de evento puede tener varios oyentes registrados. Inversamente, un slo oyente puede registrarse
con varias fuentes de eventos.

Figura 4 Relacin entre eventos y oyentes

9.

APPLETS DE SWING

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

JFrame en que admite un panel de contenido separado. A este contenedor se accede a travs
del mtodo getContentPane(). La barra de mens debe ser un objeto de la clase
JMenuBar.

10.

CONVERSIN A SWING

9.1 Por qu convertir a Swing?

Ante la pregunta, por qu debo convertir a Swing?, la razn ms fuerte es que Swing ofrece
muchos beneficios a los programadores y usuarios finales. Entre ellos:
-

El rico conjunto de componentes listo-para-usar significa que podemos aadir

caractersticas divertidas a nuestros programas -- botones con imgenes, barras de
herramientas, paneles con pestaas, display HTML, imgenes en tems de men, un
selector de color, etc.

Tambin significa que podramos reemplazar algunos componentes personalizados con

componentes Swing ms extensibles y eficaces.

Tener modelos separados de datos y estados hace que los componentes Swing sean
altamente personalizables y permite compartir datos entres componentes.

La arquitectura conectable del aspecto y comportamiento swing ofrece una amplia

seleccin de aspectos y comportamientos. Junto al aspecto y comportamiento de la
plataforma usual, podemos usar el aspecto y comportamiento Java e incluso aspectos y
comportamientos de terceras partes.

Los componentes Swing tienen soporte interno para accesibilidad, lo que hace que
nuestros programas pueden usarse automticamente con tecnologas asistivas.

Los componentes Swing continuarn amplindose en el futuro.

Por lo que la pregunta sera ahora "Por qu no debo convertir a Swing?" Es razonable
posponer la conversin si pensamos que nuestros usuarios no podrn ejecutar los
programas Swing de forma conveniente. Por ejemplo, su nuestro programa es un applet
y queremos que todo el mundo pueda usarlo en internet, deberamos considerar cuantos
navegantes del Web tienen navegadores que puedan ejecutar programas Swing. En el
momento de escribir esto, la mayora de los navegadores no tienen soporte Swing
interno; los usuarios deben aadirlo descargando e instalando Java Plug-in.

9.2 Cmo convertir a Swing?

13

Jose Luis Garca y Noelia Mndez

Dado que Swing ofrece componentes GUI que son equivalentes a los componentes del AWT,
resulta fcil convertir las aplicaciones y applets a Swing. Las aplicaciones se convierten a
Swing reemplazando la clase Frame por la clase JFrame y utilizando getContentPane()
para acceder al contenedor del marco. Los componentes GUI que se hubieran aadido al Frame
se aaden al contenedor del marco. Los applets se convierten deforma parecida con la clase
JApplet reemplazando a la clase Applet. La mayor parte de los componentes GUI del
AWT pueden convertirse a Swing anteponiendo al nombre de la clase de AWT la letra J.

11.

EJEMPLOS

Puesto que Swing tiene una gran cantidad de componentes y sera demasiado extenso detallar
cada uno de stos, a continuacin se analizan de forma detallada slo dos de ellos. Para conocer
el funcionamiento del resto de los componentes, en la bibliografa se muestran algunas
referencias para encontrar la informacin necesaria.

10.1 Cmo utilizar la Clase Tabbed Pane

10.1.1

Qu es la clase Tabbed Pane?

Con la clase JTabbedPane, podemos tener varios componentes (normalmente objetos

JPanel) compartiendo el mismo espacio. El usuario puede elegir qu componente ver
seleccionando la pestaa del componente deseado.
10.1.2

Construir una aplicacin con un Tabbed Pane

Para crear un TabbedPane, simplemente se ejemplariza un JTabbedPane, se crean los

componentes que deseemos mostrar, y luego los aadimos al TabbedPane utilizando el
mtodo addTab.
Compilando y ejecutando el siguiente cdigo, se obtiene como resultado la ventana que
aparece representada en la Figura 5.
ImageIcon icon = new ImageIcon("images/middle.gif");
JTabbedPane tabbedPane = new JTabbedPane();
Component panel1 = makeTextPanel("Blah");
tabbedPane.addTab("One", icon, panel1, "Does nothing");
tabbedPane.setSelectedIndex(0);
Component panel2 = makeTextPanel("Blah blah");
tabbedPane.addTab("Two", icon, panel2, "Does twice as much nothing");
Component panel3 = makeTextPanel("Blah blah blah");
tabbedPane.addTab("Three", icon, panel3, "Still does nothing");
Component panel4 = makeTextPanel("Blah blah blah blah");
tabbedPane.addTab("Four", icon, panel4, "Does nothing at all");

14

Programacin con Swing

Figura 5 Ejemplo de ventana con pestaas

Esta imagen representa una aplicacin que utiliza cuatro TabbedPane. Como podemos
apreciar, la ventana est constituida por cuatro pestaas. Una pestaa puede tener un tooltip, y
puede mostrar tanto texto como una imagen. El ejemplo muestra las pestaas en sus posiciones
por defecto, en la parte superior del TabbedPane. Podemos cambiar las posiciones de las
pestaas a la izquierda, derecha, o abajo.
Poniendo el cursor sobre una pestaa, despus de un corto tiempo, se ver una ayuda
(tooltip) asociada con la pestaa. Como conveniencia se debe aadir el texto de la ayuda
(tooltip) cuando se aade el componente al TabbedPane.
10.1.3

El API TabbedPane

Las siguientes tablas listan los mtodos y constructores ms utilizados de TabbedPane. El

API para utilizar TabbedPane se divide en estas categoras:
-

Crear y configurar un TabbedPane.

Insertar, Eliminar, Encontrar y Seleccionar Pestaas.

Cambiar la apariencia de las pestaas.

Tabla 1 Crear y configurar un TabbedPane

Mtodo
JTabbedPane()
JTabbedPane(int)

Propsito
Crea un TabbedPane. El argumento
opcional indica dnde deberan aparecer las
pestaas.
Por defecto, las pestaas aparecen en la
parte superior. Se pueden especificar estas
posiciones (definidas en el interface
SwingConstants,
que
implementa
TabbedPane):
TOP, BOTTOM, LEFT, LEFT.

addTab(String, Icon, Component,

String)
addTab(String, Icon, Component)
addTab(String, Component)

Aade una nueva pestaa al TabbedPane.

El primer argumento especifica el texto de la
pestaa.
El argumento Icon es opcional e indica
el icono de la pestaa. El argumento
Component especifica el componente que el
TabbedPane debera mostrar cuando se
selecciona la pestaa. El cuarto argumento, si
existe, especifica el texto del tooltip para la
pestaa.

15

Jose Luis Garca y Noelia Mndez

Tabla 2 Insertar, Eliminar, Encontrar y Seleccionar Pestaas

Mtodo

Propsito

insertTab(String, Icon,
Component, String, int)

Inserta una pestaa en el ndice especificado,

donde la primera pestaa tiene ndice 0. Los
argumentos son los mismos que para
addTab.

remove(Component)
removeTabAt(int)

Elimina la pestaa correspondiente al ndice o

componente especificado.

removeAll()

Elimina todas las pestaas.

int indexOfComponent(Component)

Devuelve el ndice de la pestaa que tiene el

componente, ttulo o icono especificados.

int indexOfTab(String)
int indexOfTab(Icon)
void setSelectedIndex(int)
void
setSelectedComponent(Component)

int getSelectedIndex()
Component getSelectedComponent()

Selecciona la pestaa que tiene el ndice o

componente especificado.
Seleccionar una pestaa tiene el efecto de
mostrar su componente asociado.
Devuelve el ndice o componente de la
pestaa seleccionada.

Tabla 3 Cambiar la Apariencia de las Pestaas

Mtodo

Propsito

void setComponentAt(int,
Component)

Selecciona u obtiene qu componente est

asociado con la pestaa del ndice
especificado. La primera pestaa tiene ndice
0.

Component getComponentA(int)
void setTitleAt(int, String)
String getTitleAt(int)
void setIconAt(int, Icon)
Icon getIconAt(int)

Selecciona u obtiene el ttulo de la pestaa del

ndice especificado.
Selecciona u obtiene iconos
pestaa del ndice especificado.

mostrados

void setDisabledIconAt(int, Icon)

Icon getDisabledIconAt(int)
void setBackgroundAt(int, Color)
Color getBackgroundAt(int)
void setForegroundAt(int, Color)
Color getForegroundAt(int)

16

Selecciona u obtiene el color de fondo o de

primer plano usado por la pestaa del ndice
especificado. Por defecto, una pestaa utiliza
los colores del TabbedPane.
Por ejemplo, si el color de primer plano del
TabbedPane es negro, entonces todos los
ttulos de las pestaas sern en negro, excepto
para aquellas en que especifiquemos otro
color usando setForegroundAt.

Programacin con Swing

void setEnabledAt(int, boolean)

boolean isEnabledAt(int)

Selecciona u obtiene el estado activado de la

pestaa del ndice especificado.

10.2 Cmo Utilizar Mens

10.2.1

Qu es un Men

Un men proporciona una forma de ahorrar espacio y permitir al usuario elegir una entre varias
opciones. Otros componentes con los que el usuario puede hacer una eleccin incluyen combo
boxes, lists, radio buttons, y tool bars.
Los mens son nicos en que, por convencin, no se sitan con los otros componentes en el
UI. En su lugar, aparecen en una barra de men o en un men desplegable. Una barra de men
contiene uno o ms mens, y tiene una posicin dependiente de la plataforma, normalmente
debajo de la parte superior de la ventana. Un men desplegable es un men que es invisible
hasta que el usuario hace una accin del ratn especfica de la plataforma, como pulsar el botn
derecho del ratn sobre un componente. Entonces el men desplegable aparece bajo el cursor.
La figura 6 muestra los componentes Swing que implementan cada parte de un sistema de
mens.

Figura 6 Componentes de un men

10.2.2

La herencia de componentes de men

Figura 7 rbol de herencia de las clases relacionadas con mens.

17

Jose Luis Garca y Noelia Mndez

Como se ve en la figura 7, los tems de mens (incluidos los propios mens) son simples
botones. Un men, a pesar de ser un botn, muestra sus tems ya que cuando se activa,
automticamente trae un men desplegable que muestra sus tems.
10.2.3

Construir una aplicacin con un Men

A continuacin tenemos el fragmento de cdigo que crea los mens mostrados en la figura 4.
Como este cdigo no tiene manejo de eventos, los mens no hacen nada til, excepto verse
como seran. Si se ejecuta el ejemplo, observaremos que a pesar de no tener un manejo de
eventos, los mens y submens aparecen cuando deben, y los checkbox y los botones de radio
responden apropiadamente cuando el usuario los elige.
menu.add(cbMenuItem);
cbMenuItem = new JCheckBoxMenuItem("Another one");
menu.add(cbMenuItem);
//a submenu
menu.addSeparator();
submenu = new JMenu("A submenu");
menuItem = new JMenuItem("An item in the submenu");
submenu.add(menuItem);
menuItem = new JMenuItem("Another item");
submenu.add(menuItem);
menu.add(submenu);
//Build second menu in the menu bar.
menu = new JMenu("Another Menu");
menuBar.add(menu);

Como se ve en el cdigo, para configurar una barra de men para un JFrame, se utiliza el
mtodo setJMenuBar. Para aadir un JMenu a un JMenuBar, se utiliza el mtodo
add(JMenu). Para aadir tems de men y submens a un JMenu, se utiliza el mtodo
add(JMenuItem). Estos mtodos y otros ms se listan en El API de JMenu.
10.2.4

Manejar Eventos desde tems de Mens

Para detectar cuando el usuario selecciona un JMenuItem, se puede escuchar por eventos
action (igual que se hara para un JButton). Para detectar cuando el usuario selecciona un
JRadioButtonMenuItem, se puede escuchar tanto por eventos action, como por eventos
item. Para JCheckBoxMenuItems, generalmente se escuchan eventos de item.
La figura 8 muestra un programa que aade deteccin de eventos al ejemplo anterior.

18

Programacin con Swing

Figura 8 Deteccin de eventos

A continuacin se muestra un fragmento de cdigo que implementa el manejo de eventos:

public class MenuDemo ... implements ActionListener,

ItemListener {
...
public MenuDemo() {
...//for each JMenuItem instance:
menuItem.addActionListener(this);
...//for each JRadioButtonMenuItem:
rbMenuItem.addActionListener(this);
...//for each JCheckBoxMenuItem:
cbMenuItem.addItemListener(this);
...
}
public void actionPerformed(ActionEvent e) {
...//Get information from the action event...
...//Display it in the text area...
}
public void itemStateChanged(ItemEvent e) {
...//Get information from the item event...
...//Display it in the text area...
}

Para traer un men desplegable (JPopupMenu), debemos registrar un oyente de ratn

para cada componente al que debera estar asociado el men desplegable. El oyente de mouse
debe detectar las peticiones del usuario para que aparezca el men desplegable.

19

Jose Luis Garca y Noelia Mndez

Para las plataformas Windows y Motif, el usuario trae un men desplegable pulsando el
botn derecho del ratn mientras el cursor est sobre el componente adecuado. El oyente de
mouse trae un men desplegable llamando a setVisible(true) sobre el ejemplar
apropiado de JPopupMenu.
El siguiente fragmento de cdigo, muestra cmo crear y mostrar mens desplegables:
...//where instance variables are declared:
JPopupMenu popup;
...//where the GUI is constructed:
//Create the popup menu.
popup = new JPopupMenu();
menuItem = new JMenuItem("A popup menu item");
menuItem.addActionListener(this);
popup.add(menuItem);
menuItem = new JMenuItem("Another popup menu item");
menuItem.addActionListener(this);
popup.add(menuItem);
//Add listener to components that can bring up popup menus.
MouseListener popupListener = new PopupListener();
output.addMouseListener(popupListener);
menuBar.addMouseListener(popupListener);
...
class PopupListener extends MouseAdapter {
public void mousePressed(MouseEvent e) {
maybeShowPopup(e);
}
public void mouseReleased(MouseEvent e) {
maybeShowPopup(e);
}
private void maybeShowPopup(MouseEvent e) {
if (e.isPopupTrigger()) {
popup.show(e.getComponent(),
e.getX(), e.getY());
}
}
}

20

Programacin con Swing

Los mens desplegables tienen unos pocos detalles interesantes de implementacin. Uno es que
cada men tiene un men desplegable apropiado. Cuando el men se activa, utiliza su men
desplegable para mostrar sus tems de men.
Otro detalle es que un propio men desplegable utiliza otro componente para implementar
la ventana que contiene los tems del men. Dependiendo de las circunstancias bajo las que se
muestre el men desplegable, podra implementar su "ventana" utilizando un componente de
peso ligero (como un JPanel), un componente de peso medio (como un Panel), o una
ventana de peso pesado (Window).
Las ventanas desplegables de peso ligero son ms eficientes que las ventanas de peso
pesado, pero no funcionan bien si tenemos componentes pesados dentro de nuestro GUI.
Especficamente, cuando un rea de una ventana desplegable de peso ligero se intersecciona con
un componente de peso pesado, el componente de peso pesado se dibuja encima. Esta es una de
las razones por la que se recomienda no mezclar componentes de peso ligero y de peso pesado.
Si realmente se necesita utilizar un componente de peso pesado en el GUI, se puede utilizar el
mtodo setLightWeightPopupEnabled de JPopupMenu para desactivar las ventanas
desplegables de peso ligero.
10.2.5

Personalizar la Distribucin de un Men

Como los mens se hacen con componentes ordinarios Swing, se pueden personalizar
fcilmente. Por ejemplo, se puede aadir cualquier componente de peso ligero a un JMenu o
JMenuBar. Y como JMenuBar utiliza BoxLayout, se puede personalizar la distribucin de
la barra de men aadindole componentes invisibles. Aqu mostramos un ejemplo que aade
un componente glue a una barra de men, para que el ltimo elemento del men se site en el
lado derecho de la barra de men:
...//create and add some menus...
menuBar.add(Box.createHorizontalGlue());
...//create the LEFTmost menu...
menuBar.add(LEFTMenu);
En la figura 9 podemos ver una imagen del resultado.

Figura 9 Men personalizado

Otra forma de cambiar el aspecto de un men es cambiar el controlador de distribucin que

lo controla. Por ejemplo, se puede cambiar el controlador de distribucin de la barra de men
del valor por defecto BoxLayout de izquierda-derecha, a algo como un GridLayout.
Tambin podemos cambiar como un men activado u otro men desplegable distribuye sus
tems. En la figura 10 se muestra una imagen de una aplicacin en la que se ha modificado la
distribucin del men.

Figura 10 Otra distribucin de un men

21

Jose Luis Garca y Noelia Mndez

10.2.6

El API de JMenu

Las siguientes tablas listan los mtodos y constructores ms utilizados de Jmenu. El API
se divide en estas categoras:
-

Crear y Configurar Barras de Men.

Crear y Rellenar Mens.

Crear, Rellenar y Controlar Mens Desplegables.

Implementar tems de Men.

Tabla 4 Crear y configurar barras de mens

Mtodo

Propsito

JMenuBar()

Crea una barra de men.

void setJMenuBar(JMenuBar)

Selecciona u obtiene la barra de men de un

applet, dialog, frame, o root
pane.

JMenuBar getJMenuBar()
(en JApplet,
JRootPane)

JDialog,

JFrame,

void setMenuBar(JMenuBar)
JMenuBar getMenuBar()
(en JInternalFrame)

En las siguientes versiones de Swing y

del JDK 1.2, los frames internos tambin
soportarn estos mtodos.
Selecciona u obtiene la barra de men de un
Frame interno. En las siguientes versiones de
Swing y del JDK 1.2, este mtodo ser
anulado
y
deberamos
utilizar
setJMenuBar/getJMenuBar.

Tabla 5 Crear y Rellenar Mens

Mtodo

Propsito

JMenu()

Crea un men.

JMenuItem add(JMenuItem)

Aade un tem de men al final del men.

JMenuItem add(Action)
void add(String)

Si el argumento es un string, el men

crea automticamente un objeto JMenuItem
que muestra el texto especificado.

void addSeparator()

Aade un separador la final del men.

>JMenuItem insert(JMenuItem, int)

Inserta un tem de men o un separador en un

men, en la posicin especificada. El primer
tem de men es la posicin 0, el segundo la
posicin 1, etc. Los argumentos JMenuItem,
Action, y String se tratan de la misma
forma que en los correspondientes mtodos
add.

JMenuItem insert(Action, int)

void insert(String, int)
void insertSeparator(int)

void remove(JMenuItem)
void remove(int)
void removeAll()

22

Elimina el tem o tems especificados del

men. Si el argumento es un entero, especifica
la posicin del tem a eliminar.

Programacin con Swing

Tabla 6 Crear y Rellenar Mens Desplegables

Mtodo
JPopupMenu()
JPopupMenu(String)

JMenuItem add(JMenuItem)
JMenuItem add(Action)

Propsito
Crea un men desplegable. El argumento
string opcional especifica el ttulo que el
aspecto y comportamiento podra mostrar
como parte de la ventana desplegable.
Aade un tem de men al final del men
desplegable.

void addSeparator()

Aade un separador al final del men

desplegable.

void insert(Component, int)

Inserta un tem de men en la posicin

especificada. El primer tem del men est
en la posicin 0, el segundo en la posicin
1, etc. El argumento Component
especfica el tem de men a aadir. El
argumento Action es tratado de la misma
forma
que
en
el
mtodo
add
correspondiente.

JMenuItem insert(Action, int)

void remove(JMenuItem)
void remove(int)
void removeAll()

static void
setDefaultLightWeightPopupEnabled
(boolean)

Elimina el tem o tems especificados del

men.
Si el argumento es un entero, especifica
la posicin del elemento del men a
eliminar.
Por defecto, Swing implementa una ventana
de men utilizando un componente de peso
ligero.
Esto causa problemas su utilizamos
componentes de peso pesado en nuestro
programa Swing. Para evitar estos
problemas,
se
puede
llamar
a
JPopupMenu.setDefaultLightWei
ghtPopupEnabled(false).

void show(Component, int, int)

Muestra el men desplegable en la posicin

X,Y (especificada en el orden de los
argumentos enteros) en el sistema de
coordenadas del componente especificado.

Tabla 7 Implementar tems de Men

Mtodo

Propsito

JMenuItem()

Crea un tem de men normal. El

argumento icon, si existe, especifica el
icono que debera mostrar el tem de men.
Igualmente el argumento String, especifica
el texto que debera mostrar el tem de
men. El argumento entero especifica el
mnemnico de teclado a utilizar.

JMenuItem(Icon)
JMenuItem(String)
JMenuItem(String, Icon)
JMenuItem(String, int)

Se puede especificar una de las

23

Jose Luis Garca y Noelia Mndez

constantes VK definidas en la clase

KeyEvent. Por ejemplo, para especificar
"a" como el mnemnico, podemos utilizar
KeyEvent.VK_A.
JCheckBoxMenuItem()
JCheckBoxMenuItem(Icon)
JCheckBoxMenuItem(String)
JCheckBoxMenuItem(String,
JCheckBoxMenuItem(String,
boolean)
JCheckBoxMenuItem(String,
boolean)

Crea un tem de men que se parece y

acta como un checkbox. Si se
especifica un icono, el tem de men utiliza
el icono en vez del icono por defecto de los
checkboxes. El argumento string, si
Icon)
existe, especifica el texto que debera
mostrar el tem de men. Si se especifica
true para el argumento booleano, el
Icon, tem de men estar inicialmente
seleccionado. De lo contrario el tem de
men est desactivado.

JRadioButtonMenuItem()
JRadioButtonMenuItem(Icon)
JRadioButtonMenuItem(String)
JRadioButtonMenuItem(String,
Icon)<

void setState(boolean)
boolean getState()

Crea un tem de men que se parece y

acta como un radio buttom. Si se
especifica un icono, el tem de men utiliza
el icono en vez del icono por defecto de los
botones de radio. El argumento string,
si existe, especifica el texto que debera
mostrar el tem de men. El tem de men
est inicialmente desactivado.
Selecciona u obtiene el estado de seleccin
de un tem de men.

void setEnabled(boolean)

Si el argumento es true, activa el tem de

men, si es false lo desactiva.

void setMnemonic(char)

Selecciona la tecla alternativa para

seleccionar el tem de men sin el ratn.

void setActionCommand(String)

Selecciona el nombre de
realizada por el tem de men.

void
addActionListener(ActionListener)

Aade un oyente de eventos al tem de

men.

la

accin

void
addItemListener(ItemListener)
La mayora de los mtodos anteriores son heredados desde AbstractButton.

12.

CONCLUSIONES

Swing es un API que ofrece JFC 1.1, y representa la nueva generacin de AWT. Swing ampla
AWT proporcionando muchos ms tipos de componentes GUI, ofreciendo implementaciones
cien por cien Java puro a estos componentes y permitiendo adaptar fcilmente el aspecto y
comportamiento de tales componentes, facilitando as el trabajo de los programadores.
El que los componentes de Swing sean cien por cien Java puro implica que no dependen de
ninguna implementacin nativa de ventanas que les de soporte, y que adems estn disponibles
y sean consecuentes en todo tipo de plataforma.

24

Programacin con Swing

Transformar programas de AWT a Swing es muy sencillo, y gracias a todos los

componentes que ofrece, presenta gran cantidad de ventajas, por lo que es recomendable utilizar
ste API.

25

Jose Luis Garca y Noelia Mndez

13.
-

26

BIBLIOGRAFA
http://www.programacion.com/java/tutorial/swing/
Manual - Programacin - Java tutor Swing
http://jungla.dit.upm.es/~santiago/docencia/apuntes/Swing/
Java 1.2 Al descubierto. Jaime Jaworski
Suns Java Swing Tutorial
Java Swing Tutorial (2005)
Lenguaje de programacin Java