Introducción a Swing

¿Qué es Swing?

Swing es una biblioteca de Java para crear interfaces gráficas de usuario (GUI) multiplataforma. Forma parte del Java Foundation Classes (JFC) y proporciona un conjunto de componentes ligeros que permiten crear aplicaciones de escritorio robustas y visualmente atractivas.

Historia y Contexto

Swing fue introducido en 1997 como parte de la Java Foundation Classes.
Fue diseñado para superar las limitaciones de AWT (Abstract Window Toolkit), su predecesor.
A diferencia de AWT, que utilizaba componentes nativos del sistema operativo, Swing está completamente escrito en Java.

Características Principales de Swing

Multiplataforma: Las aplicaciones Swing se ven y se comportan de manera similar en diferentes sistemas operativos.
Personalizable: Ofrece un alto grado de personalización en la apariencia y el comportamiento de los componentes.
Ligero: Los componentes Swing son renderizados por Java, no por el sistema operativo.
Rica en características: Proporciona una amplia gama de componentes avanzados como tablas, árboles, y pestañas.

Arquitectura de Swing

Swing se basa en una arquitectura en capas:

Capa de Componentes:
- Los elementos visibles de la interfaz (JButton, JTextField, etc.).
- Cada componente es responsable de su propio renderizado.
Capa de UI Delegate:
- Maneja la apariencia y el comportamiento de los componentes.
- Permite cambiar el Look and Feel sin modificar el código de la aplicación.
Capa de Look and Feel:
- Define el aspecto visual general de la aplicación.
- Swing viene con varios Look and Feels predefinidos (Metal, Nimbus, System, etc.).

Configuración para Desarrollo Swing

Para comenzar a desarrollar aplicaciones Swing, solamente necesitamos tener JDK (Java Development Kit) instalado en nuestro sistema y un IDE (Entorno de Desarrollo Integrado). Esto ya configuramos en la primera sección.

`Hola Mundo` en Swing

Vamos a crear nuestra primera aplicación Swing: un simple “Hola Mundo”.

Código

1
import javax.swing.*;
2

3
public class HolaMundoSwing {
4
    public static void main(String[] args) {
5
        // Aseguramos que la GUI se cree en el Event Dispatch Thread
6
        SwingUtilities.invokeLater(new Runnable() {
7
            public void run() {
8
                crearYMostrarGUI();
9
            }
10
        });
11
    }
12

13
    private static void crearYMostrarGUI() {
14
        // Crear el frame principal
15
        JFrame frame = new JFrame("Hola Mundo Swing");
16
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
17

18
        // Crear una etiqueta
19
        JLabel label = new JLabel("¡Hola, Mundo!");
20
        frame.getContentPane().add(label);
21

22
        // Ajustar el tamaño y hacer visible
23
        frame.setSize(300, 200);
24
        frame.setVisible(true);
25
    }
26
}

Detalles del Código

Importación:
```
1
import javax.swing.*;
```
Importamos las clases necesarias de Swing. Lo recomendable es importar solo las clases que necesitamos para evitar conflictos de nombres.
Método main:
```
1
SwingUtilities.invokeLater(new Runnable() {
2
    public void run() {
3
        crearYMostrarGUI();
4
    }
5
});
```
Utilizamos SwingUtilities.invokeLater() para asegurar que la GUI se cree y se actualice en el Event Dispatch Thread (EDT), lo cual es una práctica recomendada en Swing para evitar problemas de concurrencia.
Creación de la ventana:
```
1
JFrame frame = new JFrame("Hola Mundo Swing");
2
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
```
JFrame es la ventana principal de nuestra aplicación. Configuramos el comportamiento de cierre para que la aplicación termine cuando se cierra la ventana.
Añadir componentes:
```
1
JLabel label = new JLabel("¡Hola, Mundo!");
2
frame.getContentPane().add(label);
```
Creamos una etiqueta (JLabel) y la añadimos al contenedor principal del frame.
Mostrar la ventana:
```
1
frame.setSize(300, 200);
2
frame.setVisible(true);
```
Establecemos el tamaño de la ventana y la hacemos visible.

Estructura de una Aplicación Swing

Inicialización: Creación de componentes y configuración inicial.
Composición: Añadir componentes a contenedores y configurar layouts.
Event Handling: Configurar listeners para manejar interacciones del usuario.
Visualización: Hacer visible la ventana principal.

Ciclo de Vida de una Aplicación Swing

Inicialización:
- La aplicación se inicia en el método main.
- Se crea la GUI en el EDT.
Event Dispatch Thread (EDT):
- Maneja todos los eventos de la interfaz de usuario.
- Actualiza la GUI basándose en estos eventos.
Finalización:
- La aplicación termina cuando se cierra la ventana principal (en nuestro ejemplo).
- Se liberan los recursos utilizados.