GUIA 4

Facultad: Ingeniería
Uso de Swing básico.
Escuela: Computación
Asignatura: Java.

I.OBJETIVOS

Que el estudiante aplique los conceptos teóricos de Swing.

Que el estudiante pueda identificar las instrucciones del Swing en NetBeans IDE
6.1.

II. INTRODUCCIÓN TEÓRICA

Introducción a Swing:
Swing es una biblioteca gráfica para Java que forma parte de las Java Foundation
Classes (JFC). Incluye widgets para interfaz gráfica de usuario tales como cajas de texto,
botones, desplegables y tablas.

Historia
La Internet Foundation Classes (IFC) era una biblioteca gráfica para el lenguaje de
programación Java desarrollada originalmente por Netscape y que se publicó en 1996.

Desde sus inicios el entorno Java ya contaba con una biblioteca de componentes gráficos
conocida como AWT. Esta biblioteca estaba concebida como una API estandarizada que
permitía utilizar los componentes nativos de cada sistema operativo.

Ventajas:
* El diseño en Java puro posee menos limitaciones de plataforma.
* El desarrollo de componentes Swing es más activo.
* Los componentes de Swing soportan más características.

Desventajas:
* La mayoría de los browsers no incluyen clases swing, por lo que es necesario utilizar
un plugin java.

GUÍA 4 pág. 1
 * Los componentes swing generalmente son más lentos y presentan más
problemas debido a que están hechos en Java puro, y suelen presentar problemas
relacionados con vídeo en varias plataformas.
* No siempre tienen el mismo aspecto que en el sistema donde fueron diseñados.

III. PROCEDIMIENTO

Ejemplo 1:

Nombre de la Clase: HolaMundoSwing.java

Creación y visualizar una ventana

La ventana principal de la aplicación debe ser JFrame. El siguiente código crea un

JFrame, lo cual agrega dentro una etiqueta JLabel que pone "Hola mundo" y lo muestra
en pantalla.

GUÍA 4 pág. 2
Ejemplo 2:

Nombre de la Clase: PruebaMarcoSencillo.java

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

public class HolaMundoSwing {

/** Creates a new instance of HolaMundoSwing */
public HolaMundoSwing() {
}
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
JFrame frame = new JFrame("HolaMundoSwing");// Se crea el JFramen.
JLabel label = new JLabel("Hola Mundo");// Se crea el JLabel.
frame.getContentPane().add(label);//se introduce el label al frame

// Para que termine la aplicación al pulsar la x de arriba a la derecha.

frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.pack();// Se hace que JFrame tenga el tamaño justo para que quepa el
JLabel
frame.setVisible(true);// Se visualiza.

}
}

Creación de un marco.

Las ventanas de nivel superior (esto es, las que no están dentro de otra ventana) reciben
el nombre de Marco en Java. La biblioteca AWT posee una clase llamada Frame que
sirve para este tipo de ventana. La versión de Swing de esta clase se denomina JFrame y
extiende (hereda) a la clase Frame.

GUÍA 4 pág. 3
 import javax.swing.JFrame;
/**
*
* @author Santiago José Campos Robles.
*/
public class PruebaMarcoSencillo
{
/** Creates a new instance of PruebaMarcoSencillo */
public PruebaMarcoSencillo() {
}
/**
* @param args the command line arguments
*/
public static void main(String[] args)
{
// TODO code application logic here
MarcoSencillo marco = new MarcoSencillo();
marco.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
marco.setVisible(true);
}
}
class MarcoSencillo extends JFrame
{
public MarcoSencillo()
{
setSize(ANCHURA_PREFIJADA, ALTURA_PREFIJADA);
}

public static final int ANCHURA_PREFIJADA=300;

public static final int ALTURA_PREFIJADA=200;
}

Vamos a revisar este programa línea por línea.

Las clases de Swing se encuentran en el paquete Javax.swing. El nombre del paquete,
javax, indica que se trata de un paquete de extensión de Java, y no de un paquete de
base. Las clases de Swing son, ciertamente una extensión de java 1.1. Pero en Java 2, el
paquete Swing ya no es una extensión, sino que forma parte de la jerarquía básica.

De forma predeterminada, los marcos tienen un tamaño más bien inútil de 0x0 píxeles.
Nosotros definimos la subclase MarcoSencillo cuyo constructor especifica un tamaño de
300x200 píxeles. En el método main de la clase PruebaMarcoSencillo, empezamos por
construir un objeto de tipo MarcoSencillo.

GUÍA 4 pág. 4
 A continuación, definimos lo que debe ocurrir cuando el usuario cierra este
marco. Para este programa en particular, deseamos que el programa concluya. Para
seleccionar este comportamiento, empleamos la sentencia:

Marco.SetDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

En otros programas con múltiples marcos no desearíamos que el programa concluyera

solo porque el usuario cierre uno de los marcos. De forma predeterminada, el marco se
oculta cuando el usuario lo cierra, pero el programa no concluye.
No basta construir un marco para que se visualice automáticamente. Los marcos nacen
invisibles. Esto da al programador la posibilidad de añadir componentes al marco antes de
mostrarlo por primera vez. Para mostrar al marco, el método main llama al método
setVisible del marco.
A partir de JDK 1.4, se pueden desactivar todos los adornos del marco llamado a
marco.setUndecorated(true);

Ejemplo 3:

Nombre de la Clase: PruebaMarcoCentrado.java

La clase JFrame en si posee únicamente unos pocos métodos para modificar el aspecto
que tiene los marcos. Por supuesto, mediante la magia de la herencia, la mayoría de los
métodos que sirva para trabajar con el tamaño y posición del marco provienen de las
distintas superclases de JFrame. Entre los métodos más importantes cabe mencionar los
que siguen:
• El método dispose que cierra la ventana y recupera los posibles recursos del
sistema empleados para crearla.
• El método setIconImage, que admite un objeto de tipo Image y lo utiliza como
icono cuando se minimiza la ventana.
• El método setTitle que sirve para cambiar el texto que aparece en la barra de
título.
• El método setResizable, que admite un bolean y determina si el usuario va a
poder o no cambiar el tamaño del marco.

GUÍA 4 pág. 5
 import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class PruebaMarcoCentrado {
/** Creates a new instance of PruebaMarcoCentrado */
public PruebaMarcoCentrado() {
}
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
MarcoCentrado marco = new MarcoCentrado();
marco.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//marco.setExtendedState(Frame.MAXIMIZED_BOTH);
marco.setVisible(true);
}
}
class MarcoCentrado extends JFrame
{
public MarcoCentrado()
{
Toolkit Kit = Toolkit.getDefaultToolkit();
Dimension tamanoPantalla = Kit.getScreenSize();
int alturaPantalla = tamanoPantalla.height;
int anchuraPantalla = tamanoPantalla.width;

setSize(anchuraPantalla/2, alturaPantalla/2);
setLocation(anchuraPantalla/4, alturaPantalla/4);

Image img = Kit.getImage("uvas.jpg");

setIconImage(img);
setTitle("Marco Centrado");
}
}

Explicación del código más relevante:

Para averiguar el tamaño de la pantalla, se ha llamado al método estático getDefaulToolkit
de la clase Toolkit para obtener el objeto Toolkit. A continuación, llama al método
getScreenSize, que proporciona el tamaño de la pantalla en la forma de un objeto de tipo
Dimension. Los objetos Dimension contiene simultáneamente una anchura y una altura.

Nota: Pruebe agregando el siguiente código:

Marco.setExtendedState(Frame.MAXIMIZED_BOTH);

GUÍA 4 pág. 6
 MANEJO DE EVENTOS:

El manejo de eventos es de vital importancia capital para los programas que posee una
interfaz de usuario gráfica. Para implementar las interfaces de usuario, es preciso dominar
la forma en que Java maneja los eventos.

Bases del manejo de eventos

Todo entorno operativo que admite GUI monitoriza constantemente los eventos tales
como teclas pulsadas o clic de ratón. El entorno operativo notifica estos eventos a los
programas que están en ejecución. Entonces cada programa decide lo que debe hacer, si
procede, como respuesta a estos eventos.

Dentro de los límites de los eventos que resultan conocidas para AWT, tenemos un
completo control de la forma en que se transmiten los eventos desde las fuentes de
eventos (como los botones o las barras de desplazamiento) hasta los oyentes de eventos.
Cualquier objeto puede ser nombrado oyente de eventos; en la práctica, seleccionaremos
un objeto que puede llevar a cabo de forma cómoda la respuesta deseada para ese
evento.

En resumen, véase un esquema general de la forma en que funciona el manejo de

eventos en AWT.
• Un objeto oyente es un ejemplar de una clase que implementa una interfaz
denominada una interfaz de oyente.
• Una fuente de eventos es un objeto en que se pueden registrar objetos oyentes y
enviar a esos objetos otros objetos de eventos.
• La fuente de eventos envía objetos de eventos a todos los oyentes registrados en
ella cuando se produce un evento.
• Los objetos oyentes utilizarán entonces la información contenida en el objeto de
evento para determinar su reacción frente al evento.
Para registrar un objeto oyente en el objeto fuente se emplean unas líneas de código cuyo
modelo es similar al siguiente:
objetoFuentedeEventos.addEvenListener(objetoOyentedeEventos)

Véase un ejemplo:

ActionListener oyente =…;

JButton boton = new JButton(“OK”);
boton.addActionListener(oyente);

ahora el objeto oyente recibe una notificación siempre que se produce un “evento de
acción” en el botón. Para los botones, como cabe esperar, un evento de acción es un clic
en el botón.
Ejemplo 4:

GUÍA 4 pág. 7
Nombre de la Clase: PruebaBoxLayout.java

import java.awt.Component;
import javax.swing.BoxLayout;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.WindowConstants;

public class PruebaBoxLayout

{
/** Creates a new instance of PruebaBoxLayout */
public PruebaBoxLayout()
{
}
/**
* @param args the command line arguments
*/
public static void main(String[] args)
{
// TODO code application logic here
JFrame v = new JFrame("Ejemplo Utilizando BoxLayout");
v.getContentPane().setLayout(new
BoxLayout(v.getContentPane(),BoxLayout.Y_AXIS));
// Se crea un botón centrado y se añade
JButton boton = new JButton("Bienvenidos a NetBeans IDE 6.1");
boton.setAlignmentX(Component.CENTER_ALIGNMENT);
v.getContentPane().add(boton);
// Se crea una etiqueta centrada y se añade
JLabel etiqueta = new JLabel("El Segundo Examen es de Interfaz
Gráfica.!!!!!");
etiqueta.setAlignmentX(Component.CENTER_ALIGNMENT);
v.getContentPane().add(etiqueta);
v.pack();
v.setVisible(true);// Visualizar la ventana

v.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
}
}

GUÍA 4 pág. 8
GUÍA 4 pág. 9