04 Contenido POOII V5

PROGRAMACIÓN ORIENTADA A OBJETOS II
SEMANA 4
Diseño de GUI
(Interfaz Gráfica de Usuario)
Todos los derechos de autor son de la exclusiva propiedad de IACC o de los otorgantes de sus licencias. No está
permitido copiar, reproducir, reeditar, descargar, publicar, emitir, difundir, poner a disposición del público ni 1
ESTE
utilizarDOCUMENTO
los contenidos paraCONTIENE LAdeSEMANA
fines comerciales 4
ninguna clase.
2
ESTE DOCUMENTO CONTIENE LA SEMANA 4
ÍNDICE
DISEÑO DE GUI (INTERFAZ GRÁFICA DE USUARIO)............................................................................. 4

OBJETIVOS ESPECÍFICOS ........................................................................................................................... 4
INTRODUCCIÓN ...................................................................................................................................... 4
1. SWING Y JFC ................................................................................................................................ 5
1.1. SWING VS. AWT ................................................................................................................. 5
1.2. MANEJO DE EVENTOS ........................................................................................................ 6
1.3. JERARQUÍA DE COMPONENTES SWING........................................................................... 09
1.4. INTERFACES LISTENER...................................................................................................... 13
2. GESTORES DE SWING ................................................................................................................ 15
2.1. GESTOR DE DISEÑO FLOWLAYOUT .................................................................................. 16
2.2. GESTOR DE DISEÑO BORDERLAYOUT .............................................................................. 18
2.3. GESTOR DE DISEÑO GRIDLAYOUT.................................................................................... 23
3. COMPONENTES DE SWING ....................................................................................................... 26
3.1. LA CLASE JTEXTAREA ........................................................................................................ 26
3.1.1. CONSTRUCTORES .................................................................................................... 26
3.1.2. MÉTODOS ................................................................................................................ 29
3.2. LA CLASE JCHECKBOX ....................................................................................................... 33
3.2.1. CONSTRUCTORES .................................................................................................... 33
3.2.2. MÉTODOS ................................................................................................................ 36
3.3. LA CLASE JRADIOBUTTON ................................................................................................ 39
3.3.1. CONSTRUCTORES .................................................................................................... 40
3.3.2. MÉTODOS ................................................................................................................ 42
3.4. LA CLASE JCOMBOBOX..................................................................................................... 45
3.4.1. CONSTRUCTORES .................................................................................................... 45
3.4.2. MÉTODOS ................................................................................................................ 49
COMENTARIO FINAL.......................................................................................................................... 54
REFERENCIAS........................................................................................................................................ 55
3
DISEÑO DE GUI (INTERFAZ GRÁFICA DE USUARIO)
OBJETIVOS ESPECÍFICOS
 Distinguir la utilización de Swing y AWT para el diseño gráfico de aplicaciones en Java.
 Utilizar gestores de Swing para el diseño de GUI en aplicaciones Java.
 Emplear diversos componentes de Swing para el desarrollo de aplicaciones en Java.
INTRODUCCIÓN
Desde que fue el apogeo de los lenguajes visuales que las interfaces gráficas de usuario han sido
un factor muy relevante en los patrones de programación. Y es así que es muy frecuente que
cuando a un programador se le están enumerando los requerimientos del cliente, ya imagina en su
mente la forma en que presentará las pantallas de su futura aplicación.
Java comenzó con los componentes provistos por AWT (Abstract Windows Toolkit), pero con el
tiempo evolucionó a Swing, que dispone de muchos y mejores componentes visuales que los
predecesores, permitiendo crear interesantes interfaces.
En esta semana se profundizará sobre los componentes que forman parte de una interfaz de
usuario, y la forma en que Java gestiona los eventos que se gatillan desde los distintos
componentes, como botones, checkbox, etc. A su vez, también se detallarán algunos gestores de
diseño, que permiten ordenar los componentes dentro de la pantalla para un trabajo más intuitivo
por parte del usuario.
4
1. SWING Y JFC
Antes de comenzar a hablar de Swing es necesario hacer mención a JFC, que es la sigla de Java
Foundation Classes, o bien, Clases Bases Java, que corresponde a un framework gráfico que
permite la generación de interfaces gráficas de usuario portables, y que se conforma de tres
herramientas (Oracle, 2010):
 AWT (Abstract Window Toolkit)
 Swing
 Java 2D
1.1. SWING VS. AWT
AWT corresponde a un conjunto de librerías cuyo foco apunta a la creación de interfaces gráficas.
En sus inicios, AWT creaba los objetos delegando su creación y comportamiento a herramientas
nativas de las plataformas donde corre la Máquina Virtual de Java. Esto trajo problemas por
diferencias en las plataformas y en los sistemas operativos, pues en varias ocasiones el
comportamiento de los componentes dependía de la plataforma en que se ejecutara. La solución
fue desarrollar los objetos de la GUI basándolos solamente en elementos básicos y que fueran
comunes a todas las plataformas, evitando de esta forma problemas de desempeño y
compatibilidad. Así entonces nace Swing.
AWT hace uso de la interfaz de usuario y componentes nativos de la plataforma, es por ello que se
les denomina “heavyweights components”, de ahí que se dieran muchos problemas de
compatibilidad. Por ejemplo, si se presentaba un textbox, se usaba el del sistema operativo. O
bien, si Windows permitía un label con imagen y Linux no, entonces esa propiedad no se
consideraba en la librería de AWT. Por eso es que se requería personalizar las aplicaciones cuando
cambiaban de plataforma. Y en situaciones ni siquiera se podía acceder a todo el kit de
herramientas disponibles. Además que estaba pensando para el uso en los navegadores antiguos,
entonces, no dispone de componentes más complejos como tablas, vistas de árbol, barras de
progreso, etc.
Así, Swing se ha transformado en una poderosa herramienta para desarrollar interfaces para
Applets y aplicaciones varias, ya que presenta una cantidad de controles, y calidad de los mismos,
que otras herramientas del mercado no logran igualar, además que presenta una mejor
portabilidad y comportamiento. Ya no utiliza los componentes correspondientes al sistema
operativo, si no que utiliza los propios, es por ello que se les denomina “lighjtweights
components”. Además, Swing está hecho en Java, haciéndolo prácticamente 100% portable, aun
cuando usa partes de AWT como base.
5
Hoy en día, además del correcto funcionamiento de un sistema, la interfaz gráfica juega un rol
demasiado importante, pues es lo que el usuario ve, y con lo que interactúa a diario.
1.2. MANEJO DE EVENTOS
Actualmente, el usuario hace uso de una aplicación, ya sea utilizando el mouse, o bien ingresando
datos desde el teclado, y generalmente termina esto último presionando la tecla <enter>. Lo
anterior, para la aplicación, constituye eventos.
Internamente, en la aplicación, los eventos dan curso a métodos que finalmente son los que
entregan las respuestas al usuario final.
En Java el manejo de eventos se delega. Es decir, el evento que ocurre en un objeto no se realiza
en el mismo objeto (fuente), sino que se delega a otro objeto (oyente), y se efectúa de la siguiente
manera:
 El objeto fuente registra e identifica cuáles son los objetos oyentes que podrían recibir
algún evento en particular.
 Cuando ocurre el evento, el objeto fuente se lo informa a todos los oyentes que tiene
registrado.
 Finalmente, para efectuar la comunicación, el objeto fuente invoca un método del objeto
oyente, cuyo argumento es el evento generado.
Ahora bien, es válido preguntarse ¿qué es un evento?. La respuesta es sencilla: de acuerdo a lo

indicado en el tutorial de Oracle (2015), un evento es un objeto que encapsula toda la información
sobre la interacción con el usuario.
Un evento, y el efecto que provoca, se conforma de tres componentes (Oracle, 2015):
1. El EventSource, que es la fuente de un evento, o el evento propiamente tal.
 Corresponde al componente de la GUI con la que el usuario interactúa.
 Se comprueba que la información sobre un evento se encuentra encapsulada.
 El evento se deriva desde java.util.EventObject hacia java.awt.AWTEvent o a

javax.swing.event.
 Diferentes fuentes de eventos producen diferentes tipos de eventos, como por ejemplo:
- ActionEvent es enviado por un botón.
- WindowEvent es enviado por una ventana.
6
2. El EventObject es el objeto que maneja el evento producido.
 Contiene la información del evento ocurrido, y la información necesaria para manejar el

evento por parte del oyente.
 Envía el evento a los objetos oyentes (listeners) registrados para el evento.
3. El EventListener es el evento oyente y es el que ejecuta el método apropiado.
 Implementa una interfaz especial y determinada para un evento.
 Determina lo que se debe hacer ante un evento en particular.
Cada tipo de evento se puede representar mediante una clase diferente. La clase base es
java.util.EventObject, cuyo único atributo es el objeto en el que se ha generado el evento, y
además solo expone un método, llamado getSource(), que develve el objeto correspondiente a la
GUI con el que el usuario ha interactuado, sea un carácter (tecla) del teclado o un botón del
mouse.
El paquete java.awt.swing.event contiene una serie de interfaces oyentes de eventos y clases de

eventos que son utilizados por los componentes de Swing. A su vez, algunos componentes Swing
manejan eventos del AWT. A continuación se muestran algunos ejemplos (Oracle, 2014f):
COMPONENTE EVENTOS DESCRIPCIÓN
Button ActionEvent Dar clic al botón
Checkbox ItemEvent Seleccionar o deseleccionar un ítem
CheckboxMenuItem ItemEvent Seleccionar o deseleccionar un ítem
Choice ItemEvent Seleccionar o deseleccionar un ítem
Component ComponentEvent Mover, cambiar tamaño, mostrar u

ocultar un componente
FocusEvent Obtener o perder el foco.
Se denominan por: GOT_FOCUS y

LOST_FOCUS
7
KeyEvent Pulsar o soltar una tecla. Se denominan
por: KEY_PRESS, KEY_RELEASE,
KEY_ACTION y KEY_ACTION_RELEASE
MouseEvent Pulsar o soltar un botón del mouse.

Entrar o salir de un componente.
Mover o arrastrar el mouse.
Se denominan por: MOUSE_DOWN,

MOUSE_UP, MOUSE_MOVE,
MOUSE_ENTER, MOUSE_EXIT,
MOUSE_DRAG
Container ContainerEvent Agrear o eliminar un componente a un

contenedor
List ActionEvent Hacer doble clic sobre un ítem de la

lista
ItemEvent Seleccionar o deseleccionar un ítem de

la lista. Se denominan por: LIST_SELECT
y LIST_DESELECT
MenuItem ActionEvent Seleccionar un ítem de un menú
Scrollbar AdjustementEvent Cambiar el valor de la scrollbar. Se

denominan por: SCROLL_LINE_UP,
SCROLL_LINE_DOWN,
SCROLL_PAGE_UP,
SCROLL_PAGE_DOWN y
SCROLL_ABSOLUTE.
TextComponent TextEvent Camiar el texto
TextField ActionEvent Terminar de editar un texto pulsando

<enter>
Window WindowEvent Acciones sobre una venana: abrir,

cerrar, iconizar, restablecer o iniciar el
cierre.
Se denominan por:
WINDOW_DESTROY,
WINDOW_EXPOSE, WINDOW_ICONIFY,
WINDOW_DEICONIFY,
WINDOW_MOVED
8
La jerarquía de eventos se muestra a continuación:
Fuente: http://www.javaprepare.com/notes/events.html
Con respecto a los objetos oyentes (listener de aquí en adelante), la gestión de registro y
eliminación se realiza de la siguiente manera (Odelys, s.f.):
 set<TipoEvento>Listener(): define un único objeto oyente para el tipo de evento indicado.
 add<TipoEvento>Listener(): agrega el objeto a la lista de oyentes.
 remove<TipoEvento>Listener(): elimina el objeto oyente.
Más adelante se hablará en más detalle sobre la interfaz Listener.
1.3. JERARQUÍA DE COMPONENTES SWING
El siguiente cuadro muestra la jerarquía de componentes Swing. Evidentemente también se

mencionan los referentes a AWT, pues las principales clases Swing heredan el comportamiento de
algunas AWT.
9
Fuente: http://www.jroller.com/DhilshukReddy/entry/java_swing_components_hierarchy
El desglose de la clase JComponent se muestra a continuación:
10
Fuente: http://flylib.com/books/en/2.715.1.15/1/
Con lo anterior, en una aplicación todos los objetos gráficos forman una jerarquía, y la jerarquía
mayor está presente en un JFrame, o un JDialog, o un JApplet.
A continuación se muestra la estructura de un JFrame, que se compone de:
 RootPane, que viene junto con el JFrame. También lo traen los JInternalFrame y los otros
contenedores de ventanas superiores, como JDialog y JApplet.
 El RootPane tiene 4 partes: vidrio, panel de capas, panel de contenido y una barra de
menú opcional.
11
Fuente: http://www.codeproject.com/Articles/33536/An-Introduction-to-Java-GUI-Programming
A continuación se muestra un ejemplo muy simple del uso de JFrame y la forma en que se agregan
componentes a la jerarquía y en el que también se hace uso de eventos. Cabe mencionar que toda
aplicación swing debe comprender, al menos, un contenedor de alto nivel (JFrame, JWindow,
JApplet, JDialog).
12
La salida es:
En este ejemplo se hace uso de un contenedor de alto nivel como es JFrame, y sobre él se agrega
un objeto JLabel con una determinada etiqueta.
Para cerrar la ventana, se usó el método addWindowListerner(…..), pero también se podría haber
usado el siguiente código, que hace exactamente lo mismo:
miFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
1.4. INTERFACES LISTENER
Como se mecionó anteriormente, las interfaces Listener permiten manejar la captura de los
eventos. En Java, cada tipo de evento cuenta con su clase (o interface) Listerner.
De acuerdo a la mencionado en Oracle (2014a), algunas interfaces Listener son las siguientes:
Interface Descripción Método

ActionListener Se ejecuta algún comando o acción. actionPerformed(ActionEvent)
AdjustmentListener Se ajusta algún valor. adjustmentValueChanged(AdjustmentEvent)
ComponentListener El componente se oculta. componentHidden(ComponentEvent)
El componente se mueve. componentMoved(ComponentEvent)
El componente se redimensiona. componentResized(ComponentEvent)
El componente se visualiza componentShown(ComponentEvent)
ContainerListener Se agrega un componente al componentAdded(ContainerEvent)
contenedor.
Se elimina un componente del componentRemoved(ContainerEvent)
contenedor.
FocusListener El componente obtiene el foco. focusGained(FocusEvent)
El componente pierde el foco. focusLost(FocusEvent)
ItemListener Se modifica el estado de algún itemStateChanged(ItemEvent)
elemento del componente.
KeyListener Se ha pulsado una tecla. keyPressed(KeyEvent)
Se ha soltado una tecla. keyReleased(KeyEvent)
Se ha tecleado un caracter. keyTyped(KeyEvent)
MouseListener Se ha clickeado el botón del mouse. mouseClicked(MouseEvent)
El puntero del mouse ha entrado en el mouseEntered(MouseEvent)
componente.
El puntero del mouse ha salido del mouseExited(MouseEvent)
componente.
Se ha dado clic a algún botón del mousePressed(MouseEvent)
13
mouse.
Se ha soltado el botón del mouse. mouseReleased(MouseEvent)
MouseMotionListener Se ha desplazado el mouse con el mouseDragged(MouseEvent)
botón presionado.
El puntero del mouse ha cambiado de mouseMoved(MouseEvent)
posición.
TextListener El contenido del texto del componente textValueChanged(TextEvent)
ha cambiado.
WindowListener La ventana ha sido activada. windowActivated(WindowEvent)
La ventana se ha cerrado. windowClosed(WindowEvent)
Se ha solicitado cerrar la ventana. windowClosing(WindowEvent)
La ventana ha sido desactivada. windowDeactivated(WindowEvent)
Se restaura la ventana a su tamaño windowDeiconified(WindowEvent)
original o se maximiza.
La ventana se ha minimizado. windowIconified(WindowEvent)
La ventana se ha abierto. windowOpened(WindowEvent)
A continuación se muestra un ejemplo de la funcionalidad de un botón dentro de un JFrame:
Y se obtiene una ventana con un botón, que crece de acuerdo a cómo crece la ventana.
Al dar clic en el botón, se obtiene:
14
2. GESTORES DE SWING
Sin duda, lo que hace atractiva a una aplicación es la capa de presentación, más conocida como
Look and Feel, ya que es la forma en que el usuario interactúa con la aplicación. Entonces, una
buena gestión de los componentes (objetos) dentro de la pantalla permitirá que para el usuario
sea agradable utilizar la aplicación.
El concepto de Look and Feel es mucho más amplio que lo mencionado anteriormente, sin
embargo, el contenido que se presenta a continuación muestra las distintas “distribuciones” en
pantalla que Java ofrece para la gestión del diseño, lo que dicho en pocas palabras corresponde al
proceso que determina el tamaño y ubicación de los componentes dentro de un contenedor,
considerando el tamaño disponible, la resolución del monitor y/o las características del sistema de
ventanas de la plataforma donde se ejecuta.
La gestión es intrínsecamente recursiva y avanza de arriba hacia abajo en la jerarquía de

contenedores, es decir, si un contenedor (externo) contiene a otro (interno), el primero no puede
ubicar al segundo, ni redimensionarse a sí mismo hasta conocer el tamaño que necesitará el
segundo.
Algunas razones para aplicar gestión de diseño (Universia, s.f.):
 No se conoce a ciencia cierta el tamaño que tendrá la aplicación (ventana principal).

 Java conoce, casi mejor que el programador, el tamaño que tendrán los componentes.
Aunque haciendo varias pruebas, se podría medir, por ejemplo, el tamaño de un JLabel.
Sin embargo, para un sistema podría tener el tamaño correcto, pero si se ejecuta en otro,
que posee fuentes distintas, el tamaño del JLabel no será el previsto o el esperado.
 Si se ha diseñado una GUI, es muy probable que se deseen hacer algunos cambios que
puedan poner en peligro un diseño realizado “a mano”. Pero con un gestor de diseño, el
nuevo diseño se mostrará automáticamente, aunque si hay definiciones “a mano”, no es
simple volver a configurar los cambios.
Además, Swing rediseñará automáticamente una GUI cuando (op. cit.):
15
 Se hace visible por primera vez.
 Se añade o se borra un componente.
 Cambia el tamaño de un componente porque el usuario lo modifica físicamente
(redimensionando el tamaño de la ventana) o por un cambio de contenidos (por ejemplo,
el cambio de una etiqueta).
Sin embargo, los contenedores Swing poseen gestores de diseño por defecto, por ejemplo, un
panel de contenidos de JFrame utiliza BorderLayout, y un JPanel utiliza FLowLayout.
A continuación se explican los 3 gestores principales: FlowLayout, BorderLayout y GridLayout
2.1. GESTOR DE DISEÑO FLOWLAYOUT
El gestor de diseño FlowLayout es el más simple de todos. El diseño lo realiza agregando

componentes de izquierda a derecha hasta que no alcancen más según el ancho del contenedor. Si
llega al “tope” del ancho, continúa en una segunda línea de componentes, y así sucesivamente.
Cabe destacar que cada línea está centrada dentro del componente que la contiene, y además
considera un tamaño preferido para cada componente, y lo utiliza para anular alguna dimensión
establecida por el método setsize().
A continuación se muestra un ejemplo en que se agregan 10 labels a la pantalla. Los labels impares
se configuran con letra Arial negrita y con borde rojo, mientras que los pares con letra Courier
cursiva y con borde azul. Lo anterior se logra con el uso de los métodos setFont y setBorder.
16
La salida obtenida es:
17
Si se redimensionan los bordes de la pantalla, entonces se reordenan los componentes. Por
ejemplo:
2.2. GESTOR DE DISEÑO BORDERLAYOUT
El gestor de diseño BorderLayout delinea los componentes de acuerdo a cinco zonas establecidas,
denominadas PAGE_START, PAGE_END, LINE_START, LINE_END y CENTER, las que generalmente
se asocian a los puntos cardinales: NORTH, SOUTH, WEST, EAST y CENTER, respectivamente.
18
Cuando se agrega un componente con el método add, se debe añadir un parámetro de tipo String
que indica la zona en que se agregará, por ejemplo:
add( new JButton("Aceptar"), "Center" )
Donde “Center” indica BorderLayout.CENTER.
Un BorderLayout puede ampliar horizontalmente sus componentes Norte y Sur (si es que existen),
verticalmente sus componentes Este y Oeste, y de ambos modos el componente Centro.
A continuación se muestra un ejemplo donde se agregan componentes a cada una de las 5 zonas,
y además los paneles izquierdo y derecho se configuran con el diseño FlowLayout para ordenar sus
componentes.
19
20
Cabe mencionar que no es necesario hacer uso de todas las zonas de las que dispone este estilo de
diseño. Dependiendo de la necesidad, podrían ser necesarias solamente las zonas NORTH, CENTER
y SOUTH. Para esto, el administrador de diseño utilizará la misma filosofía, es decir, que el
componente del centro ocupe el máximo de espacio disponible, y los situados en la parte superior
e inferior solo el espacio necesario para mostrar su contenido.
Por ejemplo, si del ejercicio anterior se quitasen los paneles izquierdo y derecho, comentando las
líneas
frame.add(miPanelIzquierda,BorderLayout.WEST);
frame.add(miPanelDerecha,BorderLayout.EAST);
y
creaPanelIzquierda();
21
creaPanelDerecha();
se tendría lo siguiente:
Si se redimensiona la ventana, se obtiene:
Se puede apreciar que solo cambió de tamaño (altura) la zona central, sin embargo, el encabezado
(zona norte) y las opciones (zona sur) mantienen su altura.
22
2.3. GESTOR DE DISEÑO GRIDLAYOUT
El gestor de diseño GridLayout diseña los componentes en una cuadrícula rectangular. La idea es
que el contenedor se divida en rectángulos iguales, y se posicione un componente en cada
rectángulo.
En este estilo, en el constructor normal se pueden especificar la cantidad de filas o de columnas,

pero no ambas. La que es distinta de cero se mantiene fija, y la otra aumenta según la cantidad de
componentes que se agregan.
Por ejemplo, en el siguiente código, se indica que se diseña un JFrame cuadriculado con 3
columnas. La cantidad de filas va a depender de los componentes que se la agreguen.
getContentPane().setLayout( new GridLayout(0, 3))
Se tiene otro constructor que indica el espacio que existirá entre los componentes del contenedor.
El siguiente ejemplo indica que se diseña un JFrame cuadriculado con 3 columnas, donde la
separación horizontal de los componentes es de 15 pixels, y la vertical de 5 pixels.
getContentPane().setLayout( new GridLayout(0, 3, 15, 5))
Cabe mencionar que los componentes agregados basan su orden según la propiedad
componentOrientation del contenedor que usa este estilo. Los valores de la propiedad son
RIGHT_TO_LEFT o LEFT_TO_RIGHT.
A continuación se muestra un ejemplo que simula una pantalla de celular, donde el teclado
numérico fue hecho con un GridLayout.
23
24
Nótese que se hizo uso de —inicialmente— un BorderLayout para identificar 2 zonas: NORTH y
CENTER. En la primera se posiciona el visor numérico con estilo FlowLayout, y en la segunda el
telado numérico, con estilo GridLayout. Sin embargo, según lo explicado anteriormente, al
redimensionar solo se redimensiona la parte central.
25
3. COMPONENTES DE SWING
En la jerarquía de JComponent se mostraron varias clases que heredan los atributos y métodos de
esta, y en los ejemplos presentados se ha hecho mención a algunos como JButton, JLabel, entre
otros.
A continuación se detallarán algunas de las clases más utilizadas en la creación de GUI, tales como
JTextArea, JCkeckBox, JRadioButton y JComboBox.
3.1. LA CLASE JTEXTAREA
JTextArea es un componente que expone un área de texto, con múltiples líneas y múltiples
columnas.
3.1.1. CONSTRUCTORES
De acuerdo a lo expuesto por Oracle (2014e), los constructores más relevantes de la clase
JTextArea son:
CONSTRUCTOR DESCRIPCIÓN
JTextArea() Crea una nueva TextArea.
JTextArea(Document doc) Crea una nueva JTextArea con el modelo del documento especificado, y
los demás argumentos toman valores por defecto: null, 0, 0.
JTextArea(Document doc, Crea una nueva JtextArea con la cantidad especificada de filas y
26
String texto, int filas, int columnas, y el modelo especificado.
columnas)
JTextArea(int filas, int Crea una nueva TextArea vacía, con la cantidad de filas y columnas
columnas) especificadas.
JTextArea(String texto) Crea una nueva TextArea, y despliega el texto especificado
JTextArea(String texto, int Crea una nueva TextArea, con la cantidad de filas y columnas
filas, int columnas) especificadas, y además despliega el texto especificado.
A continuación se muestra un programa que permite visualizar los 4 constructores que no hacen
uso de un Document en sus argumentos.
27
28
3.1.2. MÉTODOS
De acuerdo a lo indicado por Oracle (2014e), los métodos de la clase JTextArea son los siguientes:
TIPO MÉTODO DESCRIPCIÓN
void append(String str) Agrega el texto str al final del contenido.
int getColumns Devuelve el número de columnas.
int getColumnWidth() Devuelve el ancho de las columnas.
int getLineCount() Devuelve el número de líneas que contiene la TextArea.
int getLineEndOffSet(int Determina el offSet del final de la línea especificada.

linea)
int getLineStartOffSet(int Determina el offSet del inicio de la línea especificada.

linea)
Dimension getPreferredSize() Devuelve el tamaño preferido de la TextArea.
int getRows() Devuelve el número de filas de la TextArea.
29
int getTabSize() Devuelve el número de espacios que se salta la tabulación.
void insert(String texto, int Inserta el texto especificado en la posición especificada.

posicion)
void replaceRange(String Reemplaza el texto existente entre las posiciones de

texto, int comienzo, int comienzo y fin por el nuevo texto especificado.
fin)
void setColumns(int columnas) Setea el número de columnas para la TextArea.
void setFont(Font fuente) Setea la fuente especificada para el contenido de la

TextArea.
void setRows(int filas) Setea el número de filas para la TextArea.
void setTabSize(int tamaño) Setea el número de espacios que se expande la tabulación.
Algunas consideraciones importantes de JTextArea:
1. No tiene barras de scroll, por lo tanto, si se escribe más de lo que se puede visualizar,
sencillamente no se podrá ver en la pantalla. Para solucionar este problema, respecto de lo
cual algo ya se esbozó en el ejemplo de BorderLayout, se utiliza un objeto JScrollPane, que
admite dentro de sí un componente.
La codificación queda de la siguiente manera:
JTextArea miJTextArea = new JTextArea(20, 25);

JScrollPane miScroll = new JScrollPane(miJTextArea);
2. No efectúa automáticamente los saltos de línea, es decir, si el usuario no hace manualmente

los saltos de línea, el contenido del JTextArea queda todo en una sola línea. Para solucionar
este problema se dispone de dos métodos (no mencionados en el listado):
- setLineWrap: corta la línea de forma automática, sin respetar palabras. Es decir, si se

llega al final del ancho de la JTextArea, corta la palabra y el resto aparece en la línea
siguiente.
- setWrapStyleWord: complementa el anterior, logrando que las palabras se corten
cuando encuentra un espacio entre ellas.
La idea es que ambos métodos se inicialicen en true, es decir:
30
miJTextArea.setLineWrap(true);
miJTextArea.setWrapStyleWord(true);
3. Pueden ser de solo lectura, o bien editados por el usuario. Esto se define con el método
setEditable(), que es heredado de la clase JTextComponent. Entonces, para que la JTextArea
pueda ser editable por el usuario se indica:
miJTextArea.setEditable(true);
4. Se puede cambiar la font, el color de fondo y el color del texto, mediante los métodos
setFont(), setForeground() y setBackgrond() respectivamente, los dos últimos heredados de la
clase JComponente.
La forma es la siguiente:

Font miFont = new Font(“Arial”, Font.BOLD, 15); //se define un font
miJTextArea.setFont(miFont);
miJTextArea.setForeground(Color.blue); //seteo color del texto
miJTextArea.setBackground(Color.green); //seteo color del fondo
A continuación se muestra un ejemplo que hace uso de varios métodos de la clase JTextArea. La
idea es que existan 2 JTextAreas, y cada una se inicialice de manera distinta.
31
32
Se puede apreciar que en la JTextArea de la izquierda las palabras se cortan en la medida que se
llega al tope, mientras que en la de la derecha los saltos de línea no cortan las palabras, sino que
se valen de los espacios.
3.2. LA CLASE JCHECKBOX
JCheckBox es un componente que se utiliza generalmente como botón de estado, es decir,

entregan información del tipo true o false. Si se selecciona, está con valor true, caso contrario,
valor false. Además, dentro de un conjunto, se pueden marcar varios.
Según lo expuesto en Oracle (2014b), los constructores más importantes de la clase JCheckBox
son:
JCheckBox() Crea un botón de checkBox inicialmente no seleccionado, sin texto y sin

ícono.
JCheckBox(Action a) Crea un checkBox cuyas propiedades son tomadas desde la acción

especificada.
JCheckBox(Icon icono) Crea un checkBox inicialmente no seleccionado, con el ícono

especificado.
JCheckBox(String texto) Crea un checkBox, inicialmente no seleccionado, con el texto

especificado.
33
JCheckBox(String texto, Crea un checkBox, con el texto especificado, y seleccionado o no de
boolean seleccionado) acuerdo al valor especificado.
JCheckBox(String texto, Crea un checkBox, inicialmente no seleccionado, con el texto

Icon icono) especificado y con el ícono especificado.
JCheckBox(String texto, Crea un checkBox, con el texto especificado, el ícono especificado, y

Icon icono, boolean seleccionado según el valor especificado.
seleccionado)
uso de ícono:
34
35
3.2.2. MÉTODOS
De acuerdo a la página de Oracle (2014b), los métodos de la clase JCheckBox son los siguientes:
AccesibleContent getAccessibleContent() Obtiene el AccessibleContent asociado al JCheckBox.
boolean isBorderPaintedFlat() Obtiene el valor de la propiedad borderPaintedFlat.
String paramSrting() Devuelve un string con la representación del

JCheckBox.
Void setBorderPaintedFlat Setea la propiedad borderPaintedFlat con el valor

(boolean valor) especificado. Esta variable entrega una ayuda con
respecto al look and feel, así como a la apariencia del
borde del checkBox.
Los demás métodos son heredados desde las clases padres, tales como setFont, setForeground,
setBackground (de la clase JComponent), setMnemonic, setSelected, setText (de la clase
AbstractButton), setSize, show y resize (de la clase Component).
A continuación se muestra un ejemplo en el cual se utilizan JCheckBox, y también se incluyen

Listeners. La idea es que el programa entregue la suma de los valores que se han seleccionado y
que, a la vez, reste la cantidad cuando a un JCheckBox se le quite la selección.
36
37
La salida obtenida inicialmente es la siguiente:
38
Y si se seleccionan algunos valores, se calcula la suma:
Y si se quita la selección, el total disminuye:
3.3. LA CLASE JRADIOBUTTON
JRadioButton es un componente que se utiliza generalmente en un conjunto de opciones, de las

que solo se escoge una, es decir, son mutuamente excluyentes; si se selecciona una, las demás no
quedan seleccionadas.
Cabe destacar que es recomendable agrupar las opciones en un objeto ButtonGroup.
39
Según lo informado en la página de Oracle (2014d), los constructores más importantes de la clase
JRadioButton son los siguientes:
JRadioButton() Crea un radioButton inicialmente no seleccionado y sin texto.
JRadioButton(Action a) Crea un radioButton cuyas propiedades son tomadas desde la acción

especificada.
JRadioButton(Icon icono) Crea un radioButton inicialmente no seleccionado, con el ícono

especificado, y sin texto.
JRadioButton(Icon icono, Crea un radioButton con el ícono especificado, sin texto, y seleccionado
boolean seleccionado) de acuerdo al valor especificado.
JRadioButton(String texto) Crea un radioButton inicialmente no seleccionado y con el texto

especificado.
JRadioButton(String texto, Crea un radioButton con el texto especificado, y seleccionado según el

boolean seleccionado) valor especificado.
JRadioButton(String texto, Crea un radioButton inicialmente no seleccionado, con el texto e ícono

Icon icono) especificados.
JRadioButton(String texto, Crea un radioButton inicialmente no seleccionado, con el texto e ícono

Icon icono, boolean especificados, y seleccionado según el valor especificado.
seleccionado)
uso de ícono:
40
41
3.3.2. MÉTODOS
De acuerdo a lo indicado por Oracle (2014d), los métodos de la clase JRadioButton son:
AccesibleContent getAccessibleContent() Obtiene el AccessibleContent asociado al

JRadioButton.
String paramSrting() Devuelve un string con la representación del

JRadioButton.
Los demás métodos son heredados desde las clases padres, tales como setFont, setForeground,
setBackground (de la clase JComponent), isSelected, setMnemonic, setSelected, setText (de la
clase AbstractButton), setSize, show y resize (de la clase Component).
A continuación se muestra un ejemplo en el cual se utilizan JRadioButton y también se incluyen

Listeners. La idea es que el programa entregue el resultado de la operación matemática
seleccionada, aplicada a dos números fijos 45 y 9.
42
43
La salida obtenida inicialmente es la siguiente:
44
Dependiendo de la operación, se obtiene:
3.4. LA CLASE JCOMBOBOX
JComboBox es un componente que combina un botón, un campo de texto editable y una lista
desplegable, donde el usuario puede escoger un valor desde la lista, o bien, también tiene la
opción de ingresar un valor en el campo de texto (si es que está editable).
De acuerdo a la página de Oracle (2014c), los constructores más importantes de la clase

JComboBox son:
45
JComboBox() Crea un JComboBox con un esquema de datos por defecto.
JComboBox Crea un JComboBox que toma los ítems desde una ComboBoxModel
(ComboBoxModel<E> existente.
aModel)
JComboBox(E[] ítems) Crea una JComboBox con los ítems que se indican en el arreglo.
JComboBox(Vector<E> Crea una JComboBox con los ítems especificados en el vector.

ítems)
A continuación se muestra un programa que permite visualizar 3 de los 4 constructores. Se excluye

el segundo pues no se usa regularmente.
46
47
Y al dar clic en las flechas, se obtiene:
48
3.4.2. MÉTODOS
De acuerdo a Oracle (2014c), los métodos más importantes de la clase JComboBox son:
void addActionListener(ActionListener l) Agrega un ActionListener.
void addItem(E item) Agrega un ítem a la lista de ítems.
void addItemListener(ItemListener Agrega un ItemListerner.

aListener)
E getItemAt(int indice) Devuelve el ítem especificado en el

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

desplegable.
itemListener[] getItemListener() Devuelve un arreglo con todos los

ItemListeners agregados a la
JComboBox con addItemListener().
int getMaximumRowCount() Devuelve el máximo número de ítems

que la JComboBox puede mostrar sin
usar scroll.
ComboBoxModel<E> getModel() Devuelve el esquema de datos usado

en la JComboBox.
int getSelectedIndex() Retorna el primer ítem de la lista que

coincide con el ítem dado.
Object getSelectedItem() Devuelve el ítem seleccionado.
Object[] getSelectedObjects() Devuelve un arreglo que contiene el

ítem seleccionado.
void insertItemAt(E item, int indice) Inserta un ítem a la lista, en la

posición especificada por el índice.
boolean isEditable() Devuelve true si la JComboBox es

editable. Caso contrario, false.
void removeActionListener(ActionListener Elimina un ActionListener.

l)
void removeAllItems() Elimina todos los ítems de la lista.
void removeItem(Object anObject) Elimina un ítem desde la lista.
49
void removeItemAt(int indice) Elimina el ítem de la lista, de la
posición indicada por el índice.
void removeItemListener(ItemListener Elimina un ItemListener.

aListener)
void setEditable(boolean opcion) Permite que los ítems de la ComboBox

sean editables.
void setMaximumRowCount() Define el máximo número de ítems

que la JComboBox puede desplegar.
void setSelectedIndex(int indice) Selecciona el ítem correspondiente al

índice.
void setSelectedItem(Object anObject) Define el ítem seleccionado en el

display de la JComboBox.
A continuación se muestra un ejemplo en el cual se utiliza un JComboBox con algunos países de

Sudamérica, y también se incluyen Listeners. La idea es que el programa entregue el código
telefónico del país que se seleccione.
50
51
Por defecto, en la ComboBox se muestra el primer elemento.
Si se escoge algún país de la JComboBox, se obtiene:
52
53
COMENTARIO FINAL
En este capítulo se ha dado a conocer la forma en que se gestionan los eventos en Swing. Es una
filosofía muy distinta a la conocida en los lenguajes de cuarta generación, sin embargo, es óptima
y funciona de acuerdo a lo esperado.
Por lo anterior, se identificaron todos los eventos asociados a cada uno de los componentes que
se pueden plasmar en una GUI que, dicho sea de paso, es sin duda la parte más importante de una
aplicación, pues es lo que el usuario ve a diario, y es el factor más preponderante cuando se trata
de evaluar la funcionalidad y amigabilidad de una aplicación.
Para lograr una buena impresión, Java dispone de muchos componentes y gestores de diseño en la
librería javax.swing.* y que permiten logran un look and feel adecuado y agradable a la vista.
Además, que no dependen de la plataforma sobre la cual se está ejecutando la aplicación.
Y según lo estudiado, claramente Swing lleva la delantera en cuando a interfaz de usuario. La idea
es seguir aprendiendo de los demás componentes para lograr aplicaciones de alta calidad, 100%
funcionales y adaptables a cualquier plataforma.
54
REFERENCIAS
Barnes, D. J. & Kölling, M. (2007). Programación orientada a objetos con Java. 3.ª edición. México:
Editorial Prentice Hall.
Dean, J. & Dean, R. (2009). Introducción a la programación en Java. México: Editorial McGraw Hill.
Odelys (s.f.).Programación basada en eventos. Recuperado de:
https://odelys2003.files.wordpress.com/2013/01/programacioneventos.pdf
Oracle (2010). FAQs. Recuperado de: http://www.oracle.com/technetwork/java/faqs-140150.html
Oracle (2014a). Interfaces Listener. Recuperado de:
http://docs.oracle.com/javase/7/docs/api/java/awt/event/package-summary.html
Oracle (2014b). Class JCheckBox. Recuperado de:
http://docs.oracle.com/javase/7/docs/api/javax/swing/JCheckBox.html
Oracle (2014c). Class JComboBox <E>. Recuperado de:
http://docs.oracle.com/javase/7/docs/api/javax/swing/JComboBox.html
Oracle (2014d). Class JRadioButton. Recuperado de:
http://docs.oracle.com/javase/7/docs/api/javax/swing/JRadioButton.html
Oracle (2014e). Class JTextArea. Recuperado de:
http://docs.oracle.com/javase/7/docs/api/javax/swing/JTextArea.html
55
Oracle (2014f). Uses of Package java.awt.event. Recuperado de:
http://docs.oracle.com/javase/7/docs/api/java/awt/event/package-use.html
Oracle (2015). Introduction to Event Listeners. Recuperado de:
https://docs.oracle.com/javase/tutorial/uiswing/events/intro.html
Universia (s.f.). Construcción de interfaces con Swing. Recuperado de:
http://mit.ocw.universia.net/1.00/s02/class-sessions/lecture-15/lecture-15.pdf
PARA REFERENCIAR ESTE DOCUMENTO, CONSIDERE:
IACC (2014). Diseño de Gui (Interfaz Gráfica de Usuario). Programación Orientada a Objetos II.
Semana 4.
56
57

04 Contenido POOII V5

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

04 Contenido POOII V5

Cargado por

Copyright:

Formatos disponibles

PROGRAMACIÓN ORIENTADA A OBJETOS II

DISEÑO DE GUI (INTERFAZ GRÁFICA DE USUARIO)............................................................................. 4

 Utilizar gestores de Swing para el diseño de GUI en aplicaciones Java.

 Emplear diversos componentes de Swing para el desarrollo de aplicaciones en Java.

 AWT (Abstract Window Toolkit)

1.1. SWING VS. AWT

1.2. MANEJO DE EVENTOS

Ahora bien, es válido preguntarse ¿qué es un evento?. La respuesta es sencilla: de acuerdo a lo

Un evento, y el efecto que provoca, se conforma de tres componentes (Oracle, 2015):

1. El EventSource, que es la fuente de un evento, o el evento propiamente tal.

 Corresponde al componente de la GUI con la que el usuario interactúa.

 Se comprueba que la información sobre un evento se encuentra encapsulada.

 El evento se deriva desde java.util.EventObject hacia java.awt.AWTEvent o a

- ActionEvent es enviado por un botón.

- WindowEvent es enviado por una ventana.

 Contiene la información del evento ocurrido, y la información necesaria para manejar el

 Envía el evento a los objetos oyentes (listeners) registrados para el evento.

3. El EventListener es el evento oyente y es el que ejecuta el método apropiado.

 Implementa una interfaz especial y determinada para un evento.

 Determina lo que se debe hacer ante un evento en particular.

El paquete java.awt.swing.event contiene una serie de interfaces oyentes de eventos y clases de

COMPONENTE EVENTOS DESCRIPCIÓN

Button ActionEvent Dar clic al botón

Checkbox ItemEvent Seleccionar o deseleccionar un ítem

CheckboxMenuItem ItemEvent Seleccionar o deseleccionar un ítem

Choice ItemEvent Seleccionar o deseleccionar un ítem

Component ComponentEvent Mover, cambiar tamaño, mostrar u

FocusEvent Obtener o perder el foco.

Se denominan por: GOT_FOCUS y

MouseEvent Pulsar o soltar un botón del mouse.

Se denominan por: MOUSE_DOWN,

Container ContainerEvent Agrear o eliminar un componente a un

List ActionEvent Hacer doble clic sobre un ítem de la

ItemEvent Seleccionar o deseleccionar un ítem de

MenuItem ActionEvent Seleccionar un ítem de un menú

Scrollbar AdjustementEvent Cambiar el valor de la scrollbar. Se

TextComponent TextEvent Camiar el texto

TextField ActionEvent Terminar de editar un texto pulsando

Window WindowEvent Acciones sobre una venana: abrir,

 set<TipoEvento>Listener(): define un único objeto oyente para el tipo de evento indicado.

 add<TipoEvento>Listener(): agrega el objeto a la lista de oyentes.

 remove<TipoEvento>Listener(): elimina el objeto oyente.

Más adelante se hablará en más detalle sobre la interfaz Listener.

1.3. JERARQUÍA DE COMPONENTES SWING

El siguiente cuadro muestra la jerarquía de componentes Swing. Evidentemente también se

El desglose de la clase JComponent se muestra a continuación:

A continuación se muestra la estructura de un JFrame, que se compone de:

1.4. INTERFACES LISTENER

Interface Descripción Método

A continuación se muestra un ejemplo de la funcionalidad de un botón dentro de un JFrame:

Al dar clic en el botón, se obtiene:

La gestión es intrínsecamente recursiva y avanza de arriba hacia abajo en la jerarquía de

Algunas razones para aplicar gestión de diseño (Universia, s.f.):

 No se conoce a ciencia cierta el tamaño que tendrá la aplicación (ventana principal).

Además, Swing rediseñará automáticamente una GUI cuando (op. cit.):

A continuación se explican los 3 gestores principales: FlowLayout, BorderLayout y GridLayout

2.1. GESTOR DE DISEÑO FLOWLAYOUT

El gestor de diseño FlowLayout es el más simple de todos. El diseño lo realiza agregando

2.2. GESTOR DE DISEÑO BORDERLAYOUT

add( new JButton("Aceptar"), "Center" )

Donde “Center” indica BorderLayout.CENTER.

Si se redimensiona la ventana, se obtiene:

En este estilo, en el constructor normal se pueden especificar la cantidad de filas o de columnas,