intro swing

DESARROLLO DE APLICACIONES INTERACTIVAS EN JAVA (Julio 2002) Universidad Carlos III de Madrid

Tema IV. Elementos de una interfaz gráfica

1 de 38

Introducción a la Construcción de Interfaces Gráficas de Usuario en

Java



2 de 38

INDICE

1. Introducción: Java Foundation Clases (JFC)..........................................5

1.1. El API de Swing.................................................................6

1.2. MVC (Model-View-Controller) ..............................................8

Modelo ................................................................................8

Vista...................................................................................9

Controlador .........................................................................9

1.3. Delegados UI y PLAF ..........................................................9

Pluggable look-and-feel .......................................................... 10

2. Componentes Gráficos .................................................................... 11

2.1. JFrame........................................................................... 15

Crear y configurar un Frame ................................................... 15

2.2. JPanel............................................................................ 16

Otros Contenedores ............................................................... 16

2.3. JButton .......................................................................... 18

Seleccionar u Obtener el Contenido de un Botón ........................ 19

Ajuste de la Apariencia del Botón ............................................. 20

2.4. JLabel ............................................................................ 21

Seleccionar u Obtener el Contenido de la Etiqueta ...................... 21

Ajuste Fina de la Apariencia de la Etiqueta ................................ 22

2.5. JTextField....................................................................... 22



3 de 38

Seleccionar u Obtener el Contenido de un Campo de Texto.......... 23

Ajuste de la Apariencia de un Campo de Texto........................... 24

2.6. JComboBox .................................................................... 24

Seleccionar u Obtener Ítems de la Lista del ComboBox ............... 25

Personalizar la Configuración del ComboBox .............................. 25

2.7. JRadioButton .................................................................. 26

Métodos y Constructores más utilizados de ButtonGroups............ 26

2.8. JCheckBox...................................................................... 27

2.9. JMenuBar ....................................................................... 27

Crear y Configurar Barras de Menú........................................... 27

Crear y Rellenar Menús .......................................................... 28

Implementar Ítems de Menú ................................................... 29

2.10. Otros Componentes ...................................................... 30

2.11. Cómo funciona el dibujo ................................................ 32

3. Manejo de eventos ......................................................................... 33

Acción que resulta en el evento ......................................... 33

Tipo de oyente ................................................................ 33

ActionListener .............................................................. 33

3.1. Hilo de despacho de eventos (Event-dispatching thread) ....... 35

3.2. Actions........................................................................... 35

3.3. Entrada de teclado, KeyStrokes, y Actions........................... 36



4 de 38

3.4. Modelo de datos .............................................................. 37

3.5. AWT vs Swing ................................................................. 38

3.6. Adaptadores ................................................................... 38

3.7. JButton .......................................................................... 38

3.8. JCheckBox...................................................................... 38

4. Direcciones Web............................................................................. 38



5 de 38

1. Introducción: Java Foundation Clases (JFC)

El conjunto de las bibliotecas para la construcción de la interfaz de usuario que nos proporciona Java se denomina Java Foundation Classes (JFC). Este conjunto extiende las bibliotecas originales que se denominaban Abstract Window Toolkit (AWT). Entre las interfaces de programación (API) que abarca JFC se incluyen los siguientes:

• JFC/Swing components. Incluye todo tipo de componentes gráficos, ventanas, botones, desplegables, campos de texto, etc.

• Pluggable Look and Feel. Ofrece a cualquier componente una amplia selección de aspectos y comportamientos.

• Accessibility API. Permite tecnologías asistivas como lectores de pantalla y display Braille para obtener información desde la interfaz de usuario.

• Java 2D API. Permite a los desarrolladores incorporar fácilmente gráficos 2D de alta calidad, texto, e imágenes en aplicaciones y applets Java.

• Drag and Drop. Proporciona la habilidad de arrastrar y soltar entre aplicaciones Java y aplicaciones nativas.

• AWT (Abstract Window Toolkit). Contiene el API

• Internationalization. Permite adaptar las aplicaciones java a varios lenguajes sin hacer cambios en el código.

La característica más notable de los componentes Swing es que están escritos al 100% en Java y no dependen de componentes nativos, como sucede con casi todos los componentes AWT. Esto significa que un botón Swing y un área de texto se verán y funcionarán idénticamente en las plataformas Macintosh, Solaris, Linux y Windows.

Nota respecto a las versiones: Las tres primeras API están implementadas en Java, sin código nativo, y existen desde la versión JDK 1.1. Las dos siguientes sólo están a partir de la versión Java2



6 de 38

1.1. El API de Swing

Swing consiste en 16 paquetes, cada uno de los cuales con un propósito concreto.

javax.swing

Es el paquete de más alto nivel, que contiene los componentes, adaptadores, los modelos por defecto de los componentes, y las interfaces para todos los modelos.

javax.swing.border

Clases e interfaces que se usan para definir estilos de bordes específicos. Observe que los bordes pueden ser compartidos por cualquier número de componentes Swing, ya que no son componentes por sí mismos.

javax.swing.colorchooser

Contiene clases de soporte para el componente seleccionador de color.

javax.swing.event

Contiene los tipos de eventos y listeners (oyentes) específicos de Swing. Además los componentes Swing pueden generar sus propios eventos.

javax.swing.filechooser

Contiene clase de soportes para el componente seleccionador de ficheros.

javax.swing.plaf

PLAF (pluggable look-and-feel) contiene las clases de Interfaz de Usuario que implementan los diferentes look-and-feel para los componentes. Éstas están orientadas a desarrolladores que, por una razón u otra, no pueden usar uno de los look-and-feel existentes.

javax.swing.plaf.basic



7 de 38

Consiste en la implementación del Basic look-and-feel, encima del cual se construyen los look-and- feels que provee Swing. Normalmente deberemos usar las clases de este paquete si queremos 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 que viene con Swing y que no está diseñado para ser consistente con una plataforma específica.

javax.swing.plaf.multi

Es el Multiplexing look-and-feel. No se trata de una implementación normal de look-and-feel ya que no define ni el aspecto ni el comportamiento de ningún componente. Más bien ofrece la capacidad de combinar varios look-and-feels para usarlos simultáneamente.

javax.swing.table

Contiene las clases e interfaces para soportar el componente tabla.

javax.swing.text

Contiene las clases de soporte para el framework documento.

javax.swing.text.html

Contiene las clases de soporte para crear editores de texto HTML.

javax.swing.text.html.parser

Soporte para analizar gramaticalmente HTML.

javax.swing.text.rtf

Contiene soporte para documentos RTF.

javax.swing.tree

Clases e interfaces que dan soporte al componente tree. Este componente se usa para mostrar y manejar datos que guardan alguna jerarquía.



8 de 38

javax.swing.undo

El paquete undo contiene soporte para implementar y manejar la funcionalidad deshacer/rehacer.

1.2. MVC (Model-View-Controller)

MVC es una descomposición orientada a objeto del diseño de interfaces de usuario. Los componentes se descomponen en tres partes: un modelo, una vista, y un controlador.

Modelo

El modelo es el responsable de conservar todos los aspectos del estado del componente. Esto incluye, por ejemplo, aquellos valores como el estado pulsado/no pulsado de un botón, los datos de un carácter de un componente de texto y como esta estructurado, etc. Un modelo puede ser responsable de comunicación indirecta con la vista y el controlador. Por indirecta queremos decir que el modelo no ‘conoce’ su vista y controlador--no mantiene referencias hacia ellos. En su lugar el modelo enviará notificaciones o broadcasts (lo que conocemos como eventos). En la figura anterior esta comunicación indirecta se representa con líneas de puntos.



9 de 38

Vista

La vista determina la representación visual del modelo del componente. Esto es el “aspecto(look)” del componente. Por ejemplo, la vista muestra el color correcto de un componente, tanto si el componente sobresale como si está hundido (en el caso de un botón), y el renderizado de la fuente deseada. La vista es responsable de mantener actualizada la representación en pantalla y debe hacerlo recibiendo mensajes indirectos del modelo o mensajes directos del controlador.

Controlador

El controlador es responsable de determinar si el componente debería reaccionar a algún evento proveniente de dispositivos de entrada, tales como el teclado o el ratón. El controlador es el “comportamiento(feel)” del componente, y determina que acciones se ejecutan cuando se usa el componente. El controlador puede recibir mensajes directos desde la vista, e indirectos desde el modelo.

Esta arquitectura va a permitir a los componentes Swing:

• Personalizar el “aspecto(look)” y el “comportamiento(feel)” sin modificar el modelo.

• Personalizar y reemplazar el modelo de datos de un componente.

Los componentes Swing están basados en una versión más moderna de este diseño. El componente se comporta como un mediador entre el/los modelo(s), la vista y el controlador. No es ni la M, ni la V, ni la C, aunque puede ocupar el lugar de una o incluso todas estas partes si lo diseñamos para ello.

1.3. Delegados UI y PLAF

Swing empaqueta todos los controladores y vistas de un componente dentro de un objeto denominado delegado UI. Por esta razón, la arquitectura subyacente de Swing se denomina más acertadamente como modelo-delegado que como modelo-vista-controlador. Idealmente, la comunicación entre el modelo y el delegado UI es indirecta, permitiendo así tener asociado más de un modelo a un delegado UI, y viceversa.



10 de 38

La mayor parte de los delegados UI se construyen de manera que conocen un componente y su(s) modelo(s) sólo mientras llevan a cabo tareas de dibujo o de vista-controlador. Swing evita normalmente asociar delegados UI a un componente determinado (a causa de la instancia estática).

Pluggable look-and-feel

Swing incluye varios conjuntos de delegados UI. Cada conjunto contiene implementaciones de UI para casi todos los componentes Swing y podemos llamar a estos conjuntos una implementación de look-and-feel o pluggable look-and-feel (PLAF).

Hay tres implementaciones de pluggable look-and-feel que descienden de Basic look-and- feel:

• Windows: com.sun.java.swing.plaf.windows.WindowsLookAndFeel

• CDE\Motif: com.sun.java.swing.plaf.motif.MotifLookAndFeel

• Metal (por defecto): javax.swing.plaf.metal.MetalLookAndFeel

Hay también un MacLookAndFeel que simula las interfaces de usuario de Macintosh, pero no viene con Java 2 y se debe descargar separadamente. Las librerías de los Windows y Macintosh pluggable look-and-feel sólo se soportan en la plataforma correspondiente.

Para cambiar el look-and-feel actual de una aplicación, tenemos simplemente que llamar al método setLookAndFeel() de UIManager, pasándole



11 de 38

el nombre completo del LookAndFeel que vamos a usar. El código siguiente se puede usar para llevar esto a cabo en tiempo de ejecución:

try {

UIManager.setLookAndFeel(

"com.sun.java.swing.plaf.motif.MotifLookAndFeel");

SwingUtilities.updateComponentTreeUI(myJFrame);

}

catch (Exception e) {

System.err.println("Could not load LookAndFeel");

}

SwingUtilities.updateComponentTreeUI() informa a todos los hijos del componente especificado que el look-and-feel ha cambiado y que necesitan reemplazar sus delegados UI por los del tipo especificado.

2. Componentes Gráficos

Swing desciende de un mismo padre llamado JComponent que desciende de la clase de AWT Container. Es por ello que Swing es más una capa encima de AWT que una sustitución del mismo.

El paquete Swing define dos tipos de componentes.

• Contenedores de alto nivel o peso pesado (JFrame, JApplet, JWindow, JDialog)

• Componentes de peso ligero (Jcualquier-cosa, como JButton, JPanel, y JMenu)

Por ejemplo, un componente pesado java.awt.Button ejecutándose sobre la plataforma Java para Unix mapea el botón Motif real. En esta relación es botón Motif es llamado "par" del java.awt.Button. Si hemos creado dos java.awt.Button en una aplicación, también se crearán dos "pares" y dos botones Motif. La plataforma Java comunica con los botones Motif usando el JNI. Para cada componente añadido a la aplicación, hay una pila adicional



12 de 38

unida al sistema de ventanas local, que es por lo que estos componentes se llaman de peso pesado.

Los componentes de peso ligero no tienen "pares" y emulan a los componentes del sistema local de ventanas. Un botón de peso ligero está representado por un rectángulo con una etiqueta dentro que acepta eventos del ratón. Añadir más botones significa dibujar más rectángulos.

Un componente de peso ligero necesita dibujarse sobre algo, y una aplicación escrita en Java necesita interactuar con el controlador de ventanas local para que la ventana principal de la aplicación pueda ser cerrada o minimizada. Esto es porque los componentes padres de nivel superior mencionados arriba (JFrame, JApplet, y otros) están implementado como componentes de peso pesado, es decir, necesitan ser mapeados sobre un componente en el sistema local de ventanas.

Cada aplicación o applet Swing necesita al menos un componente contenedor de peso pesado (un JFrame, JWindow, JApplet, o JDialog). Existe principalmente para proporcionar espacio para que se dibujen otros componentes Swing.

Un contenedor intermedio (un JPanel, JscrollPane, o JtabbedPane) simplifica el posicionamiento de los componentes.

Los componentes atómicos (JButton, JLabel, o JTextField) no contienen otros componentes Swing, sino que son entidades auto-suficientes que representan información para el usuario. Frecuentemente, los componentes atómicos también obtienen entrada del usuario.

A continuación se presentan dos gráficos con la jerarquía de componentes implementados en el paquete Swing.



13 de 38



14 de 38

En las siguientes subsecciones veremos algunos de estos componentes a través de ejemplos y su correspondiente código en Java.

Para utilizar y modificar dichos componentes es necesario importar el paquete Swing

import javax.swing.*;



15 de 38

2.1. JFrame

Es un contenedor Swing de alto nivel que proporciona ventanas para applets y aplicaciones. Un frame tiene decoraciones como un borde, un título, y botones para cerrar y minimizar la ventana. Un programa típico simplemente crea un frame, añade componentes al panel de contenido, y quizás añade una barra de menú.

Crear y configurar un Frame

Método Propósito

JFrame()

JFrame(String)

Crea un frame. El argumento String proporciona el título del frame.

void setDefaultCloseOperation(int)

int getDefaultCloseOperation()

Selecciona u obtiene la operación que ocurre cuando el usuario pulsa el botón de cerrar la ventana. Las posibles elecciones son.

• DO_NOTHING_ON_CLOSE • HIDE_ON_CLOSE (por defecto) • DISPOSE_ON_CLOSE

Estas constantes están definidas en el interface WindowConstants.

public class MiFrame extends JFrame{

//constructor

public MiFrame(String label) {

super(label); // Título de la ventana

try {

UIManager.setLookAndFeel(UIManager.getCrossPlatformLookAndFeelClassName());

}



16 de 38

catch (Exception exc) {

System.err.println("Error loading L&F: " + exc);

}

setDefaultCloseOperation(EXIT_ON_CLOSE);

//necesario para ver la ventana

setSize(400, 400);

pack();

setVisible(true);

}

Actividad: Mirar aquellas propiedades del JFrame en su API, que estén relacionadas con su aspecto físico (posicionamiento en la pantalla, tipo de cursor, tipo de letra, color, ...).

Actividad: Crear una ventana cuyo título será “Conversor de divisas”.

2.2. JPanel

Los paneles son los contenedores de propósito general más frecuentemente utilizados. Implementados con la clase JPanel, los paneles no añaden casi ninguna funcionalidad más allá de las que tienen los objetos JComponent. Normalmente se usan para agrupar componentes, porque los componentes están relacionados o sólo porque agruparlos hace que la distribución sea más sencilla. Un panel puede usar cualquier controlador de distribución, y se les puede dotar de bordes fácilmente.

Otros Contenedores

JPanel es sólo una de las varias clases de contenedores que se pueden utilizar. Existen algunos contenedores de propósito especial que podríamos utilizar en lugar de un JPanel.



17 de 38

Box

Automáticamente utiliza un BoxLayout para distribuir sus componentes. La ventaja de Box es que es de peso superligero, ya que desciende directamente de la clase Container. Su desventaja es que no es un verdadero componente Swing -- no hereda el API que soporta características como los bordes de la caja, ni la selección sencilla de los tamaños máximo, mínimo y preferido.

JLayeredPane

Proporciona una tercera dimensión, profundidad, para posicionar componentes. Los paneles con capas no tienen controladores de distribución pero pueden ser utilizados para colocar los componentes en capas en un JPanels. Un tipo de layeredpane, JDesktopPane, está diseñado específicamente para manejar frames internos.

JScrollPane Proporciona una vista desplazable de un componente grande.

JSplitPane Muestra dos componentes cuyos tamaños relativos pueden ser modificados por el usuario.

JTabbedPane Permite a varios componentes, normalmente objetos JPanel, compartir el mismo espacio.

El panel de contenido por defecto de un Jframe es Container que, como regla, contiene todos los componentes no-menús de la ventana. Se puede encontrar el panel de contenido utilizando un método llamado getContentPane. De forma similar, se puede cambiar el panel de contenido -- quizás para que sea un JPanel que hayamos creado -- utilizando setContentPane.

El controlador de disposición por defecto para el panel de contenido de un frame es java.awt.BorderLayout. Un BorderLayout tiene cinco áreas: north, south, east, west, y center.

Para añadir componentes al panel se utiliza el método add(componente, area). Por defecto, un BorderLayout no pone espacios entre los componentes



18 de 38

que maneja. Podemos especificar los bordes (en pixels) usando el siguiente constructor.

public BorderLayout(int horizontalGap, int verticalGap)

public class MiFrame extends JFrame{

//constructor

public MiFrame(String label) {

//...

panelBotones=new JPanel();

panelBotones.setLayout(new GridLayout(1, 0));

panelBotones.add(new JButton(“Boton 1”));

Container contenedor=getContentPane();

contenedor.add(panelBotones,BorderLayout.SOUTH);

}

}

Actividad: Mirar el layout GridLayout de java.awt.

2.3. JButton

Un botón Swing puede mostrar tanto texto como una imagen. Cómo se implemente el manejo de eventos depende del tipo de botón utilizado y de cómo se utiliza. Generalmente, implementamos un action listener (ver sección Manejo de Eventos), que es notificado cada vez que el usuario pulsa el botón.

Las siguientes tablas listan los métodos y constructores más utilizados de JButton. El API para utilizar botones se divide en tres categorías:

• Seleccionar u obtener el contenido de un botón

• Ajuste de la apariencia del botón



19 de 38

• Implementar la funcionalidad del botón

Seleccionar u Obtener el Contenido de un Botón

Método o Constructor Propósito

JButton(String, Icon)

JButton(String)

JButton(Icon)

JButton()

Crea un ejemplar de JButton, lo inicializa para tener el texto/imagen especificado.

void setText(String)

String getText()

Selecciona u obtiene el texto mostrado en el botón.

void setIcon(Icon)

Icon getIcon()

Selecciona u obtiene la imagen mostrada por el botón cuando no está seleccionado o pulsado.

void setDisabledIcon(Icon)

Icon getDisabledIcon()

Selecciona u obtiene la imagen mostrada por el botón cuando está desactivado. Si no se especifica una imagen, el aspecto y comportamiento crea una por defecto.

void setPressedIcon(Icon)

Icon getPressedIcon()

Seleccion u obtiene la imagen mostrada por el botón cuando está pulsado.

void setSelectedIcon(Icon)

Icon getSelectedIcon()

void setDisabledSelectedIcon(Icon)

Icon getDisabledSelectedIcon()

Selecciona u obtiene la imagen mostrada por el botón cuando está seleccionado. Si no se especifica una imagen de botón desactivado seleccionado, el aspecto y comportamiento crea una manipulando la imagen de seleccionado.

setRolloverEnabled(boolean)

boolean getRolloverEnabled()

Utiliza setRolloverEnabled(true) y setRolloverIcon(someIcon) para hacer que el botón muestre el icono especificado cuando el cursor pasa sobre él.



20 de 38

void setRolloverIcon(Icon)

Icon getRolloverIcon()

void setRolloverSelectedIcon(Icon)

Icon getRolloverSelectedIcon()

Ajuste de la Apariencia del Botón

Método o constructor Propósito

void setHorizontalAlignment(int)

void setVerticalAlignment(int)

int getHorizontalAlignment()

int getVerticalAlignment()

Selecciona u obtiene dónde debe situarse el contenido del botón. La clase AbstractButton permite uno de los siguientes valores para alineación horizontal: LEFT, CENTER (por defecto), y LEFT. Para alineación vertical: TOP, CENTER (por defecto), y BOTTOM.

void setHorizontalTextPosition(int)

void setVerticalTextPosition(int)

int getHorizontalTextPosition()

int getVerticalTextPosition()

Selecciona u obtiene dónde debería situarse el texto del botón con respecto a la imagen. La clase AbstractButton permite uno de los siguientes valores para alineación horizontal: LEFT, CENTER (por defecto), y LEFT. Para alineación vertical: TOP, CENTER (por defecto), y BOTTOM.

void setMargin(Insets)

Insets getMargin()

Selecciona u obtiene el número de pixels entre el borde del botón y sus contenidos.

void setFocusPainted(boolean)

boolean isFocusPainted()

Selecciona u obtiene si el botón debería parecer diferente si obtiene el foco.

void setBorderPainted(boolean)

boolean isBorderPainted()

Selecciona u obtiene si el borde del botón debería dibujarse.



21 de 38

Actividad: Crear tres botones Inicializar, Calcular y Salir. Colocarlos en la parte inferior de la ventana. Utilizar la mayor parte de los métodos de las tablas anteriores.

2.4. JLabel

Si necesitamos crear un componente que muestre un sencillo texto o una imagen, reaccionando opcionalmente a la entrada del usuario, podemos hacerlo utilizando un ejemplar de JLabel o de una subclase personalizada de JLabel. Si el componente interactivo tiene estado, probablemente deberíamos utilizar un botón en vez de una etiqueta.

Seleccionar u Obtener el Contenido de la Etiqueta

Método Propósito

JLabel(Icon)

JLabel(Icon, int)

JLabel(String)

JLabel(String, Icon, int)

JLabel(String, int)

JLabel()

Crea un ejemplar de JLabel, inicializándolo para tener texto/imagen/alineamiento especificados. El argumento int especifica el alineación horizontal del contenido de la etiqueta dentro de su área de dibujo. El alineación horizontal debe ser una de las siguientes constantes definidas en el interface SwingConstants (que implementa JLabel): LEFT, CENTER, o LEFT.


String getText()

Selecciona u obtiene el texto mostrado por la etiqueta.

void setIcon(Icon)

Icon getIcon()

Selecciona u obtiene la imagen mostrada por la etiqueta.

void setDisplayedMnemonic(char)

char getDisplayedMnemonic()

Selecciona u obtiene la letra que debería ser la tecla alternativa. Esto es muy útil cuando una etiqueta describe un componente (como un campo de texto) que tiene un tecla alternativa pero no puede mostrarla.

void setDisabledIcon(Icon) Selecciona u obtiene la imagen mostrada por la etiqueta cuando está desactivada. Si no se especifica



22 de 38

Icon getDisabledIcon() esta imagen, el aspecto y comportamiento crea una manipulando la imagen por defecto.

Ajuste Fina de la Apariencia de la Etiqueta

Método Propósito

void setHorizontalAlignment(int)

void setVerticalAlignment(int)


int getVerticalAlignment()

Selecciona u obtiene donde debería mostrarse el contenido de la etiqueta. El Interface SwingConstants define tres posibles valores para el alineamiento horizontal: LEFT (por defecto para etiquetas de sólo texto), CENTER (por defecto para etiquetas de sólo imagen), o LEFT; y tres para alineación vertical: TOP, CENTER (por defecto), y BOTTOM.

void setHorizontalTextPosition(int)

void setVerticalTextPosition(int)

int getHorizontalTextPosition()

int getVerticalTextPosition()

Selecciona u obtiene dónde debería mostrarse el texto del botón con respecto a su imagen. El interface SwingConstants define tres posibles valores para posición horizontal: LEFT, CENTER, y LEFT (por defecto); y tres para posición vertical: TOP, CENTER (por defecto), y BOTTOM.

void setIconTextGap(int)

int getIconTextGap()

Selecciona u obtiene el número de pixels entre el texto de la etiqueta y su imagen.

Actividad: Crear una etiqueta con el texto “Cantidad”. Posicionarla en la parte de arriba de la ventana. Mirar el API de JComponent y Component para tratar con la apariencia del texto.

2.5. JTextField

Los componentes de texto muestran algún texto y opcionalmente permiten que el usuario lo edite. Los paquetes Swing proporcionan cinco componentes de texto y proporcionan clases e interfaces para conseguir los requerimientos más complejos. Sin importar sus diferentes usos capacidades,



23 de 38

todos los componentes de texto Swing descienden de la misma superclase, JtextComponent.

Las siguientes tablas listan los constructores y métodos más comúnmente utilizados de JTextField. Otros métodos a los que se podría llamar están definidos en las clases JComponent y Component. Estos incluyen los métodos setForeground, setBackground, y setFont.

Además, podrías querer llamar a algunos de los métodos definidos en la clase padre de JTextField, JTextComponent.

Seleccionar u Obtener el Contenido de un Campo de Texto

Método o Constructor

Propósito

JTextField()

JTextField(String)

JTextField(String, int)

JTextField(int)

JTextField(Document, String, int)

Crea un ejemplar de JTextField, inicializando su contenido al texto especificado. El argumento int seleccionar el número de columnas. Esto se utiliza para definir la anchura preferida del componente y podría no ser el número de columnas realmente mostradas.


String getText()

Seleccion u obtiene el texto mostrado por el campo de texto.



24 de 38

Ajuste de la Apariencia de un Campo de Texto

Método o Constructor Propósito

void set Editable(boolean)

boolean is Editable()

Selecciona u obtiene si el usuario puede editar el texto del campo del texto.

void setForeground(Color)

Color getForeground()

Selecciona u obtiene el color del texto en el campo de texto.

void setBackground(Color);

Color getBackground()

Selecciona u obtiene el color del fondo del campo de texto

void setFont(Font);

Font getFont()

Selecciona u obtiene la fuente utilizada por el campo de texto.

void setColumns(int);

int getColumns()

Selecciona u obtiene el número de columnas mostradas por el campo de texto.

int getColumnWidth() Obtiene la anchura de las columnas del campo de texto. Este valor es establecido implícitamente por la fuente usada.

void setHorizontalAlignment(int);


Selecciona u obtiene cómo se alinea el texto horizontalmente dentro de su área. Se puede utilizar JTextField.LEFT, JTextField.CENTER, y JTextField.LEFT como argumentos.

Actividad: Crear un campo de texto para introducir la cantidad a convertir. Ese campo irá después de la etiqueta creada en el apartado anterior.

2.6. JComboBox

Permite al usuario seleccionar un valor desde una lista. Puede ser editable o no.



25 de 38

Las siguientes tablas listan los métodos y constructores más utilizados de JComboBox.

Seleccionar u Obtener Ítems de la Lista del ComboBox

Método Propósito

JComboBox(ComboBoxModel)

JComboBox(Object[])

JComboBox(Vector)

JComboBox()

Crea un ComboBox con una lista predeterminada.

void addItem(Object)

void insertItemAt(Object, int)

Añade o inserta un ítem en la lista.

Object getItemAt(int)

Object getSelectedItem() Obtiene un ítem de la lista.

void removeAllItems()

void removeItemAt(int)

void removeItem(Object)

Elimina uno o más ítems de la lista.

int getItemCount() Obtiene el número de ítems de la lista.

void setModel(ComboBoxModel)

ComboBoxModel getModel()

Selecciona u obtiene el modelo de datos que proporciona los ítems de la lista.

Personalizar la Configuración del ComboBox

Método Propósito



26 de 38

void setEditabe(boolean)

boolean is Editable()

Selecciona u Obtiene si el usuario puede teclear en el ComboBox.

void setRenderer(ListCellRenderer)

ListCellRenderer getRenderer()

Selecciona u obtiene el objeto responsable para crear el ítem seleccionado en el ComboBox. Utilizado cuando el ComboBox no es editable.

void setEditor(ComboBoxEditor)

ComboBoxEditor getEditor()

Selecciona u obtiene el objeto responsable del pintado y edición del ítem seleccionado en el ComboBox. Esto sólo se utiliza cuando el ComboBox es editable.

Actividad: Crear una lista desplegable con un conjunto de divisas. Será no editable y se situará detrás del campo de texto.

2.7. JRadioButton

Los Botones de Radio son grupos de botones en los que, por convención, sólo uno de ellos puede estar seleccionado. Swing soporta botones de radio con las clases JRadioButton y ButtonGroup.

Para cada grupo de botones de radio, se necesita crear un ejemplar de ButtonGroup y añadirle cada uno de los botones de radio. El ButtonGroup tiene cuidado de desactivar la selección anterior cuando el usuario selecciona otro botón del grupo.

Métodos y Constructores más utilizados de ButtonGroups

Método Propósito

ButtonGroup() Crea un ejemplar de ButtonGroup.

void add(AbstractButton)

void remove(AbstractButton)

Añade un botón a un grupo, o elimina un botón de un grupo.



27 de 38

Actividad: Crear dos radiobuttons cuyo texto será “Todos” y “Seleccionados”. Este grupo de botones se situará en la parte central de la ventana.

2.8. JCheckBox

Los Checkboxes son similares a los botones de radio, pero su modelo de selección es diferente, por convención. Cualquier número de checkboxes en un grupo -- ninguno, alguno o todos -- puede ser seleccionados.

Actividad: Crear por cada una de las divisas que se van a calcular un checkbox con su nombre y un campo donde poder mostrar el resultado de la cantidad a convertir. Este conjunto de componentes irá en la parte central de la ventana, debajo de los botones de radio.

2.9. JMenuBar

Los menús son los únicos en que, por convención, no se sitúan 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 más menús, y tiene una posición 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 acción del ratón específica de la plataforma, como pulsar el botón derecho del ratón sobre un componente. Entonces el menú desplegable aparece bajo el cursor.

Las siguientes tablas listan los métodos y constructores más utilizados de JMenuBar. El API se divide en estas categorías.

Crear y Configurar Barras de Menú

Método Propósito

JMenuBar() Crea una barra de menú.

void Selecciona u obtiene la barra de menú de un applet,



28 de 38

setJMenuBar(JMenuBar)

JMenuBar getJMenuBar()

(en JApplet, JDialog, JFrame, JRootPane)

dialog, frame, o root pane. En las siguientes versiones de Swing y del JDK 1.2, los frames internos también soportarán estos métodos.

void setMenuBar(JMenuBar)

JMenuBar getMenuBar()

(en JInternalFrame)

Selecciona u obtiene la barra de menú de un Frame interno. En las siguientes versiones de Swing y del JDK 1.2, este método será anulado y deberíamos utilizar setJMenuBar/getJMenuBar.

Crear y Rellenar Menús

Método Propósito

JMenu() Crea un menú.

JMenuItem add(JMenuItem)

JMenuItem add(Action)

void add(String)

Añade un ítem de menú al final del menú. Si el argumento es un objeto Action, el menú crea un ítem de menú como se describe en Cómo usar Actions. Si el argumento es un string, el menú crea automáticamente un objeto JMenuItem que muestra el texto especificado.

void addSeparator() Añade un separador la final del menú.

JMenuItem insert(JMenuItem, int)

JMenuItem insert(Action, int)

void insert(String, int)

void insertSeparator(int)

Inserta un ítem de menú o un separador en un menú, en la posición especificada. El primer ítem de menú es la posición 0, el segundo la posición 1, etc. Los argumentos JMenuItem, Action, y String se tratan de la misma forma que en los correspondientes métodos add.

void remove(JMenuItem)

Elimina el ítem o ítems especificados del menú. Si el argumento es un entero, especifica la posición del ítem a eliminar.



29 de 38

void remove(int)

void removeAll()

Implementar Ítems de Menú

Método Propósito

JMenuItem()

JMenuItem(Icon)

JMenuItem(String)

JMenuItem(String, Icon)

JMenuItem(String, int)

Crea un ítem de menú normal. El argumento icon, si existe, especifica el icono que debería mostrar el ítem de menú. Igualmente el argumento String, especifica el texto que debería mostrar el ítem de menú. El argumento entero especifica el mnemónico de teclado a utilizar. Se puede especifar una de las constantes VK definidas en la clase KeyEvent. Por ejemplo, para especificar "a" como el mnemónico, podemos utilizar KeyEvent.VK_A.

JCheckBoxMenuItem()

JCheckBoxMenuItem(Icon)

JCheckBoxMenuItem(String)

JCheckBoxMenuItem(String, Icon)

JCheckBoxMenuItem(String, boolean)

JCheckBoxMenuItem(String, Icon, boolean)

Crea un ítem de menú que se parece y actúa 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 existe, especifica el texto que debería mostrar el ítem de menú. Si se especifica true para el argumento booleano, el ítem de menú estará inicialmente seleccionado. De lo contario el ítem de menú está desactivado.

JRadioButtonMenuItem()

JRadioButtonMenuItem(Icon)

JRadioButtonMenuItem(String)

JRadioButtonMenuItem(String, Icon)

Crea un ítem de menú que se parece y actúa 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 debería mostrar el ítem de menú. El ítem de menú está inicialmente desactivado.



30 de 38

void setState(boolean)

boolean getState()

Selecciona u obtiene el estado de selección de un ítem de menú.

void setEnabled(boolean) Si el argumento es true, activa el ítem de menú, si es false lo desactiva.

public class Menu extends JMenuBar {

public Menu() {

/…

JMenu menuArchivo = new JMenu("Archivo");

JMenuItem itemArchivo = new JMenuItem("Salir");

menuArchivo.add(itemArchivo);

add( menuArchivo);

}

}

Actividad: Crea un menu para nuestra aplicación con las siguientes entradas: Archivo-Salir y Ayuda-Sobre ...

2.10. Otros Componentes

Otros componentes que podéis encontrar son:

• JscrollPane: 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 visualización, sino que también se encarga de proporcionar



31 de 38

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.

• JOptionPane: Proporciona soporte para mostrar diálogos estándares, proporcionando iconos, especificando el título y el texto del diálogo, y personalizando el texto del botón. Otras características permiten personalizar los componentes del diálogo a mostrar y especificar si el diálogo debiese aparecer en la pantalla.

• JToggleButton: se trata de una clase que no tiene equivalentes en AWT. Representa un botón que se mantiene presionado aunque dejemos de presionar con nuestro ratón sobre él, pero visualmente no se difiere de un Jbutton cuando no está activado.

• JTextPane: se trata también de un panel para visualizar texto, con la salvedad de que tiene 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 ventana interior a un JdesktopPane. Como ventana interior puede ser movida, cerrada, o iconizada.

• JTable: este componente presenta una rejilla en la que se puede colocar cualquier componente swing.

• JPasswordField: se encuentra justo por debajo de Jtextfield en la jerarquía de componentes, y permite la edición de texto sin realizar un eco de los caracteres tecleados en pantalla, que son sustituidos por un carácter “*”.

• JTextArea: hereda de JtextComponet, 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



32 de 38

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 de una 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.

2.11. Cómo funciona el dibujo

Cuando un GUI Swing necesita dibujarse a sí mismo -- la primera vez, o en respuesta a la vuelta de un ocultamiento, o porque necesita reflejar un cambio en el estado del programa -- empieza con el componente más alto que necesita ser redibujado y va bajando por el árbol de contenidos. Esto está orquestado por el sistema de dibujo del AWT.

Los componentes Swing generalmente se redibujan a sí mismos siempre que es necesario. Por ejemplo, cuando llamamos al método setText de un componente, el componente debería redibujarse automáticamente a sí mismo, y si es necesario, redimensionarse.

El método repaint sobre el componente pide que el componente se ponga en la cola para redibujado. Si se necesita cambiar el tamaño o la posición del componente pero no automáticamente, deberíamos llamar al método revalidate sobre el componente antes de llamar a repaint.

El código de dibujo se ejecuta en el thread del despacho de eventos (ver sección 3.1). Mientras se esté manejando un evento no ocurrirá ningún dibujo. De forma similar, si la operación de dibujado tarda mucho tiempo, no se manejará ningún evento durante ese tiempo.

Los programas sólo deberían dibujarse cuando el sistema de dibujo se lo diga. La razón es que cada ocurrencia de dibujo de un propio componente debe ser ejecutado sin interrupción. De otro modo, podrían ocurrir resultados impredecibles, como que un botón fuera dibujado medio pulsado o medio liberado.



33 de 38

Para acelerar, el dibujo Swing usa doble-buffer por defecto -- realizado en un buffer fuera de pantalla y luego lanzado a la pantalla una vez finalizado. Podría ayudar al rendimiento si hacemos un componente Swing opaco, para que el sistema de dibujo de Swing pueda conocer lo que no tiene que pintar detrás del componente. Para hacer opaco un componente Swing, se llama al método setOpaque(true) sobre el componente.

Los componentes no-opacos de Swing puede parecer que tienen cualquier forma, aunque su área de dibujo disponible es siempre rectangular. Por ejemplo, un botón podría dibujarse a sí mismo dibujando un octógono relleno. El componente detrás del botón, (su contenedor, comúnmente) sería visible, a través de las esquinas de los lados del botón.

3. Manejo de eventos

Cada vez que el usuario teclea un carácter o pulsa un botón del ratón, ocurre un evento. Cualquiera puede ser notificado del evento. Todo lo que tiene que hacer es implementar la interface apropiado y ser registrado como un oyente de evento del evento fuente apropiado. Los componentes Swing pueden generar muchas clases de evento, incluyendo los de java.awt.event y por supuesto, los de javax.swing.event. Algunos de estos nuevos tipos de eventos de Swing son específicos del componente. Aquí hay unos pocos ejemplos:

Acción que resulta en el evento Tipo de oyente

El usuario pulsa un botón, presiona Return mientras teclea en un campo de texto, o elige un ítem de menú.

ActionListener

El usuario elige un frame (ventana principal). WindowListener

El usuario pulsa un botón del ratón mientras el cursor está sobre un componente.

MouseListener

El usuario mueve el cursor sobre un componente. MouseMotionListener

El componente se hace visible. ComponentListener

El componente obtiene el foco del teclado. FocusListener

Cambia la tabla o la selección de una lista. ListSelectionListener



34 de 38

KeyListener

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.

Todo manejador de eventos requiere tres partes de código.

1. Donde se declare la clase del manejador de eventos, el código especifica que la clase o implementa una interface de oyente, o desciende una clase que implementa una interface de oyente. Por ejemplo:

public class MyClass implements ActionListener {

2. El código que registra un ejemplar de la clase de manejo de eventos de un oyente sobre uno o más componentes. Por ejemplo:

someComponent.addActionListener(instanceOfMyClass);

3. La implementación de los métodos de la interface oyente. Por ejemplo:

public void actionPerformed(ActionEvent e) {

...//código para responder a la acción

}



35 de 38

3.1. Hilo de despacho de eventos (Event-dispatching thread)

Todos los eventos se procesan por los oyentes que los reciben dentro del hilo de despacho de eventos (una instancia de java.awt.EventDispatchThread). Todo el dibujo y posicionamiento de componentes debería llevarse a cabo en este hilo. El hilo de despacho de eventos es de vital importancia en Swing y AWT, y juega un papel principal manteniendo actualizado el estado y la visualización de un componente en una aplicación bajo control.

Asociada con este hilo hay una cola FIFO (primero que entró - primero que sale) de eventos -- la cola de eventos del sistema (una instancia de java.awt.EventQueue). Esta cola se rellena, como cualquier cola FIFO, en serie. Cada petición toma su turno para ejecutar el código de manejo de eventos, que puede ser para actualizar las propiedades, el posicionamiento o el repintado de un componente. Todos los eventos se procesan en serie para evitar situaciones tales como modificar el estado de un componente en mitad de un repintado. Tenemos que estar seguros de que el código de manejo de eventos se puede ejecutar rápidamente. En otro caso toda la cola de eventos del sistema se bloquearía esperando a que terminase el proceso de un evento, el repintado, o el posicionamiento, y nuestra aplicación parecería bloqueada o congelada.

3.2. Oyente de Action

Cuando un usuario pulsa un button, elige un menu ítem o pulsa Return en un text field, ocurre un evento actio. El resultado es que se envía un mensaje actionPerformed a todos los oyentes de action que estén registrados con un componente en particular.

Si tenemos dos o más componentes que realizan la misma funcion, podemos considerar la utilización de un objeto Action para implementar la función. Un objeto Action es un ActionListener que no sólo proporciona manejo de eventos, sino que también centraliza el manejo de texto, iconos, y estados de enable de tool bar, buttons, o itéms de menu.

El interface ActionListener contiene un sólo método, y no tiene la correspondiente clase adaptadora.

void actionPerformed(ActionEvent)



36 de 38

Actividad: Crear un ActionListener que permita salir de la aplicación. Esta Action será compartida tanto por el botón “Salir” y la opción del mismo nombre del menú Archivo.

--------------------Hasta aquí----------------------------------------

3.3. Entrada de teclado, KeyStrokes, y Actions

2.13.1 Escuchando la entrad de teclado

Se lanzan KeyEvents por un componente siempre que el componente tiene el foco y el usuario pulsa una tecla. Para escuchar estos eventos en un componente particular podemos añadir KeyListeners usando el métodos addKeyListener(). KeyEvent desciende de InputEvent y, al contrario que la mayoría de los eventos, los KeyEvents se despachan antes de que la operación correspondiente tome parte (p.e. en un cuadro de texto la operación podría ser añadir un carácter específico al contenido del documento). Podemos consumir estos eventos usando el método consume() antes de que se manejen más adelante por asociaciones de teclas u otros oyentes. (más adelante veremos exactamente como tener notificación de la entrada de teclado, y en que orden ocurre ésta).

Hay tres tipos de eventos KeyEvent, cada uno de los cuales ocurre por lo menos una vez cada activación de teclado (p.e. pulsar y soltar una tecla del teclado):

KEY_PRESSED: este tipo de evento de tecla se genera cuando una tecla del teclado se pulsa. La tecla que se ha pulsado queda especificada por la propiedad keyCode y un código virtual de la tecla se puede obtener con el método getKeyCode() de KeyEvent. Un código virtual de tecla se usa para informar de la tecla exacta del teclado que ha causado el evento, tal como KeyEvent.VK_ENTER. KeyEvent define numerosas constantes estáticas de tipo int, que empiezan con el prefijo “VK,” que significa Virtual Key (tecla virtual) (ver los documentos del API de KeyEvent para una lista completa). Por ejemplo, si se pulsa CTRL-C, se lanzarán dos eventos KEY_PRESSED. El int devuelto por getKeyCode() correspondiente a pulsar CTRL será un KeyEvent.VK_CTRL. Igualmente, el int devuelto por getKeyCode() correspondiente a pulsar la tecla “C” será un KeyEvent.VK_C. (Observe que el orden en el que se lanzan depende del orden en el que se pulsan.) KeyEvent también tiene un propiedad keyChar que especifica la representación Unicode del carácter pulsado (si no hay representación Unicode se usa KeyEvent.CHAR_UNDEFINED--p.e. las teclas de función de un teclado normal de PC). Podemos



37 de 38

obtener el carácter keyChar correspondiente a un KeyEvent usando el método getKeyChar(). Por ejemplo, el carácter devuelto por getKeyChar() correspondiente a pulsar la tecla “C” será ‘c’. Si estaba pulsado SHIFT cuando se pulsó la tecla “C”, el carácter devuelto por getKeyChar() correspondiente a la tecla “C” será ‘C’. (Observe que se devuelven distintos keyChars para mayúsculas y minúsculas, a pesar de que se usa el mismo keyCode en ambas situaciones--p.e. el valor VK_C se será devuelto por getKeyCode() esé pulsada o no la tecla SHIFT cuando se pulsa la tecla “C”. Observe también que no hay keyChar asociado con teclas como CTRL, y getKeyChar() devolverá simplemente ‘’ en este caso.) KEY_RELEASED: este tipo de evento de teclado se genera cuando se suelta una tecla. Salvo por esta diferencia, los eventos KEY_RELEASED son idénticos a los eventos KEY_PRESSED (aunque, como veremos más adelante, ocurren mucho menos a menudo). KEY_TYPED: este tipo de eventos se lanzan en algún momento entre un evento KEY_PRESSED y un evento KEY_RELEASED. Nunca contiene una propiedad keyCode correspondiente a la tecla pulsada, y se devolverá 0 siempre que se llame a getKeyCode() en un evento de este tipo. Observe que para teclas sin representación Unicode (como RE PAG, PRINT SCREEN, etc.), no se lanzará el evento KEY_TYPED. La mayoría de las teclas con representación Unicode, cuando se mantienen pulsadas durante un rato, generarán repetidos KEY_PRESSED y KEY_TYPED (en este orden). El conjunto de teclas que muestran este comportamiento, y el porcentaje en que lo hacen, no se puede controlar y depende de la plataforma. Cada KeyEvent mantiene un conjunto de modificadores que especifica el estado de las teclas SHIFT, CTRL, ALT, y META. Este es un valor de tipo int que es el resultado de un or binario entre InputEvent.SHIFT_MASK, InputEvent.CTRL_MASK, InputEvent.ALT_MASK, y InputEvent.META_MASK (dependiendo de que teclas están pulsadas en el momento del evento). Podemos obtener este valor con getModifiers(), y podemos comprobar específicamente cual de estas teclas estaba pulsada en el momento en que se lanzó evento usando isShiftDown(), isControlDown(), isAltDown(), y isMetaDown(). KeyEvent también contiene la propiedad booleana actionKey que especifica si la tecla que lo ha lanzado corresponde a una acción que debería ejecutar la aplicación (true) o si son datos que se usan normalmente para cosas como la adición de contenido a un componente de texto (false). Podemos usar el método isActionKey() de KeyEvent para obtener el valor de esta propiedad. 2.13.2 KeyStrokes El uso de KeyListeners para manejar la entrada de teclado componente por componente era necesario antes de Java 2. A causa de esto, una significativa, y a menudo tediosa, cantidad de tiempo se gastaba planificando y depurando operaciones de teclado. El equipo de Swing se percató de esto, e incluyó la funcionalidad de interceptar eventos de teclado sin tener en cuenta el componente que tenga el foco. Esta funcionalidad está implementada usando asociaciones de instancias de la clase javax.swing.KeyStroke con ActionListeners (normalmente instancias de

javax.swing.Action).

3.4. Modelo de datos

Hacer un modelo para el JtextField.



38 de 38

Actividad: Se puede crear una clase que extienda de JTextField y que sólo acepte formato numérico.

3.5. AWT vs Swing

3.6. Adaptadores

3.7. JButton

3.8. JCheckBox

4. Direcciones Web

• Página principal de JFC:

http://java.sun.com/products/jfc/

• Guías de diseño JAVA Look and Feel

http://java.sun.com/products/jlf/ed1/dg/index.htm

• Repositorio de gráficos Java Look and Feel

http://developer.java.sun.com/developer/techDocs/hi/repository/

• Tutorial de Swing en español

http://programacion.com/java/swing/

intro swing

Documents

interfaz grfica

java foundation clases

ajuste fina

campo de texto

tems de men

barras de men

componentes grficos

constructores ms utilizados