Creación de una Tabla de Trabajadores en JavaFX

En este artículo, explicaremos paso a paso cómo crear una tabla para visualizar información de trabajadores utilizando JavaFX. Además, proporcionaremos el código fuente comentado para facilitar su comprensión.

Introducción

JavaFX es una potente biblioteca de gráficos para Java que permite crear interfaces de usuario avanzadas. En este ejemplo, crearemos una tabla que muestra los datos de varios trabajadores, incluyendo su nombre, apellido y salario.

Código Fuente y Explicación

A continuación, se presenta el código fuente con comentarios detallados:

package Tabla_de_trabajadores;

import javafx.application.Application;
import javafx.collections.FXCollections;
import javafx.collections.ObservableList;
import javafx.scene.Scene;
import javafx.scene.control.TableColumn;
import javafx.scene.control.TableView;
import javafx.scene.control.cell.PropertyValueFactory;
import javafx.scene.layout.BorderPane;
import javafx.stage.Stage;

// La clase principal que extiende Application para crear una aplicación JavaFX
public class Tabla_trabajadores extends Application {

    // Método start donde se configura la ventana principal (Stage)
    @Override
    public void start(Stage primaryStage) {
        primaryStage.setTitle("Tabla de trabajadores"); // Título de la ventana

        // Crear la tabla
        TableView<Trabajador> table = new TableView<>();

        // Crear columnas de la tabla y establecer cómo obtener sus valores
        TableColumn<Trabajador, String> nombreColumn = new TableColumn<>("Nombre");
        nombreColumn.setCellValueFactory(new PropertyValueFactory<>("nombre"));

        TableColumn<Trabajador, String> apellidoColumn = new TableColumn<>("Apellido");
        apellidoColumn.setCellValueFactory(new PropertyValueFactory<>("apellido"));

        TableColumn<Trabajador, Integer> salarioColumn = new TableColumn<>("Salario");
        salarioColumn.setCellValueFactory(new PropertyValueFactory<>("salario"));

        // Añadir las columnas a la tabla
        table.getColumns().addAll(nombreColumn, apellidoColumn, salarioColumn);

        // Crear los datos y asignarlos a la tabla
        ObservableList<Trabajador> data = getTrabajadores();
        table.setItems(data);

        // Crear el layout principal y añadir la tabla al centro
        BorderPane root = new BorderPane();
        root.setCenter(table);

        // Crear la escena con el layout y establecerla en el escenario principal
        Scene scene = new Scene(root, 600, 400);
        primaryStage.setScene(scene);
        primaryStage.show(); // Mostrar la ventana
    }

    // Método para obtener la lista de trabajadores
    private ObservableList<Trabajador> getTrabajadores() {
        ObservableList<Trabajador> trabajadores = FXCollections.observableArrayList();
        trabajadores.add(new Trabajador("Juan", "Perez", 2500));
        trabajadores.add(new Trabajador("Ana", "Peron", 4000));
        trabajadores.add(new Trabajador("Rodrigo", "Balsameda", 500));
        return trabajadores;
    }

    // Método principal que lanza la aplicación
    public static void main(String[] args) {
        launch(args);
    }
}

// Clase Trabajador que representa a cada trabajador con sus propiedades
class Trabajador {
    private String nombre;
    private String apellido;
    private int salario;

    // Constructor para inicializar los valores
    public Trabajador(String nombre, String apellido, int salario) {
        this.nombre = nombre;
        this.apellido = apellido;
        this.salario = salario;
    }

    // Getters para acceder a las propiedades
    public String getNombre() {
        return nombre;
    }

    public String getApellido() {
        return apellido;
    }

    public int getSalario() {
        return salario;
    }
}

Explicación del Código

1. Paquete e Importaciones:

• El código está contenido en el paquete Tabla_de_trabajadores.
• Importamos las clases necesarias de JavaFX, como Application, TableView, TableColumn, PropertyValueFactory, entre otras.

1. Clase Principal Tabla_trabajadores:

• Extiende Application para crear una aplicación JavaFX.
• El método start configura y muestra la ventana principal.

1. Configuración de la Tabla:

• Se crea una instancia de TableView para contener los objetos Trabajador.
• Se crean tres columnas (nombreColumn, apellidoColumn, salarioColumn) y se establece cómo obtener los valores de cada columna utilizando PropertyValueFactory.

1. Datos de los Trabajadores:

• El método getTrabajadores retorna una lista observable (ObservableList) que contiene varios objetos Trabajador.

1. Clase Trabajador:

• Contiene las propiedades nombre, apellido y salario.
• Tiene un constructor para inicializar estas propiedades y métodos getter para acceder a ellas.

1. Mostrar la Ventana:

• La escena se crea con un BorderPane que contiene la tabla en su centro.
• La escena se asigna al primaryStage, que luego se muestra con primaryStage.show().

Conclusión

Este ejemplo demuestra cómo crear una tabla en JavaFX para mostrar datos de objetos personalizados. La utilización de PropertyValueFactory facilita la vinculación de las columnas de la tabla con las propiedades de los objetos. Con este conocimiento, puedes expandir la funcionalidad de tu aplicación JavaFX para manejar datos más complejos y presentarlos de manera efectiva.

Puedes copiar el código directamente y ejecutarlo en tu entorno de desarrollo para ver cómo funciona. Asegúrate de tener configurada tu instalación de JavaFX correctamente para evitar problemas de ejecución.