Universidad Nacional de Piura – Jorge L.

Sandoval Rivera 1
______________________________________________________________________
CAPITULO I: CONCEPTOS BÁSICOS

1.- INTERFAZ GRAFICA DE USUARIO

Entendemos por Interfaz Gráfica de Usuario (GUI) al software que permite la
interacción entre el usuario y los servicios que proporciona el sistema operativo,
utilizando para ello una representación gráfica intuitiva de alto nivel

La informática moderna no puede entenderse sin el impacto que supuso la

generalización de los entornos gráficos de usuario a partir de los 80. Hoy en día, la
mayor parte de las aplicaciones destinadas a usuarios finales se realizan para este
tipo de entornos

La mayoría de los GUIs de propósito general siguen la llamada metáfora de

escritorio, y utilizan un sistema de ventanas. Para la interacción con el usuario,
disponen de un número más o menos grande de elementos o widgets: botones,
editores, etc.

Este tipo de interfaz tiene características que un lenguaje de programación debe

implementar en este tipo de entornos y en una descripción general del cambio que
supone respecto a la programación clásica y las nuevas posibilidades que aporta.

La programación en un GUI determinado requiere el uso de un toolkit (o SDK)

para ese GUI, en el lenguaje de programación que queramos utilizar.

La estructura de un GUI es de forma natural orientada a objetos. El desarrollo con

un toolkit orientado a objetos es mucho más sencillo y rápido

La programación en GUIs suele ser un proceso iterativo de tres pasos:

a.- Consiste en diseñar la interfaz de una parte de la aplicación, utilizando los

widgets disponibles en el toolkit de desarrollo e incluye dos tareas:

• Posicionar los widgets y establecer sus dimensiones

• Modificar sus características visuales y funcionales (títulos, colores,
comportamiento).

b.- En el segundo se realiza la captura de los eventos de la interfaz que permitan

implementar la funcionalidad requerida.

c.- En el tercer paso, se implementa cada uno de los manejadores

correspondientes a los eventos capturados
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 2
______________________________________________________________________

2.- ARQUITECTURA DE UNA APLICACIÓN CON GUI

La arquitectura de una aplicación con GUI tiene una serie de niveles que engloban
clases que realizan distintas tareas:

• Capa de presentación o interfaz

• Capa de aplicación o del dominio del problema
• Capa de persistencia

La capa de presentación o interfaz contiene los objetos que permiten mostrar la

información al usuario y gestionar la interacción con el mismo. Atención: es
dependiente del toolkit (paquete de herramientas) utilizado.

La capa de aplicación o de dominio del problema contiene los objetos que

modelan la solución del problema (objetos de negocio). Es la capa más importante
y puede ser reutilizada total o parcialmente en múltiples aplicaciones similares.

La capa de persistencia contiene el código necesario para almacenar los objetos de

negocio en bases de datos o ficheros. Puede ser dependiente de la base de
datos/formato de fichero utilizado.

3. MODELO DE DELEGACIÓN DE EVENTOS

Idea básica: el tratamiento de un evento que ocurre en un objeto (objeto fuente) no

se realiza en ese mismo objeto, sino que se delega en otro diferente.
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 3
______________________________________________________________________

Objeto evento
• Evento: objeto que encapsula toda la información sobre la interacción del
usuario con la aplicación gráfica
– Presionar un botón
– Introducir un texto, etc.
• Una interacción del usuario puede producir uno o más eventos
• Jerarquía de eventos: raíz java.util.EventObject
Atributo: objeto fuente en el que se ha generado el evento
Método: Object getSource()

Objeto fuente
• Componente en el que se genera el evento
• Métodos de manejo de oyentes
– set<TipoEvento>Listener(): establece un único oyente para este tipo de
eventos
– add<TipoEvento>Listener(): añade el objeto a la lista de oyentes
– remove<TipoEvento>Listener(): elimina el objeto oyente correspondiente

Objeto oyente
• Gestiona, maneja o responde a un evento
• Define uno o varios métodos que son ejecutados por la fuente del evento y
reciben como argumento el objeto evento
• Los métodos a implementar se definen en la interfaz Java para los oyentes de
ese tipo de eventos: <TipoEvento>Listener (ej. ActionListener)

4.- MODELO-VISTA-CONTROLADOR
El Modelo Vista Controlador (MVC) es un patrón de arquitectura de software que
separa todo nuestra aplicación en tres componentes distintos:

• los datos de una aplicación,

• la interfaz de usuario,
• y la lógica de control.
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 4
______________________________________________________________________

La motivación bajo este patrón es la siguiente: no hacer que un único objeto sea
responsable del contenido, la apariencia y comportamiento.

Este modelo esta formado por tres componentes como ya lo mencionamos:

• Modelo: Esta es la representación específica de la información (El contenido o
estado) con la cual el sistema opera. La lógica de datos que asegura la integridad
de estos y permite derivar nuevos datos; por ejemplo, no permitiendo comprar un
número de unidades negativo.
En un botón el contenido almacenaría si el botón está pulsado o no, si está activo
o no,... en un campo de texto el contenido almacenaría el texto
• Vista: Este presenta el modelo o contenido en un formato adecuado para
interactuar, usualmente es la interfaz de usuario.

La apariencia visual, depende del estado (por ejemplo, un botón se muestra de

forma diferente en función de si está pulsado o no).

• Controlador: maneja la interacción con el usuario, respondiendo a eventos,

usualmente acciones del usuario e invoca cambios en el modelo y probablemente
en la vista. Su comportamiento, está determinado por la forma en que responde
ante eventos

Ejemplo
Pensemos en un campo de texto en el que hemos escrito la frase: En un lugar de la
Mancha, de cuyo nombre no.

El campo de texto puede tener un tamaño (en cuanto al número de caracteres que
puede mostrar) menor que la frase y en un momento dado puede mostrar lo
siguiente:

El modelo debe ofrecer métodos para modificar y obtener el contenido.

La vista, seria el cuadro que muestra el contenido
El controlador, el control de un evento como agregar un carácter al presionar una
tecla, que el cuadro de texto pierda el enfoque actual, etc.

Una ventaja del patrón Model-View-Controller es que es posible tener varios view
de un mismo model.
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 5
______________________________________________________________________

Ejemplo:
Podríamos realizar un componente cuyo contenido sean 3 matrices:
Una almacena las coordenadas x, otra las coordenadas y otra el valor de una función
z = f(x,y).

Un view podría mostrar los datos como una tabla:

El controller trata los eventos relacionados con el usuario tal como pulsaciones del
ratón o pulsaciones de teclas.
Tiene que decidir si estos eventos se deben trasladar en cambios en el model o
cambios en el view.

Por ejemplo si el usuario modifica un dato de la tabla, el controller notifica al model

y éste notifica el view para que se actualice.

Si por ejemplo ofrecemos la posibilidad de de que pulsando sobre la superficie se

realice un zoom y el usuario pulsa, el controller debe notificar al view pero esta
operación no ha modificado los datos por lo que el model no interviene en ningún
momento.
La ventaja de esta separación es que se consigue mayor independencia entre el
contenido y la apariencia.

Los patrones de diseño han de ser vistos como una guía, como una posible solución a
un problema y no como algo dogmático (que hay que aplicar de una forma
inmutable).

Por lo tanto, cada componente Swing tiene un modelo y un delegado asociado con el,
el modelo es responsable del estado y el delegado de la apariencia y comportamiento
(look and feel) así como de la comunicación entre el modelo y lo que se muestra.

Ejemplo:
La siguiente imagen representa gráficamente la interacción entre los diferentes
elementos de la aplicación, como son: modelo, vista y controlador aplicado a un
objeto de desplazamiento.
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 6
______________________________________________________________________

5. ENTORNO DE DESARROLLO JAVA

Para desarrollar código Java se requiere algún paquete de programación Java. La

compañía Sun Microsystems, creadora de Java distribuye gratuitamente el Java
Development Kit (JDK), o llamado Standard Development Kit (SDK) . Se trata de
un conjunto de programas y librerías que permiten desarrollar, compilar y ejecutar
programas en Java.

Hay varias plataformas: J2EE (Java2 Enterprise Edition) especialmente pensada

para crear aplicaciones Web, J2SE (Java 2 Standard Edition) es el entorno de
desarrollo de aplicaciones Java orientado a las aplicaciones solitarias y los Applets.
Existe también una versión reducida del JDK, denominada JRE (Java Runtime
Environment), destinada únicamente a ejecutar código Java, no permitiendo
compilar. Java WSDP es un conjunto de herramientas integradas que permite a los
desarrolladores de la plataforma Java desarrollar, probar y desplegar aplicaciones
XML, aplicaciones Web y servicios Web.

Los IDE (Integrated Development Environment), son entornos de desarrollo

integrados, en un mismo programa donde es posible escribir el código Java,
compilarlo y ejecutarlo sin cambiar de aplicación.

Los IDE's ofrecen un ambiente gráfico en los que se tiene acceso a mayor número
de herramientas no ofrecidas en los JDK's: Debuggers más elaborados, check-points
dentro de la compilación, creación de WAR'S(Web-Archives), "Wizards" para
acelerar desarrollo, entre otras cosas. Algunos IDE'S son:
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 7
______________________________________________________________________
.- Visual Cafe de Symantec
La empresa Symantec, dura competidora en los IDE de Java ofrece el entorno
visual de desarrollo Java Visual Café, que ya goza de una gran reputación entre
los desarrolladores de Java.

Las principales funciones que soporta son las siguientes:

• Editor de programación gráfica:
• Editor de clases y jerarquías.
• Depurador gráfico.
• Gestor de proyectos.
• Asistentes:

.- Eclipse Open-Source
Eclipse es una plataforma de código abierto que se puede utilizar para diseñar
programas de primer nivel, componentes, sitios web y muchos otros elementos.
Con una cobertura integral de las funciones ampliadas de Eclipse 3.

• Sun One Studio ME (Se trata de una versión del entorno de Sun dedicado a
desarrollar aplicaciones J2ME. Este entorno, antes conocido como Forte for Java,
tiene el inconveniente de necesitar demasiados recursos, por lo que para utilizarlo
necesitaremos ordenadores con bastante memoria (no menos de 256Mb).

• Borland JBuilder: Desde el entorno de Borland también podremos crear

aplicaciones J2ME. A partir de la versión 9 de JBuilder, se tiene disponible una
edición Mobile para crear este tipo de aplicaciones. En versiones anteriores,
podemos instalar una extensión llamada MobileSet con la que desarrollar
aplicaciones móviles.

• Oracle Jdeveloper: El entorno JDeveloper de Oracle está destinado

principalmente al desarrollo de aplicaciones J2EE. Proporciona asistentes para
crear de forma sencilla los distintos componentes de estas aplicaciones como
servlets, JSPs, EJBs, servicios web, etc. Maneja conexiones con bases de datos y
servidores de aplicaciones para desplegar automáticamente las aplicaciones
desarrolladas, e incorpora su propio servidor de aplicaciones integrado para
realizar pruebas en modo local.

• Wireless Studio Device Developer: Se trata de un entorno de desarrollo de IBM

basado en Eclipse y dedicado principalmente al desarrollo de aplicaciones
móviles. Tiene el inconveniente de que no se integra correctamente con algunos
emuladores al ejecutar las aplicaciones.

• Visual Age de IBM

Es una RAD (Rapid Aidded Design), permite diseñar la interfaz de la aplicación
o applet, y definiendo el sistema de eventos, la herramienta puede crear código
Java. Es muy sencillo de manejar y uno de los más potentes del mercado.

Y otros IDE comoNetbeans, CodeWarrior de Metrowerks, Roaster de Natural

Intelligence, Cosmo de Silicon Graphics, SuperCede de Asymetrix, Java Maker, Ed
de Soft As It Gets, Mojo de Penumbra Software, Jamba de AimTech, etc.
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 8
______________________________________________________________________
6.- BIBLIOTECAS DE LA API DE JAVA

Con cada una de las versiones que Sun lanza del JDK, se acompaña de una serie de
bibliotecas con clases que se pueden incluir en los programas Java, sin temor a
fallos de portabilidad. Además, están bien documentadas, y organizadas en
paquetes y en un gran árbol de herencia.

A este conjunto de paquetes (o bibliotecas) se le conoce como la API de Java

(Application Programming Interface).

A. Paquetes de utilidades

• java.lang: Fundamental para el lenguaje. Incluye clases como String o

StringBuffer, que se tratan más en detenimiento en el capítulo "III.2 Cadenas" de
este tutorial.
• java.io: Para la entrada y salida a través de flujos de datos, y ficheros del sistema.
Se estudia en el capítulo "III.3 Entrada/Salida" de este tutorial.
• java.util: Contiene colecciones de datos y clases, el modelo de eventos,
facilidades horarias, generación aleatoria de números, y otras clases de utilidad.
• java.math: Clases para realizar aritmética con la precisión que se desee.
• java.text: Clases e interfaces para manejo de texto, fechas, números y mensajes
de una manera independiente a los lenguajes naturales.
• java.security: Clases e interfaces para seguridad en Java: Encriptación RSA...

B. Paquetes para el desarrollo gráfico

• java.applet: Para crear applets y clases que las applets utilizan para comunicarse
con su contexto. Se estudia en el capítulo "VI. Applets" de este tutorial.
• java.awt: Para crear interfaces con el usuario, y para dibujar imágenes y gráficos.
Se estudia en el capítulo "IV. Bibliotecas gráficas" de este tutorial.
• javax.swing: Conjunto de componentes gráficos que funcionan igual en todas las
plataformas que Java soporta. Se estudia en el capítulo "IV. Bibliotecas gráficas"
de este tutorial.
• javax.accesibility: Da soporte a clases de accesibilidad para personas
discapacitadas.
• java.beans: Para el desarrollo de JavaBeans.

C. Paquetes para el desarrollo en red

• java.net: Clases para aplicaciones de red. Se estudia en el capítulo "V. Java e

Internet" de este tutorial.
• java.sql: Paquete que contiene el JDBC, para conexión de programas Java con
Bases de datos.
• java.rmi: Paquete RMI, para localizar objetos remotos, comunicarse con ellos e
incluso enviar objetos como parámetros de un objeto a otro.
• org.omg.CORBA: Facilita la posibilidad de utilizar OMG CORBA, para la
conexión entre objetos distribuidos, aunque esté codificados en distintos
lenguajes.
• org.omb.CosNaming : Da servicio al IDL de Java, similar al RMI pero en
CORBA
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 9
______________________________________________________________________
7. HERENCIA
La idea de la herencia es permitir la creación de nuevas
clases basadas en clases existentes. Esta relación se
representa así:

• Nueva hereda todas las características (métodos y

campos) de Existente.
• Nueva puede definir características (campos y métodos)
adicionales.
• Nueva puede redefinir características heredadas de
Existente.
• El proceso de herencia no afecta de ninguna forma
a la superclase Existente.
• Nueva es una subclase y Existente es superclase

Para que una nueva clase sea subclase de otra existente basta con añadir extends
existente a continuación del nombre de la nueva:

public class Nueva extends Existente

{
.....
}

En Java, el punto más alto de la jerarquía es la clase Object de la cual derivan en

última instancia todas las demás clases. Esta clase aporta una serie de funciones
básicas comunes a todas las clases. Si al definir una nueva clase, no aparece la
claúsula extends, Java considera que dicha clase desciende directamente de Object.

7.1. Herencia Simple

Es un tipo de herencia en la que una clase hereda el estado (estructura) y el
comportamiento de una sola clase base (superclase).

7.2. Herencia múltiple

Una clase puede descender de varias superclases, en casos especiales es
posible simular herencia múltiple con unas clases especiales denominadas
interfaces.
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 10
______________________________________________________________________

7.3. ¿Qué se hereda?

· Herencia de interfaz. Sólo se hereda la declaración de las características que

la clase padre declara como públicas.

·Herencia de implementación. Se heredan también los atributos y la

implementación de las operaciones.

Motivo por el que se hereda:

· Herencia de interfaz. La herencia se establece porque la interfaz de la clase
hija coincide (o extiende) la de la clase padre.

· Herencia de implementación. Se realiza con objeto de acceder a la

implementación de los métodos de la clase padre, aunque la interfaz de ambas
clases sea distinta.

¿Quién controla lo que se hereda?

·Herencia estricta. No permite la redefinición de las características heredadas.

Por un lado, es posible redefinir la visibilidad de las características heredadas y

la implementación de los métodos. En Java, una limitación a esto son los
métodos declarados como final.

· Herencia selectiva. Se puede decidir qué características se heredan y cuáles

no.
Se heredan todas las características definidas por la clase antecesora. Sin
embargo, si atendemos a la visibilidad de las características heredadas, sí que
podemos hablar de herencia selectiva
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 11
______________________________________________________________________
Jerarquía de clases por herencia

7.4. Herencia y Constructores

• Los constructores de la clase base se invocan antes del constructor de la clase

derivada.
• Si una clase base, es a su vez una clase derivada, sin constructores se invocan
también en secuencia: constructor base, constructor derivada.
• Los constructores no se heredan aunque los constructores por defecto se
generan si se requiere.

7.5. Interface vs. Clase Abstracta

• Un interface no puede implementar ningún método.

• Un interface no forma parte de la jerarquía de clases.
• Clases dispares pueden implementar el mismo interface.
• Una clase puede implementar n interfaces pero solo una clase.
• El objetivo de un método abstracto es forzar una interfaz (API) pero no una
implementación

Haremos un interface cuando queramos definir un grupo genérico de clases y

no tengamos métodos implementados que reutilizar. O cuando nos veamos
forzados por la falta de herencia múltiple en Java.
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 12
______________________________________________________________________

8. EVENTOS
Las acciones del usuario sobre el programa se llaman eventos. Son eventos típicos
el click sobre un botón, el hacer doble click sobre el nombre de un fichero para
abrirlo, el arrastrar un icono, el pulsar una tecla o combinación de teclas, el elegir
una opción de un menú, el escribir en una caja de texto, o simplemente mover el
ratón. Existen distintos tipos de eventos reconocidos por el sistema operativo y el
lenguaje de programación que los implementa.
Cada vez que se produce un evento sobre un determinado tipo de control, el
lenguaje de programación arranca una determinada función o procedimiento que
realiza la acción programada por el usuario para ese evento concreto. Estos
procedimientos o funciones se invocan de acuerdo a la implementación que realice
el lenguaje de programación que se esta utilizando.
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 13
______________________________________________________________________
CAPITULO II: EL PAQUETE AWT

2.1. INTRODUCCION

Uno de los problemas frecuentes de la programación clásica era como programar

interfaces de usuario, ya que esto implicaba tener que utilizar las API propias del
Sistema Operativo y esto provocaba que el código no fuera transportable a otros
sistemas operativos.

AWT fue la primera solución a este problema propuesta por java.

AWT es el acrónimo de Abstract Windows Toolkit (Kit de Herramientas de

Ventana Abstracta). Se trata de una biblioteca de clases java para el desarrollo de
Interfaces de Usuario Gráficas y el trabajo con múltiples plataformas.

AWT usa clases gráficas comunes a todos los sistemas operativos gráficos y luego
la máquina virtual traduce esa clase a la forma que tenga en el sistema concreto en
el que se ejecutó el programa, sin importar que dicho sistema sea un sistema X,
Macintosh o Windows.

Este paquete viene incluido en Java Foundation Classes (JFC) que es la API de
java y que se importa desde una aplicación como java.awt, con lo que las
interfaces generadas con esta biblioteca funcionan en todos los entornos java
disponibles.

AWT proporciona la base para trabajar con entornos gráficos en java, incluso el
paquete swing está basado en él.

2.2. SUBPAQUETES Y ESTRUCTURA DEL AWT

Los subpaquete de AWT son:

• Los componentes (java.awt.Component)
• Los contenedores (java,awt.Containers)
• Los gestores de posición (java.awt.LayoutManager), que posiciona los
componentes dentro de los contenedores.

• Los eventos (java.awt.Event), que nos indican las acciones del usuario.

• Los objetos básicos (java.awt.Button), que permiten interactuar el usuario con la

aplicación para ejecutar alguna acción.

La estructura básica del AWT podemos resumirla en los puntos que exponemos a
continuación:
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 14
______________________________________________________________________
• Los Contenedores contienen Componentes, que son los controles básicos
• No se usan posiciones fijas de los Componentes, sino que están situados a través
de una disposición controlada (layouts)
• El común denominador de más bajo nivel se acerca al teclado, ratón y manejo de
eventos
• Alto nivel de abstracción respecto al entorno de ventanas en que se ejecute la
aplicación
• La arquitectura de la aplicación es dependiente del entorno de ventanas, en vez
de tener un tamaño fijo.
• Es bastante dependiente de la máquina en que se ejecuta la aplicación (no puede
asumir que un diálogo tendrá el mismo tamaño en cada máquina)

2.3. COMPONENTES

Una interfaz gráfica está construida en base a elementos gráficos básicos y

avanzados, los componentes típicos son los botones, etiquetas, campos de texto,
casillas de verificación, botones de opción, listas, barras de desplazamiento, entre
otros. Los componentes permiten al usuario interactuar con la aplicación y
proporcionar información desde el programa al usuario sobre el estado del
programa.

Los componentes no se encuentran aislados, sino agrupados dentro de

contenedores.

Los componentes de AWT se llaman componentes pesados debido al uso

significativo que hacen de los recursos del sistema.

En el AWT, todos los componentes de la interfaz de usuario son instancias de la

clase Component o uno de sus subtipos.

La siguiente figura muestra la jerarquía de clases que representan componentes y

contenedores de AWT:
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 15
______________________________________________________________________

Imagen Nº 01: Jerarquía de las clases de AWT

2.3.1. Lista de componentes más comunes de AWT

• Applet: crea un applet.

• Button: Crea un botón.
• Canvas: Crea un área de trabajo en el que se puede dibujar.
• CheckBox: Crea una casilla de activación.
• Choice: Crea un control de opción.
• Label: Crea una etiqueta.
• Menú: Crea un menú..
• ComboBox: Crea un cuadro de lista desplegable.
• List: Crea un cuadro de lista.
• Frame: crea un marco para las ventanas de aplicación.
• Dialog: Crea un cuadro de dialogo.
• Panel: crea un área de trabajo que puede tener otros controles.
• PopupMenu: crea un menú emergente.
• RadioButton: crea un botón de opción.
• ScrollBar: Crea una barra de desplazamiento.
• ScrollPane: Crea un cuadro de desplazamiento.
• TextArea: Crea un área de texto de dos dimensiones.
• TextField: Crea un cuadro de texto de una dimensión.
• TextPane: Crea un área de texto.
• Window: Crea una ventana.
• Etc.
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 16
______________________________________________________________________
2.3.2. Clase Component

Es la clase básica en la que se basan todos los componentes visuales de

AWT, ésta definida como una clase abstracta que representa a cualquier
objeto que tiene una posición y un tamaño, que puede ser dibujado en la
pantalla y que pueda recibir eventos de entrada (que responda a las
interacciones con el usuario).

La clase Component se deriva directamente de la clase java.lang.Object, e

incluye un gran número de métodos, organizados para cubrir varios
propósitos.

A continuación se explican algunos de ellos.

a.) Tamaño y posición del componente

• Dimension getSize(); Devuelve la anchura y altura del componente

como un objeto de la clase Dimension, que tiene como campos: width
(anchura) y heigth (altura).
• void setSize(int ancho, int largo); Establece la anchura y altura del
componente.
• Dimension getPreferredSize(); Devuelve el tamaño que este
componente debería tener.
• void setPreferredSize(); Establece el tamaño que este componente
debería tener.
• Dimension getMinimumSize(); Devuelve el tamaño mínimo que este
componente debería tener.
• void setMinimumSize(int ancho, int largo); Establece el tamaño
mínimo que este componente debería tener.
• Rectangle getBounds(); Devuelve las coordenadas de este
componente como un objeto de la clase Rectangle, que tiene como
campos: x, y, width y heigth.
• void setBounds(int x, int y, int ancho, int largo); Establece las
coordenadas de este componente.

b.) Acciones sobre el componente

• boolean getEnabled(); Comprueba si el componente está o no activo.

• void setEnabled(boolean); Establece el componente a activo o inactivo.
• boolean getVisible(); Comprueba si el componente está o no visible.
• void setVisible(boolean); Establece si el componente está visible o
invisible.
• void paint(Graphics g); Indica al AWT que ha de dibujar el
componente g.
• void repaint(); Indica al AWT que ha de volver a dibujar el
componente.
• void update(Graphics g); Es llamado por AWT cuando se invoca el
método repaint(). Por defecto llama a paint().

c.) Eventos de interacción con el usuario

Universidad Nacional de Piura – Jorge L.Sandoval Rivera 17
______________________________________________________________________
A su vez hay tres tipos de métodos, para la gestión de eventos.

• void add_Tipo_Listener(_Tipo_Listener l); Añade un oyente a la

espera de algún tipo de eventos sobre este componente.
• void remove_Tipo_Listener(_Tipo_Listener l); Elimina algún oyente
que estaba a la espera de algún tipo de eventos sobre este componente.
• void process_Tipo_Event(_Tipo_Event e); Procesa eventos del tipo
_Tipo_Event enviándolos a cualquier objeto _Tipo_Listener que
estuviera escuchando.

En estos métodos _Tipo_ puede ser cualquiera de los siguientes:

Component, Focus, InputMethod, Key, Mouse, MouseMotion.

2.4. CONTENEDORES

Los contenedores son clases que usan organizadores (layout manager) para
distribuir los objetos componentes en la superficie de despliegue de la mejor
forma.

Además, los contenedores son en sí mismos componentes y como tales pueden ser
situados dentro de otros contenedores. También contienen el código necesario para
el control de eventos, cambiar la forma del cursor o modificar el icono de la
aplicación.

Para aparecer en pantalla, todo componente GUI debe ser parte de una jerarquía de
contención. Una jerarquía de contención es un árbol de componentes que tiene un
contenedor de alto nivel como su raíz.

2.4.1. Tipo de contenedores

a.- Contenedores de alto nivel ("Top-Level Containers")

Un contenedor de Alto Nivel proporciona el soporte que necesitan los
componentes AWT para realizar su dibujado y su manejo de eventos.

Todo programa que presente un GUI AWT contiene al menos un

contenedor de alto nivel, los contenedores de alto nivel AWT son:

• Window: ventana sin bordes ni barra de menús

• Frame: ventana con marco: con título, borde, menús y controles
• Dialog: ventanas secundarias que implementan cuadros de diálogo
con el usuario (modal o no modal)
• Applet: implementa un área de pantalla de un applet dentro de una
ventana del navegador.
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 18
______________________________________________________________________

b.- Contenedores intermedios

AWT proporciona otros contenedores denominados intermedios con

propósitos específicos. Son los siguientes:
• Panel no añaden casi ninguna funcionalidad más allá de las que
tienen los objetos, no puede aparecer "por sí solo" en la pantalla.
• ScrollPane (panel deslizante) proporciona barras de
desplazamiento alrededor de un sólo componente.
• SplitPane (panel dividido) permite al usuario personalizar la
cantidad relativa de espacio dedicada a cada uno de dos
componentes,
• TabbedPane (panel con solapas ) muestra sólo un componente a
la vez, permitiendo fácilmente cambiar entre componentes.
• ToolBar (barra de herramientas) contiene un grupo de
componentes (normalmente botones) en una fila o columna, y
opcionalmente permite al usuario arrastrar la barra de
herramientas a diferentes localizaciones.

c.- Contenedores específicos

Existen otro tipo de contenedores que son más especializados, como los
paneles internos y los paneles de capas, que a su vez pueden
superponerse como:
Internal frames se parecen a los frames y tienen mucho del mismo API
pero al contrario que los frames deben aparecer dentro de otras
ventanas.
Root Panes proporcionan soporte detrás-de-la-escena a los
contenedores de alto nivel. Layered panes existen para soportar
ordenación en el eje Z de componentes

• Un panel transparente (GlassPane) como primera capa

• Una barra de menú (MenuBar)
• Detrás un panel de capa (LayeredPane)
• Detrás el panel raíz de las capas (RootPane)
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 19
______________________________________________________________________
• Por último el contenedor de alto nivel (un Frame)

En el AWT, todos los contenedores son instancias de la clase Container o

uno de sus subtipos.

2.4.2. Clase Container

Container es una clase abstracta derivada de Component, que representa a
cualquier componente que pueda contener otros componentes.
Se trata, de añadir a la clase Component la funcionalidad de adición,
sustracción, recuperación, control y organización de otros componentes

Algunos de los métodos de la clase Container son:

• Component add(Component c); Añade un componente al contenedor.

• void print(Graphics g); Imprime el contenedor.
• void printComponents(Graphics g); Imprime cada uno de los
componentes de este contenedor.
• LayoutManager getLayout(); Devuelve el gestor de impresión
(LayoutManager) asociado a este contenedor, que es el responsable de
colocar los componentes dentro del contenedor.
• void setLayout(LayoutManager 1); Establece un gestor de impresión
para este componente.

Estos objetos Container tienen un LayoutManager asociado que define la

manera en que van a posicionarse los objetos componentes en su interior.

2.5. COMPONENTES Y CONTENEDORES

2.5.1. Organización de los componentes sobre los contenedores

Los componentes deben circunscribirse dentro del contenedor que los

contiene. Esto hace que el anidamiento de componentes (incluyendo
Contenedores) en contenedores crean árboles de elementos, comenzando
con un contenedor en la raíz del árbol y expandiéndolo en sus ramas.

En la imagen siguiente presentamos una interface de usuario muy simple,

con la apariencia que presenta cuando se visualiza bajo un entorno
Windows.
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 20
______________________________________________________________________

A continuación presentamos el árbol que representa la interface que

corresponde con la aplicación gráfica generada anteriormente, donde se
puede apreciar la organización de todos los elementos de dicha interfaz.

2.5.2. Componentes, eventos y significado

La siguiente tabla nos muestra los componentes del AWT y los eventos de
cada uno de ellos, así como una breve explicación de en qué consiste cada
tipo de evento.

Eventos
Componente Significado
generados
Button ActionEvent Hacer click en el botón
Checkbox ItemEvent Seleccionar o deseleccionar un item.
CheckboxMenuItem ItemEvent Seleccionar o deseleccionar un ítem.
Choice ItemEvent Seleccionar o deseleccionar un ítem.
Mover, cambiar tamaño, mostrar u
Component ComponentEvent
ocultar un componente.
FocusEvent Obtener o perder el focus.
KeyEvent Pulsar o soltar una tecla.
MouseEvent Pulsar o soltar un botón del ratón;
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 21
______________________________________________________________________
entrar o salir de un componente; mover
o arrastrar el ratón (tener en cuenta que
este evento tiene dos Listener).
Añadir o eliminar un componente de un
Container ContainerEvent
container.
Hacer doble click sobre un ítem de la
List ActionEvent
lista.
Seleccionar o deseleccionar un ítem de
ItemEvent
la lista.
MenuItem ActionEvent Seleccionar un item de un menú.
Scrollbar AdjustementEvent Cambiar el valor de la Scrollbar.
TextComponent TextEvent Cambiar el texto.
Terminar de editar un texto pulsando
TextField ActionEvent
Enter.
Acciones sobre una ventana: abrir,
Window WindowEvent
cerrar, restablecer e iniciar el cierre.

Se debe tomar en cuenta que los eventos propios de una super-clase pueden
afectar tambien a los componentes de sus sub-clases. Por ejemplo, la clase
TextArea no tiene ningun evento específico o propio, pero puede recibir los
de su super-clase TextComponent.

2.6. GESTORES DE IMPRESIÓN

LayoutManager1 es la interface encargada de la representación y posicionamiento

en pantalla de componentes AWT.

De estas interfaces se proporcionan cinco implementaciones en AWT. Cada una de

ellas reparte los objetos de una forma particular:

• BorderLayout: En cinco lugares: Norte, Sur, Este, Oeste y Centro (North, South,
East, West y Center).

• CardLayout: Permite gestionar varios componentes de los que sólo uno se

visualiza a la vez, permaneciendo los demás invisibles debajo.

• FlowLayout: De izquierda a derecha horizontalmente en cada línea. Cuando

sobrepasan una línea se comienza a la izquierda de la siguiente.

• GridLayout: En una tabla en la que todas las casillas tienen el mismo tamaño.

• GridBagLayout: En una tabla, pero las casillas no tienen que tener el mismo
tamaño.

1
Con más detalle estos gestores de impresión así como los ejemplos se trataran capitulos siguientes de
este manual.
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 22
______________________________________________________________________

2.7. EVENTOS DE AWT

AWT tiene sus propios eventos, que se explican a continuación.

2.7.1. Eventos físicos

Son todos hijos del evento ComponentEvent, que indica algún cambio en
un objeto Component:

• InputEvent: Se ha producido una entrada del usuario. Tiene como

eventos hijos KeyEvent (pulsación de una tecla) y MouseEvent (acción
sobre el ratón).
• FocusEvent: Avisa al programa de que el componente ha ganado o
perdido la atención (enfoque) del usuario. Esto se deduce de la actividad
del usuario (ratón y teclado).
• WindowEvent: Avisa al programa de que el usuario ha utilizado uno de
los controles de ventana a nivel del sistema operativo, como los controles
de minimizar o cerrar.
• ContainerEvent: Se envía cuando se añaden o eliminan componentes a
un contenedor.
• PaintEvent: Evento especial que señala que el sistema operativo quiere
dibujar de nuevo una parte de la interfaz. Un componente debe
sobreescribir el método paint() o el método update() para gestionar este
evento.

2.7.2. Eventos semánticos

Son todos hijos del evento AWTEvent, que es el evento base de la jerarquía
de eventos:

• ActionEvent: Avisa al programa de acciones específicas de componentes

como las pulsaciones de botones.
• AdjustmenteEvent: Comunica que una barra de desplazamiento ha sido
ajustada.
• ItemEvent: Avisa al programa cuando el usuario interacciona con una
elección, una lista o una casilla de verificación.
• TextEvent: Avisa cuando un usuario cambia texto en un componente
TextComponent, TextArea o TextField.
• InputMethodEvent: Avisa que un texto que está siendo creado utilizando
un método de entrada está cambiando (se ha escrito algo más...).
• InvocationEvent: Este evento ejecuta el método run() en una clase
Runnable cuando es tratado por el thread del despachador (dispatcher) de
AWT.
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 23
______________________________________________________________________
2.8. CREACIÓN DE APLICACIONES CON AWT

Para crear una aplicación utilizando AWT, se debe generar la interfaz de esa
aplicación, mostrando los distintos elementos del AWT y posteriormente realizar la
implementación de la funcionalidad de la aplicación.

Aunque no existen reglas que se deban seguir, éste manual trata de establecer una
secuencia para diseñar la aplicación:

• Crear el marco de la aplicación, que es un container o ventana principal

donde se situarán los componentes también definir las propiedades de este
marco (fuentes, colores, layouts).

• Crear los componentes como botones, cajas, áreas de texto, botones de

opción y selección, menús, barras de desplazamiento etc, así como sus
propiedades.

• Utilizar el gestor de impresión por defecto o modificarlo y agregar los

componentes a dicho contenedor.

• Implementar el gestor de eventos (oyentes), de tal manera que el usuario

pueda controlar la aplicación actuando sobre los componentes.

• Crear otros componentes especializados como menús y barras de menús,

selector de archivos, arboles, etc.

Para crear una ventana principal así como los componentes de la aplicación, se
deben importar el paquete AWT de la siguiente manera:
import java.awt.*;
donde:
*, representa todas las clases del paquete AWT incluida la clase Frame.

2.7.1. Crear el marco de la aplicación

El Contenedor de los Componentes es el Frame que viene a ser la ventana
principal de la aplicación.

2.7.1.1. Creación de una ventana a través de un objeto Frame

import java.awt.*;

public class demoVentana

{
public static void main(String[] s)
{ Frame marco=new Frame("Principal");

//Dos operaciones básicas que se deben realizar como mínimo

//para la presentación de la ventana: tamaño y visualización
marco.setSize(250,300);
marco.setVisible(true);
}
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 24
______________________________________________________________________
}

2.7.1.2. Creación de una ventana por herencia

import java.awt.*;

public class demoVentana extends Frame

{ public demoVentana(String t)
{
setTitle(t);
setSize(250,300);
setVisible(true);
}
public static void main(String[] s)
{ demoVentana marco=new demoVentana("Principal");

}
}
Cualquiera de las dos formas de crear una ventana principal nos
va a llevar a tener el siguiente resultado:

2.8.1.3. Creación de ventana principal con diversas propiedades

import java.awt.*;

public class demVentana extends Frame

{
public demVentana()
{
// setExtendedState(Frame.MAXIMIZED_BOTH); //Maximiza la
ventana al ejecutar la aplicación
setBackground(Color.pink);
setResizable(false); //ventana tamaño fijo
//setState(Frame.ICONIFIED); //Minimiza ventana al ejecutar
aplicación
setState(Frame.NORMAL);
setLocation(150,250); // ubicar la ventana sobre la pantalla
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 25
______________________________________________________________________
setTitle("Principal");
setSize(250,300);
setVisible(true);
}

public static void main(String[] s)

{ new demVentana();
}
}

Nota: Ejemplos donde se utilicen exclusivamente las clases de

AWT, ya no se desarrollarán más porque el objetivo del libro es
utilizar clases tanto de AWT y SWING en las aplicaciones de
ejemplos, lo cual se dara después del siguiente capitulo.

2.7.2. Crear componentes

Si tomamos como ejemplo: crear un botón, una etiqueta y una caja de texto
para mostrarlos en el marco creado anteriormente sería de la siguiente
forma:

Creamos los objetos

Button cmdOk=new Button(“OK”);
Label lblMensaje=new Label(“Mensaje”);
TextField txtMensaje=new TextField(“Programando con AWT”);

Incorporar componentes al marco

Utilizando el gestor de distribución por defecto para el marco
(BorderLayout) y asumiendo que estamos creando el marco por herencia,
entonces se agregarian los componentes a través del método constructor de
la siguiente manera:
add(lblMensaje,BorderLayout.NORTH);……

De la misma forma para el resto de componentes quedando el programa

completo:

import java.awt.*;

public class demoVentana extends Frame

{
public demoVentana(String t)
{ Button cmdOk=new Button("OK");
Label lblMensaje=new Label("Mensaje");
TextField txtMensaje=new TextField("Programando con AWT");

add(lblMensaje,BorderLayout.NORTH);
add(txtMensaje,BorderLayout.CENTER);
add(cmdOk,BorderLayout.SOUTH);
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 26
______________________________________________________________________

setTitle(t);
pack();
setVisible(true);
}
public static void main(String[] s)
{
demoVentana marco=new demoVentana("Principal");
}
}

Se personaliza las características o propiedades de la ventana de la

aplicación Java que estamos desarrollando con el AWT, posteriormente se
van incorporando y visualizando los distintos Componentes que
proporciona AWT.
• Cambiar el color del fondo de la ventana
• Cambiar el color del texto de las etiquetas
• Cambiar el tipo de fuente
• Seleccionar como disposición de los componentes el Layout para ese
contenedor.
• Incorporar gráficos para reproducir títulos en la ventana principal

2.7.3. Crear Controles, Dialogos y Ventanas

2.7.4. Crar Menús y Barras de Menús

2.8. Ejemplos

A continuación presentamos algunos programas de ejemplo sobre el uso de la

librería AWT2.

2.8.1. Creación de una Ventana Principal (Frame)

Los siguientes ejemplos crean ventanas de formas diferentes y le agregan

las características que se pueden aplicar a toda ventana.

2
Debido a que SWING, mejora en gran parte las clases de AWT, los ejemplos de este manual se basan en
la utilización de clases de AWT y SWING, por lo tanto después de conocer SWING abundaremos con la
totalidad de ejemplos en este manual.
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 27
______________________________________________________________________

CAPITULO III: PAQUETE SWING

3.1. Introducción
El paquete SWING es un conjunto de clases desarrolladas por primera vez para Java
1.2 (el llamado Java2), para mejorar el anterior paquete denominado AWT, debido
a que éste último presentaba muchas limitaciones a la hora de construir
aplicaciones.
Tanto Swing como AWT forman parte de una colección de clases llamada JFC,
que incluyen paquetes dedicados a la programación de interfaces gráficos (así
como a la producción multimedia).

Swing aporta muchas más clases, consume menos recursos y construye mejor la
apariencia de los programas. En cualquier caso, AWT no desaparece; simplemente
se añade a las nuevas capacidades Swing

Todas las clases de Swing son parte del paquete javax.swing, para poder utilizar
una clase de Swing se tiene que importar la clase de la siguiente manera:

import javax.swing.*;

A pesar de que Swing tiene un estilo visual propio por defecto, puede también
utilizar un aspecto “Motif”, “Windows” o “Apple”; estos últimos sólo en las
plataformas correspondientes. Además puede cambiar de aspecto en tiempo de
ejecución

Metal Mac Os

Motif Windows
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 28
______________________________________________________________________

3.2. SWING – JERARQUÍA DE COMPONENTES

Este paquete swing esta estructurado, tal como lo muestra la siguiente figura:
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 29
______________________________________________________________________
3.3. Árbol de Contenido de un GUI Típico
Cuando se elabora un programa con clases del paquete swing, se hace uso de
contenedores de diversos tipos y componentes denominados ligeros que son los
que interactuan con el usuario.

Todos estos objetos se agrupan en una estructura de tipo árbol que nos indica que
objeto contiene otro objeto y que por lo general presenta todo programa típico que
usa este paquete Swing.

De acuerdo a la imagen que se presenta se implementa una ventana que contiene

dos botones, un campo de texto y una lista.

3.4. BIBLIOTECA O API DE SWING

El API Swing es poderoso, flexible e inmenso. Por ejemplo, la versión JFC 1.2
tiene 16 paquetes públicos

• javax.swing
• javax.swing.border (bordes)
• javax.swing.colochooser (elección de color)
• javax.swing.event (eventos)
• javax.swing.filechooser (elección de archivos)
• javax.swing.plaf (pluggable look-and-feel
• javax.swing.plaf.basic (base look-and-feel)
• javax.swing.metal (look-and-feel defecto)
• javax.swing.multi (mezclar look-and-feel)
• javax.swing.table (tablas)
• javax.swing.text (documentos)
• javax.swing.text.html (soporte edición html)
• javax.swing.text.html.parser (análisi html)
• javax.swing.text.rtf (soporte documentos RTF)
• javax.swing.tree (soporte representación de árbol)
• javax.swing.undo
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 30
______________________________________________________________________
3.5. COMPONENTES Y CONTENEDORES

3.5.1. Componentes
Los componentes son los elementos básicos de la programación con Swing.
Todo lo que se ve en un GUI de Java es un componente.
Los componentes se colocan en otros elementos llamados contenedores que
sirven para agrupar componentes. Un administrador de diseño se encarga
de de disponer la presentación de los componentes en un dispositivo de
presentación concreto, swing posee alrededor de 250 componentes que
cada vez se incrementan.

Los componentes de swing, tienen las siguientes características:

• Están escritos en Java
• Proporcionan un Look&Feel consistente entre plataformas
• Se pueden usar sobre cualquier plataforma que soporte Java 1.1 o
posteriores

Un componente está formado por:

• Propiedades
Representan un valor o estado asociado al componente. Normalmente
tiene asociado una acción que se ejecuta con la modificación de la
propiedad
Ejemplo: componente JButton

Propiedad text

Las propiedades tienen un valor antes de que se use el componente, dicho

valor puede cambiarse en tiempo de ejecución.

Modificación en tiempo de ejecución

Según el ejemplo
el método
setText, se
encarga de
modificar la
propiedad text
del componente
. JButton

• Métodos
Los métodos proporcionan el comportamiento de un componente, ya que
obligan al componente a realizar una acción
Ejemplo:
El método setText modifica el texto de un objeto JTextArea denominado
jTextArea1
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 31
______________________________________________________________________
• Eventos
Un evento es una señal o acción, externa o interna a la aplicación, que
produce la ejecución de un bloque de código que se escribe como un
método.

Ejemplos
o Pulsar el mouse
o Llamar a un método
o Modificar el valor de una propiedad

Ejemplo:

3.5.2. Contenedores

Los componentes no se encuentran aislados, sino agrupados dentro de

contenedores3.

Los contenedores, se utilizan para recoger y gestionar otros componentes y

también son componentes. Generalmente, en los contenedores no se
emplean posiciones fijas, sino que los componentes están situados con una
disposición controlada (layouts)

3
Todo los conceptos sobre componentes y contenedores se trató con detalle en la descripción del paquete
AWT, como SWING es una mejora de AWT, los conceptos se aplican igual para ambos paquetes.
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 32
______________________________________________________________________
Swing propone una jerarquía de contenedores de componentes. Cualquier
aplicación que utilice Swing debe tener un contenedor de alto nivel y uno o
más contenedores intermedios y componentes atómicos.

Los contenedores de alto nivel mas comúnmente utilizados son: JFrame,

JApplet y JDialog. Las ventanas son contenedores de otros componentes
tales como barras de menús, campos de texto, botones, etc.
De hecho una ventana está constituida por una serie de capas:
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 33
______________________________________________________________________
3.6. PROPIEDADES DE COMPONENTES

Todos los componentes del paquete swing presentas las propiedades siguientes que
son heredadas por todas las clases que derivan de la clase Component.

• text: Texto presente en el componente

• icon: Icono asociado al componente (gif, jpg)
• toolTipText Texto alternativo (cursor sobre componente)
• font Estilo asociado al componente
• background Estilo asociado al componente
• foreground Estilo asociado al componente
• doubleBuffered Dibujos (gráficos)
• border Estilos de bordes del componente
• preferredSize Ajustes de tamaños preferentes
• minimumSize Ajustes de tamaños preferentes
• maximumSize Ajustes de tamaños preferentes
• mnemonic Acceso alternativo por teclado (ALT+carácter ‘C’)

3.7. DESCRIPCIÓN DE LAS CLASES DE LOS COMPONENTES SWING

3.7.1. Contenedores

3.7.1.1. JFrame
Representa una ventana básica, capaz de contener otros
componentes. Casi todas las aplicaciones construyen al menos un
JFrame, es dependiente del escritorio y posee decoración, icono, y
controles

Constructores:
JFrame(String); // titulo

Propiedades y métodos:
.- Dimension dim = getToolkit().getScreenSize(); Tamaño
pantalla:
.- setSize(int, int); // Tamaño de ventana
.- setLocation(int_x; int_y); // Ubicación de ventana
.- setVisible(boolean); // Mostrar ventana
.- pack(); // colocar
.- add(Component...); // agregar componentes
.- setIconImage(ImageIcon); // modificar imagen

Creación de Marco
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 34
______________________________________________________________________

import javax.swing.*;
public class Ventana {

public static void main(String[] args) {

JFrame frame = new JFrame(“Mi marco");
frame.setSize(400, 300);
frame.setVisible(true);
ImageIcon g=new ImageIcon("general.gif");
this.setIconImage(g.getImage());
}
}

Resultado:

3.7.1.2. JDialog
Es un componente o ventana auxiliar que sirve para presentar
diálogos cuando se registra un evento dentro de un programa,
pueden ser modales o no modales, esto quiere decir que si son
modales la ventana del diálogo bloquea las entradas a otras
ventanas, este tipo de diálogos se pueden hacer también con
JOptionPane

Constructores
JDialog(JFrame, String, boolean) //ventana padre, título y modo
JDialog() //ventana
JDialog(Frame) //ventana padre
JDialog(Frame, boolean) //ventana padre y modo
JDialog(Frame, String) //ventana padre y título

Propiedades y métodos

int getDefaultCloseOperation() // cerrar un diálogo

setDefaultCloseOperation(int) // Obtiene lo que sucede cuando el
usuario intenta cerrar el dialog.
Valores posibles:
DISPOSE_ON_CLOSE, DO_MOTHING_ON_CLOSE,
HIDE_ON_CLOSE (por defecto)
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 35
______________________________________________________________________
void setLocationRelativeTo(Component) // Centrar diálogo

Ejemplo

JDialog dialogo;
JFrame credi;
credi=new JFrame();

dialogo = new JDialog(credi, "Creditos", true);

JTextArea salida = new JTextArea("Este Programa fue diseñado para\n"+
" Comprobar uso de JDialog\n"+
"Que es una ventana hijo de credi y es modal(true)");
Container contentPane = dialogo.getContentPane();
contentPane.add(salida, BorderLayout.CENTER);
dialogo.setSize(new Dimension(300, 150));
dialogo.setVisible(true);

Resultado

3.7.1.3. JPanel
Es un contenedor de propósito general para componentes de peso
ligero., utiliza un controlador de distribución para posicionar y
dimensionar sus componentes. Un objeto JPanel permite añadirle
bordes y determinar si utiliza el doble buffer para aumentar el
rendimiento. Tiene su controlador de distribución por defecto que
es FlowLayout.

Constructores
JPanel()
JPanel(boolean) //Determina estrategia de buffer: trae doble
buffer
JPanel(LayoutManager) //porporciona controlador distribución
JPanel(LayoutManager, boolean)

Propiedades y métodos
void add(Component) //Añade el componente al panel.
int getComponentCount() //obtiene nº de componentes de panel
Component getComponent(int) //obtiene componente basándose
en su índice
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 36
______________________________________________________________________
Ejemplo

JPanel panel=new JPanel();

. JButton boton=new JButton("OK");
panel.add(boton); //agrega botón al panel
panel.setBackground(Color.yellow); //color al fondo de panel
panel. setBorder(BorderFactory.createTitledBorder("Panel de botones"));
//agrega borde y título

getContentPane().add(panel,BorderLayout.CENTER);
setSize(200,150);
setVisible(true);

Resultado

3.7.2. Etiquetas e iconos

Añade componentes no interactivos al interfaz

3.7.2.1. JLabel
Objeto que permite situar un texto y/o
imagen no seleccionable en una línea,
generalmente usado para identificar
otros elementos widgets. Estos objetos
no tienen ningún tipo de interacción
con el usuario.
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 37
______________________________________________________________________
Constructores:
JLabel(String text)
JLabel(Icon icon)
JLabel(String text, int alin_hor)
JLabel(Icon icon, int alin_hor)

Propiedades y métodos
String texto;
Icon icono;
int horizontalAlignment

Métodos
setText(String s);
String getText();
setIcon(new ImageIcon(“fich.gif"));
setHorizontalAlignment(int); // LEFT, CENTER, RIGHT
setVerticalAlignment(int); // TOP, CENTER, BOTTON

3.7.2.2. ImageIcon
Implementa la clase abstracta Icon, visualiza imágenes .jpg/.gif
que deben estar ubicadas en el mismo directorio de la aplicación.
Componentes: setIcon

Constructores:
ImageIcon(String Fichero);

Propiedades
String texto;
Icon icono;
int horizontalAlignment

Métodos
setImage(String fichero);
Image getImage();

Ejemplo

ImageIcon icono = new ImageIcon(“ok.gif");

...
Icono.setImage(“hola.gif”);
JLabel et = new Jlabel (icono);

3.7.3. Botones
Son componentes para capturar eventos generados por el usuario (por
pulsación).
• Pueden representar texto y/o iconos.
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 38
______________________________________________________________________
• La clase DefaultButtonModel define el estado del botón
• Se pueden agrupar (ButtonGroup)

El siguiente gráfico nos muestra la estructura de los botones a partir de las

definiciones realizadas en la clase abstracta AbstracButton

3.7.3.1. DefaultButtonModel
Propiedades de los diferentes tipos de botones controlados por la
clase DefaultButtonModel
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 39
______________________________________________________________________
3.7.3.2. JButton
Objeto de control de pulsación de tipo widget que permiten al
usuario comenzar un evento, como buscar, aceptar una tarea,
interactuar con un cuadro de diálogo, etc.
Un botón se presiona haciendo clic sobre el mismo, o al presionar
Enter si está seleccionado. También suele poder presionarse con
alguna tecla o combinación de teclas.
Los botones más comunes, especialmente en los cuadros de
diálogos y formularios son:

* Aceptar (OK), Enviar (Send), Si (Yes), Cancelar (Cancel),

Cerrar (Close).
* En los sistemas de ventanas, los pequeños botones de
minimizar, maximizar, cerrar y restaurar en las ventanas, son
representados con pequeños íconos.

Constructores
JButton(String text)
JButton(Icon icon)
JButton(String text, Icon icon)

Propiedades
String texto;
Icon icono;
int mnemonic;

Métodos
setText(String);
setIcon(Icon);
setRolloverIcon(Icon); // muestra al estar encima del botón
setDisabledSelectedIcon()
setPressedIcon()

Ejemplo

JButton jb = new JButton();

jb.setIcon (new ImageIcon(“a.jpg”);

3.7.3.3. JToggleButton
Botón con proporciona el estado en un momento determinado
(seleccionado/deseleccionado)
Un ejemplo de esto, son los botones de Negrita, Cursiva,
Subrayado en los editores de texto comunes.
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 40
______________________________________________________________________
Existen dos tipos de botones que se extiende de esta clase tal
como lo muestra la figura siguiente:

Constructores
JToggleButton(String text)
JToggleButton(Icon icon)
JToggleButton(Icon icon, boolean selected);

Propiedades y métodos
bool getSelected()
void setSelected (bool)

JToggleButton jtb = new JToggleButton();

jtb.setSelected(true);

3.7.3.4. JCheckBox / JRadioButton

JCheckBox (Casillas de Verificación)

Elemento widget que permite al usuario marcar múltiples
selecciones de un número de opciones. Generalmente son
mostrados en pantalla como cuadraditos que pueden estar vacíos
(para falso) o tildados (para verdadero), al lado de los cuadrados
hay un texto que explica el significado de que el casillero esté o
no chequeado.

JRadioButton (Radio Botón)

Elemento widget que permite al usuario elegir sólo una opción de
un conjunto predefinido de opciones.
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 41
______________________________________________________________________

Un botón de opción no seleccionado se mantiene en blanco, en

tanto uno seleccionado se rellena. Al lado de cada botón de opción
se encuentra un texto que describe la opción que ese botón
representa.

Cuando un usuario selecciona un botón de opción, cualquier otro

botón de opción previamente seleccionado se deselecciona .

Estos tipos de botones pueden contener iconos y emiten un

ItemEvent al cambiar de estado (ItemStateChanged)

ItemEvent.SELECTED
ItemEvent.DESELECTED

Constructores
JCheckBox/JRadioButton(String text [, boolean selec])
JCheckBox /JRadioButton(Icon icon [, boolean selec])
JCheckBox /JRadioButton(String text, Icon icon [, boolean selec])

Propiedades
String texto;
Icon icono;
int mnemonico
boolean selec

Métodos
setText(String);
setIcon(Icon);
boolean isSelected()
setSelected(boolean b)

JCheckBox jcb = new JCheckBox(“opcion1”);

jcb.setSelected(true);

JRadioButton jrb = new JRadioButton(“opcion1”);

jrb.setSelected(true);
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 42
______________________________________________________________________
3.7.3.5. ButtonGroup (Grupo de Botones)
Es un conjunto de opciones predefinidas utilizando objetos
JRadioButton, y que permite agrupar en forma lógica estos
botones para poder hacer que se comporten de manera excluyente.

Constructor
ButtonGroup()

Propiedades
String texto;
Icon icono;
int mnemonico
boolean selec

Métodos
add/remove(AbstractButton); // añade/quita botones
setSelected(ButtonModel m, boolean b);
boolean isSelected(ButtonModel m); // comprueba si está
seleccionado botón
int getButtonCount(); // número de botones

Ejemplo

ButtonGroup bg1 = new ButtonGroup();

bg1.add(jRadioButton1);
bg1.add(jRadioButton2);

3.7.4. Rangos
Son componentes para obtener un valor dentro de un rango
La clase DefaultBoundedRangeModel define el estado del Componente
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 43
______________________________________________________________________

3.7.4.1. DefaultBoundedRangeModel
Clase que define el estado (modelo) del componente.

DefaultBoundedRangeModel modelo = new DefaultBoundedRangeModel( );

model.setMaximum(10);
model.setMinimum(0);
model.setValue(3);

3.7.4.2. JScrollBar
Componentes para obtener un valor dentro de un rango

Constructores
JScrollBar()
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 44
______________________________________________________________________
Propiedades
String texto;
Icon icono;
int mnemonic;
boolean selecc;

3.7.4.3. JProgressBar

Descripción
Barra para medir el progreso (grado de acabado) de un suceso

Constructores
JProgressBar( ) // Barra progreso horizontal
JProgressBar(int orient, int min, int max)
JProgressBar(int min, int max)
JProgressBar(int orient)

Propiedades
int orientation; // JProgressBar.HORIZONTAL|VERTICAL
setString(String s); // mostrar en el progreso
setStringPainted(boolean b);

Ejemplo
JProgressBar pbar;
pbar.setMinimum(0);
pbar.setMaximum(100);
pbar.value(35);
pbar.setString(“35%”);
pbar.setStringPainted(true);

Resultado
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 45
______________________________________________________________________
3.7.4.4. JSlider
Barra para medir el valor en un rango, permite introducir un valor
numérico entre un máximo y un mínimo de manera rápida.

Constructores
JSlider();
JSlider(int orientation)
JSlider(int min, int max);
JSlider(int min, int max, int value);
JSlider(int orientation, int min, int max, int value);

Propiedades y Metodos
int orientation; // JSlider.HORIZONTAL|VERTICAL
setMajorTickSpacing(int n ) // marca cada n valores
setMinorTickSpacing(int n ) // distancia de marcas pequeñas
setPaintTicks( boolean ) // dibujar las marcas
setValue(int) // Valor del deslizador
setPaintLabels (boolean) // mostrar etiquetas

Ejemplo
JSlider s;
s.setMinimum(0); s.setMaximum(20);
s.setValue(4);
s.setMajorTickSpacing(5);
s.setMinorTickSpacing(1);
s.setPaintTicks(true);
s.setPaintLabels(true);

Resultado

3.7.5. Texto

Los componentes de texto muestran algún texto y opcionalmente permiten

que el usuario lo edite. Los programas necesitan componentes de texto para
tareas dentro del rango del correcto (introducir una palabra y pulsar Enter)
al complejo (mostrar y editar texto con estilos y con imagenes embebidas
en un lenguaje asiático). Todos los componentes de texto Swing descienden
de la misma superclase, JTextComponent, que proporciona una base
poderosa y ampliamente configurable para la manipulación de texto.

Aquí podemos ver una imagen que muestra cada uno de los componentes
de texto Swing
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 46
______________________________________________________________________

Jerarquia de clases de texto

3.7.5.1. JTextField (Cuadro de texto)

Objeto en donde es posible insertar una línea de texto. Los
cuadros de texto suelen utilizarse en formularios, herramientas y
aplicaciones donde se muestra texto, generalmente editable.
Suelen tener también barras de desplazamiento para que el usuario
pueda moverse dentro de textos que exceden el cuadro.

Constructores
JTextField();
JTextField(String, int); // nº columnas
JTextField(String);

Propiedades
text, editable, columns
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 47
______________________________________________________________________
Métodos
setText(String);
setColumns(int) // nº columnas
setEditable(boolean editable)

JTextField txtTexto = new JTextField(10);

txtTexto.setActionCommand(“xxx”);
txtTexto.addActionListener(this);

3.7.5.2. JPasswordField
JPasswordField es una subclase de JTextField que, en vez de
mostrar el caracter real tecleado por el usuario, muestra otro
caracter como un asterisco '*'. Este tipo de campo es útil para
pedir al usuario que introduzca passwords cuando se conecta o
para validar su identidad.

Constructores
JPasswordField();
JPasswordField(String, int);// nº columnas
TextField(String);

Métodos
setPassword(String);
setEchoChar(char) // carácter
setColumns(int) // nº columnas
boolean echoCharIsSet();

JPasswordField txtClave = new JPasswordField(10);

txtClave.setActionCommand(“Clave”);
txtClave.addActionListener(this);

3.7.5.3. JTextArea
Es el único componente de texto plano, que puede mostrar y editar
múltiples líneas de texto.
En este objeto se puede utilizar setText y getText para recuperar o
modificar el contenido del componente en una simple llamada al
método.

Constructores
JTextArea(String t, int n_fila, int n_col);
JTextArea(int n_fila, int n_col);
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 48
______________________________________________________________________
Propiedades
text, editable, columns, rows
lineCount

Métodos
setText(String);
String getSelectedText();
insert(String s, int pos); // inserta texto en pos.
replaceRange(String s, int inicio, int fin) // sustituye texto en el
rango
append(String s); // añade al final.

JTextArea txtArea = new JTextArea(5, 10);

txtArea.setFont(new Font("Serif", Font.ITALIC, 16));
txtArea.setText("En un lugar \n " +"de la mancha " );
txtArea.setLineWrap(true); // activa la ruptura de líneas
textArea.setWrapStyleWord(true); // Le dice al área de texto que rompa
la líneas entre palabras

JScrollPane areaScrollPane = new JScrollPane(txtArea);

areaScrollPane.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_S
CROLLBAR_ALWAYS);
areaScrollPane.setPreferredSize(new Dimension(250, 250));

Agregar un objeto JTextArea sobre un objeto JScrollPane, para

incluir barras de desplazamiento.

3.7.6. Elección
Componentes que permiten elegir una opción entre una serie de alternativas
• Se permite selección simple/múltiple
• El modo de selección múltiple depende del Look&Feel (Shift, Crtl...)
Componentes como:
• JList
• JComboBox

3.5.7.1. JList
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 49
______________________________________________________________________
Consta de tres partes: Modelo de datos (ListModel) Modelo de
selección (ListSelectionModel) y Modelo de representación
(ListCellRenderer)

Descripción:
• Lista de elementos (para selección)
• Admite diferentes modos de selección
• No dispone de barra de desplazamiento (scroll) automáticamente
(se debe insertar en un panel JScrollPane
• Listas sencillas (tamaño fijo) o variables (ListModel)

Constructores:
JList (Octect[] elementos); // array de (String) elementos para
visualizar
JList (ListModel modelo); // modelo de datos complejos

Propiedades y Métodos
String texto;
Icon icono;
int modo; // SINGLE_SELECTION,
// SINGLE INTERVAL_SELECTION,
//MULTIPLE_INTERVAL_SELECTION
void setVisibleRowCount (int filas); // columnas visibles
void setSelectionMode(int modo); // modo selección
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 50
______________________________________________________________________

asad
s

3.5.7.2. ListModel/DefaultListModel

Descripción:
• Lista de elementos (para selección)
• Adecuado para: listas largas, cambiantes, de objetos, etc.
• Control para el manejo de la lista (Interfaz ListModel)
• Existe una implementación predefinida (DefaultListModel)
Constructor:
void addElement(object o); // añade elemento al final de la lista
void removeElement(object o); // elimina la primera ocurrencia
del objeto en la lista
removeAllElements();

Propiedades y métodos
String texto;
Icon icono;
int modo; // SINGLE_SELECTION,
// SINGLE INTERVAL_SELECTION,
MULTIPLE_INTERVAL_SELECTION

void setVisibleRowCount (int filas); // columnas visibles

void setSelectionMode(int modo); // modo selección

Ejemplo

public interface ListModel {

public int getSize();
public Object getElementAt(int pos);
…
}

3.5.7.3. JComboBox

Descripción
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 51
______________________________________________________________________
Objeto que combina entrada de texto con una lista desplegable,
permite seleccionar una opción entre varias posibles, el primer
elemento aparece como seleccionado (índice 0)

ComboBoxModel extiende ListBoxModel para permitir una única

selección
• MutableComboBoxModel permite listas editables

Descripción:
• Combinación de entrada de texto con lista desplegable
• Posee ScrollBar automático
• El primer elemento aparece como seleccionado (índice 0)

Constructor
public JComboBox();
public JComboBox(ComboBoxModel aModel);
public JComboBox(Object items[]); //array de elementos

Propiedades y métodos
int getSelectedItem(); // selección actual
void setMaximumRowCount( int n ) // número de elementos a
mostrar en el combo
int getItemCount(); // contabilizar nº de elementos
void setEditable(boolean ); // si permite realizar cambios en la
lista
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 52
______________________________________________________________________

3.5.7.4. ComboBoxModel/ DefaultComboBoxModel

Descripción:
• Modelo para representar los datos de un JComboBox
• Permite edición

Constructores:
public DefaultComboBoxModel( );
public JComboBox(Vector items);

Métodos
void addElement(object o); // añade elemento al final de la lista
public void insertElementAt(Object obj, int index); // en una
posición
void removeElement(object o); // elimina la primera ocurrencia
del objeto en la lista
removeAllElements();

Ejemplo

JComboBox c = new JComboBox();

DefaultComboBoxModel m = new DefaultComboBoxModel();
m.addElement((String) "Granada");
m.addElement("Jaén");
c.setModel(m);
c.setEditable(true);

3.5.8. Otros Componentes

Otros componentes tenemos

3.5.8.1. JOptionPane
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 53
______________________________________________________________________
Clase que contiene métodos estáticos para crear distintos tipos de
diálogos modales.
Cuando un dialogo modal es visible, bloquea las entradas del
usuario en todas las otras ventanas del programa.
Con parámetros: padre, mensaje, titulo, tipo de opción
(ERROR_MESSAGE,…), tipo de mensaje
(OK_CANCEL_OPTION, YES_NO_OPTION, ……), ícono a
utilizar y opciones.
Para la mayoría de los diálogos modales sencillos, se crea y se
muestra el diálogo utilizando uno de los métodos showXxxDialog
de JOptionPane

Constructores
JOptionPane()
JOptionPane(Object)
JOptionPane(Object, int)
JOptionPane(Object, int, int)
JOptionPane(Object, int, int, Icon)

Métodos
showConfirmDialog(…)
Muestra un diálogo modal con dos botones, etiquetados "Yes" y
"No". Estas etiquetas no son siempre terriblemente descriptivas
con las acciones específicas del programa que causan.

showInputDialog(….)
Muestra un diálogo modal que obtiene una cadena del usuario. Un
diálogo de entrada muestra un campo de texto para que el usuario
teclee en él, o un ComboBox no editable, desde el que el usuario
puede elegir una de entre varias cadenas

showMessageDialog(…. )
Muestra un diálogo modal con un botón, etiquetado "OK". Se
puede especificar fácilmente el mensaje, el icono y el título que
mostrará el diálogo.
showOptionDialog(…)
Muestra un diálogo modal con los botones, los iconos, el mensaje
y el título especificado, etc. Con este método, podemos cambiar el
texto que aparece en los botones de los diálogos estándard.
También podemos realizar cualquier tipo de personalización

3.5.8.2. JFileChooser
Elemento para seleccionar archivos, incluye métodos para mostrar
dialogo de selección.

Coinstructor
JFileChooser( )
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 54
______________________________________________________________________

Propiedades y métodos
showOpenDialog(JFileChooser )
getSelectedFile()

3.5.8.3. JColorChooser

Componente para seleccionar un color, permite crear un dialogo

de selección.

3.5.8.4. JSplitPane

Un JSplitPane contiene dos componentes de peso ligero,

separados por un divisor. Arrastrando el divisor, el usuario puede
especificar qué cantidad de área pertenece a cada componente. Un
SplitPane se utiliza cuando dos componentes contienen
información relacionada y queremos que el usuario pueda cambiar
el tamaño de los componentes en relación a uno o a otro.

Constructores
JSplitPane() //crea un SplitPane
JSplitPane(int) //int indica orientación
HORIZONTAL_SPLIT o
VERTICAL_SPLIT
JSplitPane(int, boolean) // booleano selecciona si los componentes
se redibujan continuamente cuando el
usuario arrastra el divisor.
JSplitPane(int, Component, Component) // Los parámetros
Component seleccionan los componentes izquierdo y derecho o
superior e inferior, respectivamente.
JSplitPane(int, boolean, Component, Component)
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 55
______________________________________________________________________

Propiedades y métodos
void setOrientation(int) // selecciona la orientación del SplitPane
puede ser HORIZONTAL_SPLIT o
VERTICAL_SPLIT
void setDividerSize(int) //selecciona tamaño de divisor en pixeles
setOneTouchExpandable(boolean) // selecciona si el SplitPane
muestra los botones de control expandibles
void setTopComponent(Component) //selecciona el componente
indicado
void setBottomComponent(Component)
void setLeftComponent(Component)
void remove(Component) //elimina componente
void removeAll() //elimina todos los componentes
void add(Component) // agrega un componente
void setDividerLocation(double)

3.5.8.5. JTabbedPane

Descripción
Con la clase JTabbedPane, podemos tener varios componentes
(normalmente objetos JPanel) compartiendo el mismo espacio. El
usuario puede elegir qué componente ver seleccionando la pestaña
del componente deseado.

Constructores
JTabbedPane() //crea un TabbedPaned
JTabbedPane(int) // crea un TabbedPane con orientación de las
pestañas de acuerdo a los valores TOP, BOTTOM, LEFT, LEFT.

Propiedades y métodos

addTab(String, Icon, Component, String) //añade nueva pestaña

addTab(String, Icon, Component)
addTab(String, Component)
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 56
______________________________________________________________________
insertTab(String, Icon, Component, String, int) //inserta nueva
pestaña en índice especificado
remove(Component) //elimina una pestaña de acuerdo a
componente
removeTabAt(int) //elimina pestaña de acuerdo a índice
removeAll() //remueve todas las pestañas
int indexOfComponent(Component) //devuelve el índice de la
pestaña del componente espcificado
void setSelectedIndex(int) //
void setTitleAt(int,String) //selecciona el titulo de la pestaña
void setIconAt(int, Icon) //selecciona el ícono de acuerdo a
índice y figura
void setBackgroundAt(int,Color) //selecciona color de fondo
void setEnabledAt(int,boolean)
void setForegroundAt(int,Color)

3.5.8.6. JToolBar
Es un objeto contenedor que permite agrupar otros componentes
normalmente botones con iconos en una fila o columna
Las barras de herramientas tienen la particularidad de que el
usuario puede situarlas en distintas configuraciones sobre el frame
principal

Constructores
JToolBar() // crea una barra de herramientas

Propiedades y métodos

Component add(Component) //añade un componente

void addSeparator() // añade separador al final de la barra de
herramientas
void setFloatable(boolean) // La propiedad floatable es true por
defecto, para indicar que el usuario puede arrastrar la barra de
herramientas a una ventana separada.

3.5.8.7 JInternalFrame
Con la clase JInternalFrame, se puede mostrar un JFrame, como
una ventana dentro de otra ventana. Para crear un frame interno
que parezca un diálogo sencillo, se pueden utilizar los métodos
showInternalXxxDialog de JOptionPane.
Normalmente, los frames internos se muestran dentro de un
JDesktopPane que es una subclase de JLayeredPane al que se le
ha añadido el API para manejar el solapamiento de múltiples
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 57
______________________________________________________________________
frames internos. Generalmente, se pone el panel superior dentro
del panel de contenido de un JFrame.

Constructores
JInternalFrame()
JInternalFrame(String)
JInternalFrame(String, boolean)
JInternalFrame(String, boolean,boolean)
JInternalFrame(String, boolean,boolean, boolean)
JInternalFrame(String, boolean,boolean, boolean, boolean)

Métodos de la clase JOptionPane:

· showInternalConfirmDialog
· showInternalInputDialog
· showInternalMessageDialog
· showInternalOptionDialog

void setContentPane(Container)
Container getContentPane()
void setMenuBar(JMenuBar)
void pack()
void setDefaultCloseOperation(int) // Selecciona lo
que hace el frame interno cuando el usuario intenta "cerrar" el
frame. El valor por defecto es HIDE_ON_CLOSE. Otros
posibles valores son DO_NOTHING_ON_CLOSE y
DISPOSE_ON_CLOSE.

void addInternalFrameListener(InternalFrameListener)
void moveToFront()
void moveToBack()
void setClosed(boolean)
boolean isClosed()
void setMaximum(boolean)

3.5.8.8. JToolTip.
Consiste en una etiqueta de ayuda que surge al cabo de uno
segundos sobre la posición apuntada por el cursor. Normalmente
no es necesario utilizar directamente la clase JToolTip, se puede
establecer para cualquier componente de la ventana mediante:
e.setToolTipText (“Ésta es la etiqueta”).
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 58
______________________________________________________________________
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 59
______________________________________________________________________
CAPITULO III APLICACIONES

3.1. INTRODUCCION
En este capitulo vamos a proporcionar ejemplos que van desde casos simples hasta
casos de mediana complejidad.
Asimismo se combinan el uso de los paquetes AWT y SWING de tal manera que
les sirva de guía durante la creación de los programas que ustedes diseñen.

3.2. PRIMEROS PASOS CON SWING

Casi siempre, el primer paso a la hora de
construir una aplicación es crear un
JFrame (marco o ventana principal) inicial
Por defecto un JFrame se crea de forma
invisible, y sin tamaño, así que es
necesario activar su visualización
mediante la operación setVisible() y
definirle un tamaño a través de setSize().

El código para obtener esta ventana o interfaz será:

Se importa el paquete swing así como
import javax.swing.*; todas sus clases representadas por el
comodín asterisco (*).
public class Marco1 { Se define la clase con un nombre para
public static void main(String[] args) { este caso Marco1, se crea el objeto f,
JFrame f = new JFrame("Prueba"); que representa la ventana a la cual se
f.setSize(200,300); le define un tamaño que permite
f.setVisible(true); especificar ancho y alto. En nuestro
} caso, tiene una anchura de 200 y una
} altura de 300 y hacer visible la
ventana a través del argumento true.

Sin embargo, al cerrar este JFrame la aplicación no termina. Esto ocurre porque es
necesario asociar la acción de cerrar el JFrame con la finalización de la aplicación
podemos realizar esta asociación mediante la operación
setDefaultCloseOperation() con su argumento constante EXIT_ON_CLOSE de la
clase JFrame.

import javax.swing.*;

public class Marco1 {

public static void main(String[] args) {
JFrame f = new JFrame("Prueba");
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f.setSize(200,300);
f.setVisible(true);
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 60
______________________________________________________________________
}
}

Crear Ventana Principal Por Herencia

En este caso la estructura del programa es la siguiente:

import javax.swing.*;

public class Marco1 extends JFrame {

public Marco1( ) {
setTitle("Prueba");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setSize(200,300);
setVisible(true);
}

public static void main(String[] args) {

Marco1 f = new Marco1();
}
}

En este caso se crea la ventana aplicando herencia, donde las propiedades de la ventana
se definen en el método constructor de la clase, de tal manera que cuando se crea el
objeto ventana se aplican las propiedades incluidas en el método constructor.

Otras propiedades que pueden ser modificadas a través de los siguientes métodos:
.- setLocation(100,100);
Este método ubica la ventana de acuerdo a la siguiente estructura:

Declara la posición del ángulo derecho en la parte que está arriba de la ventana en el
desktop, en este caso <100, 100> (Son la x y la y respectivamente. La x se mide partiendo del
lado izquierdo de la pantalla y aumenta a medida que se va hacia la derecha. La y se mide
partiendo de la parte superior de la pantalla y aumenta a medida que se va hacia abajo).
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 61
______________________________________________________________________
3.3. Añadir Componentes a una Ventana
La estructura de la ventana o JFrame
esta compuesta por capas tal como lo
muestra la figura:

Entonces los componentes se deben

añadir a la capa Content Pane (panel de
contenido), como lo hace, existen varias
formas dos de ellas son las siguientes:

.- getContentPane
.- setContentPane

Mediante el método Container getContentPane() que retorna la capa Content Pane

y el método .add() que agrega el componente a la capa obtenida, quedaría de la
siguiente forma:
getContentPane().add(ObjetoComponente, ubicación).

Una variante de la forma anterior seria:

• Obtener la capa:
Container c=getContentPane();
• Agregar el componente.
c.add(ObjetoComponente, ubicación);

Lo del getContentPane() es porque en realidad la ventana no es el contenedor, sino

un componente que lleva internamente la ventana y que se puede obtener a través
de este método. Es a este componente al que debemos añadirle el layout y los
componentes (botoncitos y demás).
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 62
______________________________________________________________________
Ejemplo
Vamos a crear un JLabel con el texto “Hola mundo” y lo vamos a añadir al
JFrame. Con esto ya tenemos un “Hola mundo” en Swing

import javax.swing.*;

public class HolaMundo {

public static void main(String[] args) {

JFrame f = new JFrame("Prueba");

f.getContentPane().add(new JLabel(“Hola mundo”),BorderLayout.NORTH);

f.setSize(200,300);

f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f.setVisible(true);
}
}

Como se habrá podido dar cuenta se ha incluido BorderLayout.NORTH, esta

instrucción hace referencia a la ubicación del componente sobre la ventana.
Para esto debemos saber que la ventana tiene un administrador de diseño por
defecto que se denomina BorderLayout, que se va a explicar en el punto siguiente
de gestores de distribución.
3.4. Gestores de Distribución (LayoutManager)
Una de las tareas más tediosas a la hora de diseñar un JFrame con varios elementos
en el interior es posicionar y establecer el tamaño de cada uno de estos elementos.
Tenemos dos alternativas para esta tarea:
• Posicionar cada uno de los elementos, indicando posiciones y tamaños.
Además al cambiar el tamaño del JFrame los elementos no pueden actualizarse
perdiendo el aspecto armónico que deben tener la interfaz.

• Utilizar un gestor de distribución que se encarga de distribuir los componentes

de forma automática. Y que permiten actualizar el aspecto de la interfaz.

Ejemplo de una distribución de componentes sobre una ventana principal

Universidad Nacional de Piura – Jorge L.Sandoval Rivera 63
______________________________________________________________________
En la programación con Swing se recomienda el uso de un gestor de distribución
(LayoutManager) para la distribución de los componentes en marcos y cuadros de
diálogo
• Podemos establecer el gestor de distribución para los elementos situados en un
panel mediante: panel.setLayout(<gestor de distribución>)
• Podemos anular la distribución automática mediante panel.setLayout(null) e
indicar coordenadas absolutas.
• Así para cualquier otro contenedor
• Para establecer el tamaño del JFrame que contiene los componentes tenemos
igualmente dos opciones:
o Utilizar f.pack() para que ajuste su tamaño al de los componentes de su
interior. Esta es la opción más recomendable
o Establecer su tamaño indicando ancho y alto mediante frame.setSize()

Los gestores de organización que ofrece Java entre otros son:

3.4.1. BorderLayout
Se puede utilizar para colocar en un contenedor cinco componentes como
máximo ya que proporciona cinco posiciones donde colocar los
componentes, estas son:
• NORTH (arriba). • EAST (derecha)
• SOUTH (abajo) • CENTER (en el centro).
• WEST (izquierda)

Es el gestor de distribución por defecto que tiene definido un objeto JFrame

Ejemplo
Crear una ventana con 5 botones y se colocan en cada posición que este
gestor proporciona.

import java.awt.*;
import javax.swing.*;

class panel extends JFrame {

JButton b1,b2,b3,b4,b5;

public panel() {

Container c = getContentPane();

b1=new JButton("Norte");
b2=new JButton("Sur");
b3=new JButton("Este");
b4=new JButton("Oeste");
b5=new JButton("Centro");

//agregar botones al contenedor

Universidad Nacional de Piura – Jorge L.Sandoval Rivera 64
______________________________________________________________________
c.add(b1,BorderLayout.NORTH);
c.add(b2,BorderLayout.SOUTH);
c.add(b3,BorderLayout.EAST);
c.add(b4,BorderLayout.WEST);
c.add(b5,BorderLayout.CENTER);

//Propiedades de la ventana
setTitle("Gestor BorderLayout");
setSize(400,250);
setVisible(true);
}
public static void main (String[] args){
panel t= new panel();

}
}

3.4.2. FlowLayout

Coloca los componentes de izquierda a derecha conforme se van añadiendo a

la ventana. El tamaño de los componentes se ajusta a su contenido.

Ejemplo: En este caso se modifica el gestor de diseño por defecto cambiando

por el gestor FlowLayout, a través del método setLayout. Se agregan los
botones creados de izquierda a derecha y la ventana toma el tamaño de todos
los objetos a través del método pack.

import java.awt.*;
import javax.swing.*;

class panel extends JFrame {

JButton b1,b2,b3,b4,b5;

public panel() {

Container c = getContentPane();
c.setLayout(new FlowLayout());

b1=new JButton("Primero");
b2=new JButton("Segundo");
b3=new JButton("Tercero");
b4=new JButton("Cuarto");
b5=new JButton("Quinto");

//agregar botones al contenedor

c.add(b1);
c.add(b2);
c.add(b3);
c.add(b4);
c.add(b5);

setTitle("Gestor FlowLayout");
pack();
setVisible(true);
}
public static void main (String[] args){
panel t= new panel();
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 65
______________________________________________________________________
}
}

3.4.3. GridLayout:
Coloca los componentes del mismo tamaño y los coloca en filas y
columnas en función de los valores pasados al constructor.

Ejemplo, para este ejemplo se modifica el gestor de diseño del JFrame por
el gestor GridLayout que ubica los 4 botones en 2 filas y 2 columnas y
además define con valor 5 la distancia tanto vertical como horizontal entre
los botones que son los dos últimos argumentos del objeto GridLayout.

import java.awt.*;
import javax.swing.*;

class panel extends JFrame {

JButton b1,b2,b3,b4;

public panel() {

Container c = getContentPane();
c.setLayout(new GridLayout(2,2, 5,5));

b1=new JButton("Primero");
b2=new JButton("Segundo");
b3=new JButton("Tercero");
b4=new JButton("Cuarto");

//agregar botones al contenedor

c.add(b1);
c.add(b2);
c.add(b3);
c.add(b4);

setTitle("Gestor GridLayout");
pack();
setVisible(true);
}

public static void main (String[] args){

panel t= new panel();

}
}
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 66
______________________________________________________________________

3.4.4. BoxLayout
Este gestor de distribución organiza los componentes horizontal o
verticalmente, ajustando los componentes al espacio disponible

Ejemplo, para este caso el BoxLayout organiza los componentes

horizontalmente, aquí el método constructor panel, recibe el título de la
ventana y lo envia a través de super al método constructor de la clase padre,
otra variante en este ejemplo respecto a los anteriores es que conforme se
crean los objetos se van agregando al contenedor.

import java.awt.*;
import javax.swing.*;

class panel extends JFrame {

public panel(String titulo) {

super(titulo);
Container c = getContentPane();

//Modifica gestor por defecto

c.setLayout(new BoxLayout(c, BoxLayout.X_AXIS));

//se crean componentes y se agregan al contenedor

c.add(new JLabel("Código"));
c.add(new JTextField(8));
c.add(new JLabel("Titular"));
c.add(new JTextField(30));
c.add(new JLabel("Saldo"));
c.add(new JTextField(8));
c.add(new JLabel("Interés"));
c.add(new JTextField(4));

setTitle("Gestor BoxLayout");
pack();
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setVisible(true);
}

public static void main (String[] args){

panel t= new panel("Gestión de Cuentas");

}
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 67
______________________________________________________________________
}

Cambiando la constante BoxLayout.X_AXIS, que los distribuye

horizontalmente por BoxLayout.Y_AXIS que los distribuye
verticalmente se tiene la siguiente interfaz:

3.4.5. GridBagLayout

Este es un organizador complejo que permite ajustar la posición de los

componentes. Al colocar los componentes en los contenedores se
especifican las restricciones que se deben cumplir (posición del
componente, anchura y altura del componente, separación entre los
componentes, posición dentro del espacio que ocupa,...).

Ejemplo
Vamos a construir una ventana en la que situamos determinados
componentes (botones) en determinadas posiciones.
La ventana que pretendemos obtener es la de la siguiente figura:
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 68
______________________________________________________________________

Tiene un área de texto que ocupa casi toda la ventana. Un "Boton 1" en la
parte superior derecha, un "Boton 2" en la derecha hacia el medio, el
"Boton 3" en la equina inferior izquierda, el "Boton 4" en la esquina
inferior derecha y un campo de texto entre estos dos últimos botones.

Hacer una rejilla adecuada

El primer paso es dibujar la ventana que queremos. Es importante dibujarla
más o menos estirada, para tener claro si los botones deben hacerse grandes
o no. Por ejemplo, en la figura anterior, los botones deben mantener su
tamaño aunque estiremos la ventana, sin embargo el area de texto debe
crecer con la ventana y el campo de texto sólo debe crecer horizontalmente.

Luego, sobre el dibujo, hay que trazar unas lineas horizontales y verticales,
para tratar de delimitar una rejilla en la que iran colocados los botones. Para
trazar esta rejilla y que luego el código no nos salga muy complicado
conviene tener en cuenta lo siguiente:

• Debemos tratar de incluir los componentes en las celdas. Cada

componente debe ocupar una o más celdas. Dos componentes no pueden
ocupar la misma celda.
• No es necesario que las celdas de la rejilla sean todas del mismo tamaño
ni es necesario que un componente ocupe una celda completa.

• Para que no se lie el código, conviene que el componente ocupe toda la

celda, o bien que esté centrado en la misma, o bien pegado al centro de
uno de los bordes de la celda o a una esquina de la misma.

Un ejemplo de rejilla para nuestra ventana puede ser la de la siguiente

figura:
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 69
______________________________________________________________________

Vamos con las líneas verticales:

• La primera en el borde izquierdo de la ventana.
• La segunda entre el boton 3 y el campo de texto.
• La tercera entre el campo de texto y el boton 4.
• La última en el borde derecho de la ventana.

Estas líneas son casi obligadas, puesto que el boton 3, el campo de texto y
el boton 4 nos las limitan. No importa que una de ellas pase por enmedio
del area de texto, símplemente haremos que esta ocupe dos columnas. Estas
líneas nos limitan tres columnas que hemos numerado como 0, 1 y 2.

Vamos ahora con las líneas horizontales.

• La primera por la parte de arriba de la ventana
• La segunda puede pasar por cualquier sitio entre el boton 1 y el boton 2.
• La tercera pasa justo por debajo del area de texto y por encima de boton
3, campo de texto y boton 4
• La última por el borde inferior de la ventana.

Como hemos dicho, la segunda puede pasar por cualquier lado entre los dos
botones. Para que no se nos complique el código y según dijimos arriba,
cogiendo la segunda línea pegando por arriba al botón 2 (como hemos
hecho en el dibujo), ya tenemos al boton 2 ocupando la parte superior de su
celda. También podíamos haberla pegado al botón 1, así el botón 2 estaría
más o menos en el centro de su celda. Lo que complicaría luego el código
sería poner la línea entre ambos botones, por lo que el boton 2 quedaría a
1/3 de la parte superior de su celda.

Resumiendo, nuestro area de texto ocupa cuatro celdas, los botones una
cada uno y el campo de texto otra. Boton 1 y 2 no ocupan toda la celda,
pero están en la parte superior de la misma.

Nuestra primera aproximación

Universidad Nacional de Piura – Jorge L.Sandoval Rivera 70
______________________________________________________________________
Vamos a hacer nuestro primer código para obtener la ventana. Nuestra
ventana será un JFrame, así que hacemos una clase que herede de JFrame y
le ponemos el GridBagLayout.

class Ventana extends JFrame

{
public Ventana()
{
super ("Ejemplo 1"); // El título
this.getContentPane().setLayout (new GridBagLayout()); // Le ponemos
el GridBagLayout
..........
}
}

Ahora debemos empezar a añadir componentes. Tenemos por un lado el

método add() con un sólo parámetro.

JTextArea areaTexto = new JTextArea("Area texto");

this.getContentPane().add (areaTexto);

Esta llamada añade el área de texto, dejando al GridBagLayout total

libertad para decidir dónde y cómo ponerlo. No es lo que queremos.
Necesitamos el método add() que admite un segundo parámetro. Este
segundo parámetro le indica al layout dónde y cómo colocar el
componente. El segundo parámetro es un Object, lo que quiere decir que
podriamos meter cualquier cosa. Evidentemente esto no es asi, debemos
meter algo que el layout entienda. Cada layout entiende su propio segundo
parámetro. El GridBagLayout admite como segundo parámetro un
GridBagConstraints.

GridBagConstraints en una clase en cuyos atributos se guarda información

de cómo y dónde añadir el componente. De momento vamos a contemplar
sólo cuatro de estos atributos:

• GridBagConstraints.gridx nos dice la posición x del componente, es decir,

el número de columna en la que está el componente, siendo la columna 0
la primera columna de la izquierda. Si el componente ocupa varias
columnas (como nuestra área de texto), debemos indicar la columna en la
que está la esquina superior izquierda del componente.
• GridBagConstraints.gridy nos dice la posición y del componente, es
decir, el número de fila en la que está el componente, siendo la fila 0 la
primera fila de la parte de arriba. Si el componente ocupa varias filas
(como nuestra área de texto), debemos indicar la fila en la que está la
esquina superior izquierda del componente.
• GridBagConstraints.gridwidth nos dice cuántas celdas en horizontal debe
ocupar el componente. El ancho del componente.
• GridBagConstraints.gridheight nos dice cuantas celdas en vertical debe
ocupar el componente. El alto del componente.
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 71
______________________________________________________________________
Con esto podemos añadir nuestra área de texto

JTextArea areaTexto = new JTextArea ("Area texto");

GridBagConstraints constraints = new GridBagConstraints();
constraints.gridx = 0; // El área de texto empieza en la columna cero.
constraints.gridy = 0; // El área de texto empieza en la fila cero
constraints.gridwidth = 2; // El área de texto ocupa dos columnas.
constraints.gridheight = 2; // El área de texto ocupa 2 filas.
this.getContentPane().add (areaTexto, constraints);

En realidad gridwith y gridheight admite también determinadas constantes

que hacen que el componente se estire hasta el final del contenedor,
ocupando todas las columnas o filas libres o hasta que encuentre otro
componente.

Los siguientes elementos tienen todos un gridwidth y gridheight de 1,

puesto que ocupan una fila y columna. Las posiciones son las siguientes:

JButton boton1 = new JButton ("Boton 1");

constraints.gridx = 2;
constraints.gridy = 0;
constraints.gridwidth = 1;
constraints.gridheight = 1;
this.getContentPane().add (boton1, constraints);

JButton boton2 = new JButton ("Boton 2");

constraints.gridx = 2;
constraints.gridy = 1;
constraints.gridwidth = 1;
constraints.gridheight = 1;
this.getContentPane().add (boton2, constraints);

JButton boton3 = new JButton ("Boton 3");

constraints.gridx = 0;
constraints.gridy = 2;
constraints.gridwidth = 1;
constraints.gridheight = 1;
this.getContentPane().add (boton3, constraints);

JButton boton4 = new JButton ("Boton 4");

constraints.gridx = 2;
constraints.gridy = 2;
constraints.gridwidth = 1;
constraints.gridheight = 1;
this.getContentPane().add (boton4, constraints);
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 72
______________________________________________________________________

JTextField campoTexto = new JTextField ("Campo texto");

constraints.gridx = 1;
constraints.gridy = 2;
constraints.gridwidth = 1;
constraints.gridheight = 1;
this.getContentPane().add (campoTexto, constraints);

Hay un detalle importante a tener en cuenta. Sólo hemos hecho un new de

GridBagConstraints, por lo que todos ellos comparten la misma instancia
de ese objeto. Hay que tener en cuenta que si cambiamos uno de los
atributos para un componente, debemos restaurarlo luego para el siguiente.
Por ejemplo, para el area de texto pusimos gridwidth a 2. Para el siguiente
componente (el botón1), debemo volver a poner este valor a 1.

Por ello es acosejable poner siempre todos los atributos. Otra opción es
hacer un new GridBagConstraints para cada componente (claramente
menos eficiente) o finalmente la que he seguido en el código de ejemplo,
ser muy cuidadoso e ir restaurando valores según se van cambiando.

Si ejecutamos lo que tenemos hasta ahora y estiramos un poco la ventana

resultante nos sale lo de la siguiente figura:

Bueno, no se parece mucho a lo que queríamos. Se ha quedado todo en el

centro de la ventana y el area de texto es bastante pequeña. ¿Qué ha
pasado?

Estirar las filas y las columnas

Lo que ha pasado es que sólo le hemos dicho al GridBagLayout dónde

colocar los componentes y eso lo ha hecho bien. Cada componente está
donde debe. Lo que pasa es que no le hemos dicho nada de cómo estirar las
filas y columnas, así que ha hecho lo que hace por defecto: Cada fila y
columna es del tamaño mínimo necesario para albergar sus componentes y
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 73
______________________________________________________________________
están centradas dentro de la ventana. En la siguiente figura vemos como
están nuestras filas y columnas:

Las filas son de la altura justa para contener a los botones. Las columnas
también. El área de texto que ocupa cuatro celdas se ha situado en el medio
de ellas y le sobra un montón de espacio.

El siguiente paso a dar consiste en decir cómo se deben estirar las filas
columnas. Si comparamos con la figura en las que marcamos inicialmente
las filas y columnas, vemos que las dos primeras filas deben ser más
anchas, la tercera fila ya está bien de ancho. En cuanto a las columnas, la
segunda es la que debe estirarse, la primera y tercera están bien.

Para estirar filas y columnas, dentro del GridBagConstraints tenemos los

campos weigthx y weigthy. El primero indica cómo estirar las columnas. El
segundo las filas. Aqui vamos a contar una forma sencilla de usar estos
campos que nos servirá para la mayoría de los casos.

A estos campos debemos darles el valor 0.0 (que es el valor por defecto) si
no queremos que la fila o columna se estire. Este es el caso para la primera
y tercera columna, así como para la tercera fila. Debemos dar el valor 1.0 a
las filas o columnas que queremos que se estiren hasta completar toda la
ventana. Es el caso de las dos primeras filas y de la columna del medio.

Hay dos detalles con estos campos. El primero es que widthy afecta a una
fila completa, no solo a un componente. Por ello, cada vez que añadamos
un componente a esa fila, debemos dar a widthy el mismo valor (o 0.0 o
1.0). Lo mismo pasa con widthx y las columnas. El segundo detalle es el
que comentamos antes, sólo estamos usando una instancia de
GridBagConstraints, asi que después de poner uno de estos campos a 1.0 y
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 74
______________________________________________________________________
añadir un componente, debemos volver a ponerlo a 0.0 para el siguiente
(suponiendo que sea eso lo que necesita).

El código ahora, añadiendo estos dos campos, quedaría así:

JTextArea cajaTexto = new JTextArea("Area texto");

constraints.gridx = 0; // Columna 0. No necesita estirarse, no ponemos
weightx
constraints.gridy = 0; // Fila 0. Necesita estirarse, hay que poner weighty
constraints.gridwidth = 2;
constraints.gridheight = 2;
constraints.weighty = 1.0; // La fila 0 debe estirarse, le ponemos un 1.0
this.getContentPane().add (cajaTexto, constraints);
constraints.weighty = 0.0; // Restauramos al valor por defecto, para no
afectar a los siguientes componentes.

JButton boton1 = new JButton ("Boton 1");

constraints.gridx = 2; // Columna 2. No necesita estirarse, no ponemos
weightx
constraints.gridy = 0; // Fila 0. Necesita estirarse, hay que poner weighty
constraints.gridwidth = 1;
constraints.gridheight = 1;
constraints.weighty = 1.0; // La fila 0 debe estirarse, le ponemos un 1.0. Ya
lo hicimos en el area de texto,
// pero aquí debemos ser coherentes y poner lo mismo.
this.getContentPane().add (boton1, constraints);
constraints.weighty = 0.0; // Restauramos al valor por defecto, para no
afectar a los siguientes componentes.

JButton boton2 = new JButton ("Boton 2");

constraints.gridx = 2; // Columna 2, no necesita estirarse, no ponemos
weigthx
constraints.gridy = 1; // Fila 1, necesita estirarse, hay que poner weigthy
constraints.gridwidth = 1;
constraints.gridheight = 1;
constraints.weighty = 1.0; // La fila 1 debe estirarse, le ponemos 1.0
this.getContentPane().add (boton2, constraints);
constraints.weighty = 0.0; // Restauramos el valor por defecto.

JButton boton3 = new JButton ("Boton 3");

constraints.gridx = 0; // Columna 0, no necesita estirarse, no ponemos
weigthx
constraints.gridy = 2; // Fila 2, no necesita estirarse, no ponemos weigthy
constraints.gridwidth = 1;
constraints.gridheight = 1;
this.getContentPane().add (boton3, constraints);
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 75
______________________________________________________________________

JButton boton4 = new JButton ("Boton 4");

constraints.gridx = 2; // Columna 2, no necesita estirarse, no ponemos
weightx
constraints.gridy = 2; // Fila 2, no necesita estirarse, no ponemos weigthy
constraints.gridwidth = 1;
constraints.gridheight = 1;
this.getContentPane().add (boton4, constraints);

JTextField campoTexto = new JTextField ("Campo texto");

constraints.gridx = 1; // Columna 1, debe estirarse, le ponemos el weigthx
constraints.gridy = 2; // Fila 2, no necesita estirarse, no ponemos weigthy
constraints.gridwidth = 1;
constraints.gridheight = 1;
constraints.weightx = 1.0; // La columna 1 debe estirarse, ponemos el 1.0
en weigthx
this.getContentPane().add (campoTexto, constraints);
// Puesto que es el último componente, no restauramos el valor por defecto.
Si más adelante añadimos más
// componentes, seguro que pagamos cara nuestra osadía.

Bueno, vamos a ejecutar nuestro programa, estirar la ventana y a ver qué

sale. Sale lo de la siguiente figura, que tampoco es lo que queremos.

¿Qué es lo que ha pasado ahora?. Le hemos dicho que estire las filas y
columnas y es lo que ha hecho, pero como no le hemos dicho nada sobre
los componentes, no los ha estirado en absoluto.

Estirar los componentes

Si pintamos sobre la ventana las rayas que delimtan filas y columnas,

vemos que efectivamente se han ensanchado las que hemos dicho
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 76
______________________________________________________________________

pero los componentes siguen con su tamaño original y en el centro de las

celdas que tienen asignadas. El area de texto sigue igual, en el centro de sus
cuatro celdas, los botones 1 y 2 se han centrado en sus celdas y lo mismo le
pasa al campo de texto.

Lo siguiente que tenemos que hacer es decir qué componentes deben

estirarse (el area de texto y el campo de texto para nuestro ejemplo). Para
aquellos componentes que no deben estirarse, podemos indicar en qué parte
de la celda queremos que se situen (caso del boton 1 y boton 2).

Para hacer que un componente se estire, tenemos el atributo fill del

GridBagConstraints. Este puede tomar los siguientes valores:

• GridBagConstraints.NONE para que no se estire en ningún sentido, es la

opción por defecto.
• GridBagConstraints.VERTICAL para que se estire sólo en vertical
• GridBagConstraints.HORIZONTAL para que se estire sólo en
horizontal.
• GridBagConstraints.BOTH para que se estire en ambas dimensiones

Si el componente no se estira en alguna dirección, podemos decirle por

medio de anchor en GridBagConstraints qué posición queremos que
ocupe. Las posibilidades son

• GridBagConstraints.CENTER para que el componente ocupe el centro

de la celda. Es la opción por defecto
• GridBagConstraints.NORTH para que se pegue a la parte superior,
centrado en la misma.
• GridBagConstraints.NORTHEAST para que se pegue a la esquina
superior derecha.
• GridBagConstraints.WEST para que se pegue al lado izquierdo,
centrado en ese lado.
• GridBagConstraints.NORTHWEST para que se pegue a la esquina
superior izquierda.
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 77
______________________________________________________________________
Igual que antes, estamos usando una única instancia de
GridBagConstraints, por lo que si al añadir un componente cambiamos
una opción, debemos tenerlo en cuenta para el siguiente.

Bueno, pues básicamente nos queda decirle al area de texto de se ensanche

en todos los sentidos, al campo de texto que se ensanche en horizontal y a
los botones 1 y 2 que ocupen la posicion NORTH de su celda. El código
sería el siguiente:

JTextArea cajaTexto = new JTextArea("Area texto");

constraints.gridx = 0;
constraints.gridy = 0;
constraints.gridwidth = 2;
constraints.gridheight = 2;
// El area de texto debe estirarse en ambos sentidos. Ponemos el campo fill.
constraints.fill = GridBagConstraints.BOTH;
constraints.weighty = 1.0;
this.getContentPane().add (cajaTexto, constraints);
constraints.weighty = 0.0;

JButton boton1 = new JButton ("Boton 1");

constraints.gridx = 2;
constraints.gridy = 0;
constraints.gridwidth = 1;
constraints.gridheight = 1;
constraints.weighty = 1.0;
// El botón 1 debe ocupar la posición NORTH de su celda
constraints.anchor = GridBagConstraints.NORTH;
// El botón 1 no debe estirarse. Habíamos cambiado este valor en el
// area de texto, asi que lo restauramos.
constraints.fill = GridBagConstraints.NONE;
this.getContentPane().add (boton1, constraints);
// Restauramos valores por defecto
constraints.anchor = GridBagConstraints.CENTER;
constraints.weighty = 0.0;

JButton boton2 = new JButton ("Boton 2");

constraints.gridx = 2;
constraints.gridy = 1;
constraints.gridwidth = 1;
constraints.gridheight = 1;
constraints.weighty = 1.0;
// El boton 2 debe ocupar la posición NORTH de su celda.
constraints.anchor = GridBagConstraints.NORTH;
this.getContentPane().add (boton2, constraints);
// Restauramos valores por defecto.
constraints.weighty = 0.0;
constraints.anchor = GridBagConstraints.CENTER;
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 78
______________________________________________________________________

JButton boton3 = new JButton ("Boton 3");

constraints.gridx = 0;
constraints.gridy = 2;
constraints.gridwidth = 1;
constraints.gridheight = 1;
this.getContentPane().add (boton3, constraints);

JButton boton4 = new JButton ("Boton 4");

constraints.gridx = 2;
constraints.gridy = 2;
constraints.gridwidth = 1;
constraints.gridheight = 1;
this.getContentPane().add (boton4, constraints);

JTextField campoTexto = new JTextField ("Campo texto");

constraints.gridx = 1;
constraints.gridy = 2;
constraints.gridwidth = 1;
constraints.gridheight = 1;
constraints.weightx = 1.0;
// El campo de texto debe estirarse sólo en horizontal.
constraints.fill = GridBagConstraints.HORIZONTAL;
this.getContentPane().add (campoTexto, constraints);

Bueno, ejecutamos esto, estiramos la ventana, y Sale lo que queríamos al

principio.

Algunos comentarios finales

Los camos weightx y weighty, como hemos visto, hace que se estiren las
filas y columnas. Hemos puesto 0.0 para las que no se estiran y 1.0 para las
que sí. En realidad cada fila o columna se estira en proporción al valor de
este campo respecto a los demás. Por ejemplo, si a la columna 1 le
ponemos weightx=1.0 y a la 2 le ponemos weightx=0.5, ambas se estirarían
, pero la primera el doble que la segunda.

Hay campos insets, ipadx e ipady que permiten fijar márgenes entre los
componentes, de forma que no queden pegados entre sí.
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 79
______________________________________________________________________
3.5. Look And Feel

Cada ejecutable Java tiene un objeto UIManager que determina el Look-and-Feel,

es decir, la apariencia que se proporciona a los diferentes componentes: botones,
cajas de texto, cajas de selección, listas, etc., en pantalla y funcionamiento, que van
a tener estos componentes.

Java utiliza el interfaz gráfico de la plataforma sobre la que se está ejecutando para
presentar los Componentes del AWT con el aspecto asociado a esa plataforma, de
este modo los programas que se ejecuten en Windows tendran esa apariencia y los
que se ejecuten en Unix tendrán apariencia Motif.

Pero Swing permite la selección de esta apariencia gráfica, independientemente de

la plataforma en que se esté ejecutando; tanto es así que, la apariencia por defecto
de los Componentes Swing se denomina Metal, y es propia de Java. Teniendo
siempre en cuenta las restricciones impuestas por el control de seguridad, se puede
seleccionar la apariencia, o Look-and-Feel de los Componentes Swing invocando
al método setLookAndFeel() del objeto UIManager correspondiente al ejecutable.
La forma en que se consigue esto es porque cada objeto JComponent tiene un
objeto ComponentUI correspondiente que realiza todas las tareas de dibujo,
manejo de eventos, control de tamaño, etc. para ese JComponent.

Una de las ventajas que representan las capacidades de Look&Feel incorporadas a

Swing para las empresas, es el poder crear un interfaz gráfico estándar y
coporativo. Con el crecimiento de las intranets se están soportando muchas
aplicaciones propias que deben ejecutarse en varias plataformas, ya que lo más
normal es que en una empresa haya diferentes plataformas. Swing permite ahora
que las aplicaciones propias diseñadas para uso interno de la empresa tengan una
apariencia exactamente igual, independientemente de la plataforma en que se estén
ejecutando. Y es que hay pequeñas cosas que vuelven loco al usuario al cambiar de
entorno, por ejemplo:

• ¿Ratón de dos o tres botones?

• ¿Click simple o doble para activar aplicaciones?
• ¿La ventana activa sigue al foco o no lo sigue?
• Diferentes esquemas de color
• Diferentes aproximaciones para proporcionar accesibilidad
• Difernte conjunto de iconos, o widgets
• Diferente nomenclatura, geografía, efectos...

En la imagen se puede observar una revisión gráfica de los interfaces de usuario

más utilizados actualmente.
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 80
______________________________________________________________________

Java incorpora su propio Look&Feel por defecto, cuyo nombre es Metal, y que se
muestra a continuación.

3.5.1. Poner Look and Feel del sistema operativo

Normalmente las ventanas java tienen su propio aspecto, su propio estilo de

botones y demás. Con java es muy fácil cambiar el aspecto (look and feel o
skin) de nuestras ventanas para que tengan aspecto java, aspecto windows,
etc. Basta con tener la librería adecuada y una sola línea de código.

Para obtener el aspecto de ventanas propio del sistema operativo en el que

estemos (windows xp, solaris, etc), basta con estas líneas de código antes
de crear ninguna ventana:

import javax.swing.UIManager;
...
try
{
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 81
______________________________________________________________________

UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClass
Name());
}
catch (Exception e)
{
e.printStackTrace();
}

Con UIManager.getSystemLookAndFeelClassName() obtenemos el

nombre del Look and Feel por defecto del sistema operativo en el que
estemos. Con UIManager.setLookAndFeel decimos qué Look and Feel
queremos.

3.5.2. Cómo crear interfaces gráficas con Look And Feel en Java

Los componentes de Swing están escritos en Java, sin ningún código de

especificación de ventanas. Esto facilita la creación de interfaces gráficas
sin tomar en cuenta el sistema de graficación de ventanas donde se trabaje,
y simplificando el desarrollo de aplicaciones. Swing además soporta una
arquitectura de visualización (Look And Feel). Ésta característica dota a los
usuarios con la habilidad de cambiar la apariencia de una aplicación sin
reiniciarla y sin que el desarrollador se tenga que cambiar por completo su
conjunto de subclases.

Java Look And Feel (de ahora en adelante J&F) es un API multiplataforma
proporcionada por JavaSoft. .Java L&F implementa todas las
funcionalidades básicas de Swing, pero tambén se extiende en otras áreas
incluyendo:

o Temas
o Sliders (barras de selección de rangos)
o Toolbars (Barras de herramientas)
o Trees (arboles de contenido)

Creando un JFrame con el Look And Feel activado

Esto es muy sencillo de hacer. Lo único que tenemos que hacer es activar el
Look And Feel, pasando true como parámetro al método estático
setDefaultLookAndFeelDecorated de JFrame y de JDialog. Por ej.:

import javax.swing.*;
import java.awt.event.*;
import java.awt.*;

public class Ejemplo1Look extends JFrame

{
public Ejemplo1Look()
{
super("Ejemplo 1");
JButton boton = new JButton("Mostrar dialogo");
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 82
______________________________________________________________________

boton.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent e){
JOptionPane.showMessageDialog(null,
"Y así se ve un cuadro de dialogo de error",
"Mensaje",JOptionPane.ERROR_MESSAGE);
}
}
);
getContentPane().add(new JLabel("Asi se ve un Frame"),
BorderLayout.NORTH);
getContentPane().add(boton);
setSize(200,80);
setVisible(true);
}
public static void main(String args[])
{
JFrame.setDefaultLookAndFeelDecorated(true);
JDialog.setDefaultLookAndFeelDecorated(true);
Ejemplo1Look ventana = new Ejemplo1Look();
ventana.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}

Este programa tiene la siguiente salida:

Universidad Nacional de Piura – Jorge L.Sandoval Rivera 83
______________________________________________________________________

3.4. MANEJO DE EVENTOS

Para la captura de eventos Swing usa clases, cada clase de captura de eventos
(event listeners) debe implementar una interfaz concreta en función del tipo de
eventos que desea capturar Una vez implementado el listener, bastará con indicar
éste al componente del cual deseamos capturar los eventos

3.4.1. Elementos del modelo de eventos

Los elementos son los siguientes:

a) Clase del evento

Cuando se produce un evento dicho evento es representado como un
objeto de una clase que desciende de EventObject. Los eventos están
organizados en jerarquías de clases de eventos

java.lang.Object

java.util.EventObject

awt.event

ActionEvent AdjustmentEvent ComponentEvent ItemEvent TextEvent

ContainerEvent FocusEvent InputEvent WindowEvent

KeyEvent MouseEvent

b) Fuentes de Eventos (event sources)

Las fuentes de eventos (event sources) son objetos que detectan eventos
y notifican a los receptores que se han producido dichos eventos
Ejemplos de fuentes:
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 84
______________________________________________________________________

• Botón sobre el que se pulsa

• Campo de texto que pierde el foco
• Campo de texto sobre el que se presiona una tecla
• Ventana que se cierra
• Etc.

c) Receptores de Eventos (event listener)

Son objetos instanciados de una clase que implementa un interface
específico, denominado interface listener.

Cuando ocurre un evento el objeto fuente necesita llamar a un objeto

receptor
Existen ciertos objetos receptores (event Listeners) que son comunes a
todos los componentes:

.-FocusListener: captura eventos relacionados con la recepción o pérdida

del foco
.-KeyListener: captura pulsaciones de teclado sobre el componente activo
.-MouseListener: captura la entrada o salida del cursor sobre un
componente, así como pulsaciones de los botones
.-MouseMotionListener: captura movimientos del ratón sobre el
componente.

Otros son específicos de algunos componentes:

ActionListener: captura cierto tipo de acción realizada sobre ciertos

componentes. Por ejemplo, pulsar un botón, seleccionar un elemento en
una lista desplegable o una opción en un menú

ChangeListener: registra los cambios sobre ciertos componentes. Por

ejemplo un cambio en el dato de un spinner, o un nuevo valor
seleccionado en un slider

ItemListener: recoge el cambio de estado en un componente tipo on/off:

check boxes, radio buttons y listas desplegables

ListSelectionListener: es un listener específico para detectar las

selecciones múltiples realizadas en listas y tablas

WindowListener: permite recoger los eventos relacionados con las

ventanas (cerrar, minimizar, maximizar, iconizar, etc.) en los frames,
frames internos y cuadros de diálogo.

Si la interfaz captura un único tipo de evento, como ActionListener,

normalmente tendrá una única operación a implementar
void actionPerformed (ActionEvent e)
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 85
______________________________________________________________________

En cambio los listeners más complejos como FocusListener requieren la

implementación de varias operaciones, cada una para un tipo de evento
concreto
void focusGained (FocusEvent e)
void focusLost (FocusEvent e)

d) Registro e implementación de un Listener

Cuando ya disponemos del objeto fuente y del objeto receptor es

necesario asociarlos, es decir, hay que registrar el objeto receptor de
eventos con el objeto fuente de los mismos:
objetoFuenteEventos.add_Tipo_Listener (Tipo_Listener L)

Hay dos formas básicas de implementar un Listener:

• Hacer que el JFrame que genera o contiene el componente generador

del evento sea un listener, haciendo que implemente la interfaz
correspondiente (lo más simple y eficiente)
• Implementar una pequeña clase interior que haga de listener (lo más
flexible)

e) Adaptadores

Para las interfaces con más de una operación Swing proporciona por
comodidad una clase adaptadora (adapter classes), que tienen como
objetivo evitar la tediosa tarea de tener que implementar todos los
métodos de las interfaces listener.

Por ello existe una clase adaptadora por cada interface listener que tiene
más de un método: MouseAdapter, WindowAdapter, KeyAdapter,
MouseMotionAdapter, FocusAdapter, ContainerAdapter y
ComponentAdapter,
etc.
La clase adaptadora correspondiente se obtiene sustituyendo “Listener”
por “Adapter”

Ejemplo: WindowListener -> WindowAdapter

Universidad Nacional de Piura – Jorge L.Sandoval Rivera 86
______________________________________________________________________

CAPITULO IV APPLETS

4.1. INTRODUCCION
Un applet está formado por una clase o conjunto de clases escritas en java que está
insertado en una pagina Web.
Cuando un usuario carga la página en la que esta el applet, éste se ejecuta localmente (en
la maquina cliente donde se esta ejecutando el navegador Web.) y no remotamente (sobre
el sistema que está ejecutando el servidor HTTP).

El hecho de que el código se ejecute localmente implica que la seguridad sea crucial, los
applets están sometidos a restricciones de seguridad por defecto. Por ejemplo nadie desea
que un applet cargado visitando una página Web borre sus archivos. O que ese applet
realice conexiones a otras máquinas para transferir información.
Estas están impuestas por un objeto del tipo SecurityManager en el sistema cliente que
especifica que acciones están permitidas y cuales no.

A partir de la versión 1.1. de la plataforma java, las clases se pueden firmar digitalmente,
estas clases pueden realizar acciones no permitidas a las clases no firmadas.

Por defecto, el gestor de seguridad de los navegadores verifica entre otras cosas que los
applets:
• No puedan leer los archivos locales
• No puedan escribir en los discos locales
• No puedan establecer conexioes a otras máquinas salvo con el servidor que
contiene el applet
• No ejecutar programas locales
• No puedan obtener información privada sobre el usuario.

Los applets deben ser subclases de la clase Applet o de JApplet, la ejecución de un

applet no comienza en el método main, existiendo una serie de métodos que son
invocados cuando ocurren determinadas circustancias, debiendo sobrescribirlo de
acuerdo a la necesidad del applet.
Universidad Nacional de Piura – Jorge L.Sandoval Rivera 87
______________________________________________________________________

Hay que
init( ) start() redibujar el
applet

Se carga la paint()
página que
contiene el
applet

Se cierra el stop() destroy()

navegador
o se cambia
de página

Jerarquia de la clase Applet y JApplet