AWT y Swing

En el paquete estándar de Java, contamos con tres opciones para crear interfaces gráficas de usuario:
• AWT -Abstract Window Toolkit: es una biblioteca pesada -heavy weight
• Swing: es una biblioteca ligera -light weight-de componentes.
• JavaFX: Swing JavaFX permite crear intefaces gráficas de usuario tanto para aplicaciones de
escritorio como para la web y dispositivos móviles.

La idea de pesada o ligera, en este caso, está relacionada con la dependencia de Java con el sistema
operativo, para visualizar y gestionar los elementos de la interface gráfica de usuario.
En el caso de AWT, la creación, visualización y gestión de los elementos gráficos depende del SO. Es el
propio SO quien dibuja y gestiona la interacción sobre los elementos.
En el caso de Swing, es Java quien visualiza y gestiona la interacción del usuario sobre los elementos de
la interface gráfica por lo que la forma en que se visualiza es similar en cualquier sistema operativo

Qué es Swing
El paquete swing de Java incluye una serie de componentes gráficos clasificados en contenedores de alto
nivel, intermedios y componentes específicos.
Dicho de otra forma es una biblioteca de clases que permite crear interfaces gráficas de usuario en Java.
Swing forma parte del paquete estándar, no hace falta importar ningún fichero adicional en nuestros
proyectos.
Swing no es la única alternativa para crear interfaces gráficas de usuario en Java, SWT -Standard Widget
Toolkit- es una biblioteca, desarrollada por IBM, con la que también podemos crear interfaces gráficas de
usuario.
Eclipse utiliza SWT para construir su interfaz gráfica.
JavaFX es la apuesta actual de Oracle la comunidad de código abierto en Java para construir interfaces
gráficas de usuario multi-dispositivo.
La tendencia actual en la construcción de interfaces gráficas de usuario es mantener la misma calidad, y
riqueza de componentes, tanto si el cliente es de escritorio, como un navegador, un dispositivo móvil, la
televisión, etcétera.
Swing está orientado a objetos, y usa el patrón de diseño Observador/Observable para informar de las
interacciones del usuario sobre la interface gráfica de usuario.
Los programas swing deben importar los paquetes: javax.swing.* y AWT: java.awt.* y java.awt.event.*.

Contenedores y componentes
Existen dos elementos básicos para la creación de interfaces gráficas de usuario usando Swing:
• Contenedores: Elementos capaces de albergar otros elementos. Estos se subdividen en :
o Contenedores de alto nivel: representan las ventanas de la interfaz gráfica de
usuario. Estos tienen contenedores intermedios. Estos son:
▪ JFrame: Se visualiza como una ventana principal con marco y barra de título.
▪ JDialog: Se visualiza como una ventana independiente de la
ventana principal para mostrar información, como por ejemplo el contenido de
un directorio.
▪ JApplet: Permite crear aplicaciones con interface gráfica que se ejecutan en el
contexto de un navegador web.

o Contenedores intermedios: agrupan componentes de acuerdo con algún criterio

lógico (clase JPanel y clase JScrollPane). A su vez, los contenedores intermedios
contienen componentes.
 • Componentes: Elementos que se añaden a contenedores. Usualmente los componentes tienen
aspecto gráfico, como un botón.

Los pasos básicos para la construcción de una interfaz gráfica de usuario son
1. Crear una nueva clase para una ventana (o directamente instanciar un objeto JFrame).
2. Crear los componentes de la interfaz gráfica de usuario.
3. Crear uno o varios contenedores intermedios.
4. Asociar los componentes al contenedor.
5. Asociar el contenedor a la ventana.
6. Hacer visible la ventana.

Ejemplo:
un programa con una interfaz gráfica de usuario que genere una ventana para solicitar los datos de una
persona: nombre, apellidos, dirección y teléfono, todos de tipo String.

Clase: VentanaPrincipal
package Personas;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.*;
/**
* Esta clase denominada VentanaPrincipal define una interfaz gráfica
* que permitirá crear una persona y agregarla a un vector de personas.
* Luego, se puede eliminar una persona seleccionada o borrar todas las
* personas.
*/
public class VentanaPrincipal extends JFrame implements
ActionListener {
private ListaPersonas lista; // El objeto ListaPersonas de la aplicación
private Container contenedor; /* Un contenedor de elementos gráficos */
// Etiquetas estáticas para los nombres de los atributos
private JLabel nombre, apellidos, teléfono, dirección;
// Campos de ingreso de texto
private JTextField campoNombre, campoApellidos, campoTeléfono,
campoDirección;
private JButton añadir, eliminar, borrarLista; // Botones
private JList listaNombres; // Lista de personas
private DefaultListModel modelo; // Objeto que modela la lista
private JScrollPane scrollLista; // Barra de desplazamiento vertical
/**
* Constructor de la clase VentanaPrincipal
*/
public VentanaPrincipal(){
lista = new ListaPersonas(); // Crea la lista de personas
inicio();
setTitle(“Personas”); // Establece el título de la ventana
setSize(270,350); // Establece el tamaño de la ventana
setLocationRelativeTo(null); /* La ventana se posiciona en el
centro de la pantalla */
// Establece que el botón de cerrar permitirá salir de la aplicación
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setResizable(false); /* Establece que el tamaño de la ventana no se puede cambiar */
}
/**
* Método que crea la ventana con sus diferentes componentes
* gráficos
*/
private void inicio() {
contenedor = getContentPane(); /* Obtiene el panel de contenidos de la ventana */
contenedor.setLayout(null); /* Establece que el panel no tiene asociado ningún layout */
// Establece la etiqueta y el campo nombre
nombre = new JLabel();
nombre.setText(“Nombre:”);
nombre.setBounds(20, 20, 135, 23); /* Establece la posición de la etiqueta nombre */
campoNombre = new JTextField();
// Establece la posición del campo de texto nombre
campoNombre.setBounds(105, 20, 135, 23);
// Establece la etiqueta y el campo apellidos
apellidos = new JLabel();
apellidos.setText(“Apellidos:”); /* Establece la posición de la etiqueta apellidos */
apellidos.setBounds(20, 50, 135, 23);
campoApellidos = new JTextField();
// Establece la posición del campo de texto apellidos
campoApellidos.setBounds(105, 50, 135, 23);
// Establece la etiqueta y el campo teléfono
teléfono = new JLabel();
teléfono.setText(“Teléfono:”);
teléfono.setBounds(20, 80, 135, 23); /* Establece la posición de la etiqueta teléfono */
campoTeléfono = new JTextField();
// Establece la posición del campo de texto teléfono
campoTeléfono.setBounds(105, 80, 135, 23);
// Establece la etiqueta y el campo dirección
dirección = new JLabel();
dirección.setText(“Dirección:”);
dirección.setBounds(20, 110, 135, 23); /* Establece la posición de la etiqueta dirección */
campoDirección = new JTextField();
// Establece la posición del campo de texto dirección
campoDirección.setBounds(105, 110, 135, 23);
// Establece el botón Añadir persona
añadir = new JButton();
 añadir.setText(«Añadir»);
añadir.setBounds(105, 150, 80, 23); /* Establece la posición del botón Añadir persona */
/* Agrega al botón un ActionListener para que gestione eventos del botón */
añadir.addActionListener(this);
// Establece el botón Eliminar persona
eliminar= new JButton();
eliminar.setText(“Eliminar”);
eliminar.setBounds(20, 280, 80, 23); /* Establece la posición del botón Eliminar persona */
/* Agrega al botón un ActionListener para que gestione eventos del botón */
eliminar.addActionListener(this);
// Establece el botón Borrar lista
borrarLista= new JButton();
borrarLista.setText(“Borrar Lista”);
borrarLista.setBounds(120, 280, 120, 23); /* Establece la posición del botón Borrar lista */
/* Agrega al botón un ActionListener para que gestione eventos del botón */
borrarLista.addActionListener(this);
// Establece la lista gráfica de personas
listaNombres = new JList();
/* Establece que se pueda seleccionar solamente un elemento de la lista */
listaNombres.setSelectionMode(ListSelectionModel.SINGLE_
SELECTION);
modelo = new DefaultListModel();
// Establece una barra de desplazamiento vertical
scrollLista = new JScrollPane();
// Establece la posición de la barra de desplazamiento vertical
scrollLista.setBounds(20, 190 ,220, 80);
// Asocia la barra de desplazamiento vertical a la lista de personas
scrollLista.setViewportView(listaNombres);
// Se añade cada componente gráfico al contenedor de la ventana
contenedor.add(nombre);
contenedor.add(campoNombre);
contenedor.add(apellidos);
contenedor.add(campoApellidos);
contenedor.add(teléfono);
contenedor.add(campoTeléfono);
contenedor.add(dirección);
contenedor.add(campoDirección);
contenedor.add(añadir);
contenedor.add(eliminar);
contenedor.add(borrarLista);
contenedor.add(scrollLista);
}
/**
* Método que gestiona los eventos generados en la ventana principal
*/
@Override
public void actionPerformed(ActionEvent evento) {
if (evento.getSource() == añadir) { // Si se pulsa el botón añadir
 añadirPersona(); // Se invoca añadir persona
}
if (evento.getSource() == eliminar) { /* Si se pulsa el botón eliminar */
/* Se invoca el método eliminarNombre que elimina el elemento seleccionado */
eliminarNombre(listaNombres.getSelectedIndex() );
}
if (evento.getSource() == borrarLista) { /* Si se pulsa el botón borrar lista */
borrarLista(); // Se invoca borrar lista
}
}
/**
* Método que agrega una persona al vector de personas y a la lista
* gráfica de personas
*/
private void añadirPersona() {
/* Se obtienen los campos de texto ingresados y se crea una persona */
Persona p = new Persona(campoNombre.getText(),
campoApellidos.getText(),
campoTeléfono.getText(), campoDirección.getText());
lista.añadirPersona(p); /* Se añade una persona al vector de personas */
String elemento = campoNombre.getText() + “-” +
campoApellidos.getText() +
“-” + campoTeléfono.getText() + “-” + campoDirección.
getText();
modelo.addElement(elemento); /* Se agrega el texto con los datos de la persona al JList */
listaNombres.setModel(modelo);
// Se colocan todos los campos de texto nulos
campoNombre.setText(“”);
campoApellidos.setText(“”);
campoTeléfono.setText(“”);
campoDirección.setText(“”);
}
/**
* Método que elimina una persona del vector de personas y de la
* lista gráfica de personas en la ventana
* @param indice Parámetro que define la posición de la persona a
* eliminar
*/

private void eliminarNombre(int indice) {

if (indice >= 0) { // Si la posición existe
modelo.removeElementAt(indice); /* Se elimina la persona seleccionada de la lista
gráfica */
lista.eliminarPersona(indice); /* Se elimina la persona
seleccionada del vector de personas */
} else { /* Si no se seleccionó ninguna persona, se genera un mensaje de error */
JOptionPane.showMessageDialog(null, “Debe seleccionar un elemento”,”Error”,
JOptionPane.ERROR_MESSAGE);
 }
}
/**
* Método que elimina todas las personas del vector de personas
*/
private void borrarLista() {
lista.borrarLista(); // Se eliminan todas las personas del vector
modelo.clear(); // Limpia el JList, la lista gráfica de personas
}
}

Clase: ListaPersonas
package Personas;
import java.util.*;
/**
* Esta clase denominada ListaPersonas define un vector de Personas.
*/
public class ListaPersonas {
Vector listaPersonas; // Atributo que identifica un vector de personas
/**
* Constructor de la clase ListaPersonas
*/
public ListaPersonas() {
listaPersonas = new Vector(); // Crea el vector de personas
}
/**
* Método que permite agregar una persona al vector de personas
* @param p Parámetro que define la persona a agregar al vector de
* personas
*/
public void añadirPersona(Persona p) {
listaPersonas.add(p);
}
/**
* Método que permite eliminar una persona del vector de personas
* @param i Parámetro que define la posición a eliminar en el vector
* de personas
*/
public void eliminarPersona(int i) {
listaPersonas.removeElementAt(i);
}
/**
* Método que permite eliminar todos los elementos del vector de
* personas
*/
public void borrarLista() {
listaPersonas.removeAllElements();
}
}

Clase: Persona
package Personas;
/**
* Esta clase denominada Persona modela una persona que cuenta con
* los atributos: nombre, apellidos, teléfono y dirección.
*/
public class Persona {
String nombre; // Atributo que identifica el nombre de una persona
String apellidos; /* Atributo que identifica los apellidos de una
persona */
String teléfono; // Atributo que identifica el teléfono de una persona
String dirección; /* Atributo que identifica la dirección de una
persona */
/**
* Constructor de la clase Persona
* @param nombre Parámetro que define el nombre de una persona
* @param apellidos Parámetro que define los apellidos de una
* persona
* @param teléfono Parámetro que define el teléfono de una persona
* @param dirección Parámetro que define la dirección de una
* persona
*/
public Persona(String nombre, String apellidos, String teléfono, String dirección) {
this.nombre = nombre;
this.apellidos = apellidos;
this.teléfono = teléfono;
this.dirección = dirección;
}
}

Clase: Principal
package Personas;
/**
* Esta clase define el punto de ingreso al programa de gestión de
* personas.
* Por lo tanto, cuenta con un método main de acceso al programa.
*/
public class Principal {
/**
* Método main que sirve de punto de entrada al programa
*/
public static void main(String[] args) {
VentanaPrincipal miVentanaPrincipal; /* Define la ventana principal */
miVentanaPrincipal= new VentanaPrincipal(); /* Crea la ventana principal */
miVentanaPrincipal.setVisible(true); /* Establece la ventana como visible */
}
}