Java Swing y JavaFX son las dos librerías principales para crear interfaces de escritorio en Java. Swing vive en el JDK desde Java 2 y se mantiene en modo mantenimiento; JavaFX, fuera del JDK desde Java 11, ofrece escenas aceleradas por GPU con FXML y CSS. Esta guía compara ambos y te enseña tu primera aplicación JavaFX.

Java Swing vs JavaFX: cuál elegir (y tutorial JavaFX)

Última actualización: agosto 2026

Contenido Rápido

• Swing está en el JDK desde Java 2; JavaFX vive fuera del JDK desde Java 11
• Swing usa componentes clásicos de javax.swing; JavaFX usa escenas con FXML y CSS
• JavaFX acelera el renderizado por GPU; Swing pinta por CPU
• Swing está en modo mantenimiento; JavaFX recibe desarrollo activo en OpenJFX
• Para mantener apps legacy, Swing sigue siendo la opción segura
• El tutorial te enseña Application, Stage, Scene, FXML y @FXML

Si quieres crear una aplicación de escritorio con Java, te habrás encontrado con la misma duda: ¿uso Swing o JavaFX? No es una decisión menor: condiciona el código que escribirás durante años. La buena noticia es que cada una tiene un lugar claro, y esta guía te ayuda a elegir con datos concretos.

Compararemos ambas punto por punto, veremos en qué casos gana cada una y cerraremos con un tutorial JavaFX paso a paso. Si todavía no tienes el JDK configurado, empieza por la guía para instalar Java y vuelve.

Qué es Swing

Swing es la librería gráfica clásica de Java, creada por Sun en 1997 como parte de las JFC e incluida en el JDK desde Java 2. Sus clases viven en el paquete javax.swing.* sobre el módulo java.desktop, con componentes familiares como JFrame, JButton, JPanel o JLabel.

Desde Java 9, Oracle mantiene Swing en modo mantenimiento: recibe correcciones y parches de seguridad, pero no incorpora funcionalidades nuevas importantes. No está muerto: IntelliJ IDEA y NetBeans usan Swing internamente para su interfaz, y miles de aplicaciones empresariales dependen de él. Seguirá en el JDK en el futuro previsible, como explica la documentación oficial de Swing.

Detalle relevante: el código de la interfaz se ejecuta en un hilo especial, el Event Dispatch Thread (EDT). Toda actualización de componentes debe ocurrir en él, lo que enlaza con la gestión de hilos en Java cuando la app crece.

Qué es JavaFX

JavaFX es la librería gráfica moderna de Java, pensada para sustituir a Swing. Nació en 2008 y viajó dentro del JDK con Java 8, pero desde Java 11 se distribuye como proyecto independiente, OpenJFX, con el grupo Maven org.openjfx y su propio ciclo de versiones.

Su modelo es muy distinto. En lugar de añadir componentes a un contenedor, defines una escena con una jerarquía de nodos (Scene, Stage, VBox, Button), la estilizas con CSS y describes las vistas en FXML, un XML que separa la interfaz del código. El renderizado, además, está acelerado por GPU, lo que permite animaciones fluidas.

El editor visual de referencia es Scene Builder, de Gluon: diseñas la interfaz arrastrando controles y genera el FXML. Todo el ecosistema está documentado en el sitio oficial de OpenJFX.

Tabla de comparación: Swing vs JavaFX

Característica	Swing	JavaFX
Inclusión en JDK	En el JDK desde Java 2 (módulo java.desktop)	Fuera del JDK desde Java 11 (OpenJFX)
Rendimiento	Pintado por CPU	Acelerado por GPU
Estilo de UI	Componentes clásicos (JFrame, JButton)	Escenas con FXML y hojas de estilo CSS
Curva de aprendizaje	Baja si vienes de AWT	Moderada: escena, FXML, CSS
Mantenimiento	Modo mantenimiento desde Java 9	Desarrollo activo en OpenJFX
Cuándo usarlo	Mantener apps empresariales legacy	Apps de escritorio modernas

La tabla resume lo esencial: no hay un ganador absoluto, sino dos perfiles. Swing es la opción conservadora ya probada; JavaFX, la apuesta a futuro con un modelo más moderno. El siguiente apartado concreta cuándo elegir cada una.

Cuál elegir según tu caso

La decisión práctica depende del contexto del proyecto, no de la tecnología en abstracto:

• Mantener una app empresarial legacy: usa Swing. Reescribir una aplicación madura solo por la librería gráfica raramente compensa; aquí Swing sigue siendo la opción correcta.
• Crear una app de escritorio nueva: elige JavaFX. Tiene mejor rendimiento, CSS para estilizar sin tocar código y FXML para separar vista de lógica.
• Tu equipo ya conoce CSS y XML: JavaFX acorta la curva de aprendizaje, porque reutiliza conocimientos que ya tenéis.
• Tu caso es una aplicación web: ninguna de las dos. Para interfaces web, el ecosistema de Spring Boot y sus API REST es la vía habitual del mercado.

Si estás planificando tu carrera, esta decisión forma parte de la ruta de junior a senior de CodeJa. Para el mercado actual, JavaFX suma más a tu perfil de escritorio; Swing solo interesa si trabajas con productos legacy concretos.

Tutorial JavaFX paso a paso: tu primera app

Construiremos una lista de tareas mínima con JavaFX para ver los conceptos en acción. Necesitas Java 11 o superior y Maven; con eso basta.

1. El modelo de datos

Como el dominio no depende de la interfaz, define la tarea como un record de Java, el tipo inmutable que viste en nuestra guía de programación funcional:

public record Tarea(String titulo, boolean completada) {

    public Tarea marcarCompletada() {
        return new Tarea(titulo, true);
    }
}

La parte de Java puro de este ejemplo, como el record Tarea, puedes ejecutarla en el Java Playground de CodeJa: compila y ejecuta Java directamente en el navegador, sin instalar nada. La ventana de la interfaz, en cambio, necesita el entorno gráfico de tu equipo.

2. Añade JavaFX al proyecto

Declara las dependencias de OpenJFX en el pom.xml. El plugin de Maven lanza la aplicación y resuelve los módulos nativos:

<dependency>
    <groupId>org.openjfx</groupId>
    <artifactId>javafx-controls</artifactId>
    <version>21</version>
</dependency>

<plugin>
    <groupId>org.openjfx</groupId>
    <artifactId>javafx-maven-plugin</artifactId>
    <version>0.0.8</version>
</plugin>

3. La clase principal: Application

Toda aplicación JavaFX extiende javafx.application.Application e implementa start(Stage stage), el método obligatorio donde construyes la escena. La firma public void start(Stage stage) throws Exception es parte del contrato, y launch(args) arranca desde el main que ya conoces:

import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.control.Label;
import javafx.scene.layout.VBox;
import javafx.stage.Stage;

public class HolaJavaFX extends Application {

    @Override
    public void start(Stage stage) throws Exception {
        Label saludo = new Label("Hola desde JavaFX");
        VBox raiz = new VBox(saludo);
        Scene escena = new Scene(raiz, 400, 300);

        stage.setTitle("Mi primera app JavaFX");
        stage.setScene(escena);
        stage.show();
    }

    public static void main(String[] args) {
        launch(args);
    }
}

4. Vistas con FXML y @FXML

Construir la interfaz en código funciona para ejemplos, pero cuando la vista crece conviene separarla en un archivo FXML. El fichero vista.fxml declara los controles y conecta los eventos mediante fx:id y onAction:

<?xml version="1.0" encoding="UTF-8"?>

<?import javafx.scene.control.Button?>
<?import javafx.scene.control.Label?>
<?import javafx.scene.control.TextField?>
<?import javafx.scene.layout.VBox?>

<VBox spacing="10" xmlns:fx="http://javafx.com/fxml">
    <Label text="Lista de tareas"/>
    <TextField fx:id="campoTitulo" promptText="Nueva tarea"/>
    <Button text="Añadir tarea" onAction="#agregarTarea"/>
</VBox>

El controlador es una clase Java normal cuyos campos y métodos se enlazan con la vista mediante @FXML. La escena se carga con FXMLLoader.load(getClass().getResource("/vista.fxml")) y el resultado se asigna a una Scene en start:

import javafx.fxml.FXML;
import javafx.scene.control.Label;
import javafx.scene.control.TextField;
import javafx.scene.layout.VBox;

public class TareasController {

    @FXML
    private TextField campoTitulo;

    @FXML
    private VBox listaTareas;

    @FXML
    private void agregarTarea() {
        Tarea tarea = new Tarea(campoTitulo.getText(), false);
        listaTareas.getChildren().add(new Label(tarea.titulo()));
    }
}

En proyectos reales, diseñas la vista en Scene Builder de Gluon, que genera el FXML, y enlazas los fx:id con los campos @FXML del controlador. El resultado es el mismo: lógica en Java y presentación en XML con estilos CSS.

Preguntas Frecuentes

¿Qué es mejor, Swing o JavaFX?

Depende del contexto. Para mantener aplicaciones legacy, Swing es la opción segura y estable. Para proyectos de escritorio nuevos, JavaFX ofrece mejor rendimiento, estilos CSS y un modelo de escenas más moderno; sin restricciones previas, es la recomendación general.

¿JavaFX está incluido en el JDK?

No desde Java 11. Java 8 lo incluía; a partir de Java 11 se distribuye como proyecto independiente, OpenJFX, con el grupo Maven org.openjfx y su propio ciclo de versiones. Swing sigue incluido en el JDK dentro del módulo java.desktop.

¿Swing está obsoleto?

No, pero está en modo mantenimiento. Oracle corrige bugs y vulnerabilidades desde Java 9 sin añadir funcionalidades nuevas importantes. Miles de aplicaciones lo usan y seguirá en el JDK en el futuro previsible, así que mantenerlo no es un riesgo inmediato.

¿Puedo usar Swing y JavaFX en la misma aplicación?

Sí. JavaFX ofrece la clase javafx.embed.swing.SwingNode para incrustar componentes Swing dentro de una aplicación JavaFX, y javafx.embed.swing.JFXPanel para el caso inverso. Esta compatibilidad es útil en migraciones progresivas, aunque lo habitual es elegir una y mantenerla.

¿Necesito Scene Builder para trabajar con JavaFX?

No es obligatorio, pero facilita mucho el trabajo. Scene Builder, de Gluon, es un editor visual que genera el FXML arrastrando controles, sin escribir XML a mano. También puedes construir las vistas en código puro con las clases de javafx.scene.

Artículos Relacionados

• Instalar Java y configurar el JDK
• Método main() en Java: punto de entrada
• Hilos y Thread en Java: guía práctica
• Spring Boot: qué es y cómo funciona
• Programación funcional en Java: guía completa