> For the complete documentation index, see [llms.txt](https://educacion.gitbook.io/programacion/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://educacion.gitbook.io/programacion/ud5-entrada-e-saida-da-informacion/interfaces-graficas/componentes.md).

# Compoñentes

## JButton

`JButton` é un compoñente da biblioteca Swing que representa un **botón premible** na interface gráfica. Este compoñente vainos permitir:

* Capturar eventos de pulsación (ActionEvent) cando o usuario fai clic.
* Executar accións en resposta ao evento mediante un ActionListener

Algúns dos métodos mais importantes son os seguintes:

| Método                | Función                        |
| --------------------- | ------------------------------ |
| `addActionListener()` | Engade un listener             |
| `setText()`           | Cambia o texto                 |
| `setEnabled()`        | Activa / desactiva             |
| `setBackground()`     | Cambia a cor                   |
| `setBounds()`         | Posición e tamaño (sen layout) |

<figure><img src="/files/lKc0HNL1GrbU05cn8Xhk" alt=""><figcaption></figcaption></figure>

```java
import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class ExemploBoton extends JFrame {

    private JButton boton;

    public ExemploBoton() {

        // Configuración do frame
        this.setTitle("Exemplo JButton");
        this.setSize(400, 300);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setLayout(null); // Desactivamos layout para posicionar manualmente

        // Crear botón
        boton = new JButton("Preme aquí");
        boton.setBounds(120, 100, 150, 40);

        // Engadir listener
        boton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                System.out.println("Botón premido: " + LocalDateTime.now());
            }
        });

        // Engadir botón ao frame
        this.add(boton);

        this.setVisible(true);
    }

    public static void main(String[] args) {
        new ExemploBoton();
    }
}
```

{% hint style="info" %}
**Documentación oficial:** <https://docs.oracle.com/javase/8/docs/api/javax/swing/JButton.html>
{% endhint %}

## JLabel

`JLabel` é un compoñente para **mostrar texto ou imaxes** dentro dun JFrame ou JPanel.

* Non é interactivo por defecto (non capta clics).
* Pode actualizarse dinámicamente dende o código (por exemplo, mostrar resultados).

Algúns dos métodos mais importantes son os seguintes:

| Método                        | Función                                     |
| ----------------------------- | ------------------------------------------- |
| `setText(String)`             | Cambia o texto                              |
| `setIcon(Icon)`               | Engade unha imaxe                           |
| `setHorizontalAlignment(int)` | Alineación horizontal (LEFT, CENTER, RIGHT) |
| `setVerticalAlignment(int)`   | Alineación vertical (TOP, CENTER, BOTTOM)   |
| `setForeground(Color)`        | Cor do texto                                |
| `setFont(Font)`               | Fonte e tamaño do texto                     |

<figure><img src="/files/xwBV1wvqm2o0g488zsbc" alt=""><figcaption></figcaption></figure>

```java
public class ExemploBoton extends JFrame {

    private JButton boton;
    private JLabel etiqueta;
    private JPanel panelInferior;
    private JPanel panelSuperior;

    public ExemploBoton() {

        // Configuración do frame
        this.setTitle("Exemplo JButton + JLabel");
        this.setSize(400, 300);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setLayout(new BorderLayout(10, 10));

        // Crear etiqueta
        panelSuperior = new JPanel(new GridBagLayout());
        etiqueta = new JLabel("Preme o botón para ver a data/hora");
        etiqueta.setHorizontalAlignment(SwingConstants.CENTER);
        etiqueta.setFont(new Font("Arial", Font.BOLD, 14));
        panelSuperior.add(etiqueta);
        etiqueta.setPreferredSize(new Dimension(400,40));
        this.add(panelSuperior, BorderLayout.CENTER);

        // Crear botón
        panelInferior = new JPanel();
        boton = new JButton("Preme aquí");
        boton.setPreferredSize(new Dimension(150, 40)); 
        panelInferior.add(boton);
   

        // Engadir listener
        boton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                String texto = "Botón premido: " + LocalDateTime.now();
                System.out.println(texto);
                etiqueta.setText(texto); // Actualizamos a etiqueta
            }
        });

        // Engadir botón ao frame
        this.add(panelInferior, BorderLayout.SOUTH);

        this.setVisible(true);
    }

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


```

{% hint style="info" %}
**Documentación oficial:** <https://docs.oracle.com/javase/8/docs/api/javax/swing/JLabel.html>
{% endhint %}

## JTextField

`JTextField` é un compoñente que permite que o usuario escriba **unha liña de texto**.

* Pode ler e actualizar texto con `getText()` e `setText()`.
* Normalmente combínase con `JButton` para executar accións co texto introducido

Algúns dos métodos mais importantes son:

<figure><img src="/files/nCUS4vNxHQKO8Jm1k7mf" alt=""><figcaption></figcaption></figure>

```java
package Interfaces2;

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

public class ExemploCampoTexto extends JFrame {

    private JTextField campoTexto;
    private JButton boton;
    private JPanel panelInferior;
    private JPanel panelSuperior;

    public ExemploCampoTexto() {

        // Configuración do frame
        this.setTitle("Exemplo JTextField");
        this.setSize(400, 300);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setLayout(new BorderLayout(10, 10));

        panelSuperior = new JPanel(new GridBagLayout());
        campoTexto = new JTextField("Escribe aquí");
        campoTexto.setFont(new Font("Arial", Font.BOLD, 14));
        campoTexto.setPreferredSize(new Dimension(250, 40));
        panelSuperior.add(campoTexto);


        // Crear botón
        panelInferior = new JPanel();
        boton = new JButton("Ler texto");
        boton.setBounds(130, 140, 140, 40);
        boton.setPreferredSize(new Dimension(150, 40));
        panelInferior.add(boton);

        // Engadir listener ao botón
        boton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                String texto = campoTexto.getText(); // Ler texto do campo
                System.out.println("Texto introducido: " + texto);
            }
        });

        // Engadir compoñentes ao frame
        this.add(panelSuperior,BorderLayout.CENTER);
        this.add(panelInferior, BorderLayout.SOUTH);

        this.setVisible(true);
    }

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

```

{% hint style="info" %}
Documentación oficial: <https://docs.oracle.com/javase/8/docs/api/javax/swing/JTextField.html>
{% endhint %}

## JRadioButton

**JRadioButton** é un compoñente da biblioteca Swing que representa un botón de opción (radio button) na interface gráfica. Este compoñente vainos permitir:

* Seleccionar unha opción entre varias posibles.
* Capturar eventos cando o usuario selecciona o botón.
* Usarse xunto con **ButtonGroup** para que só se poida seleccionar unha opción á vez.

Algúns dos métodos máis importantes son os seguintes:

| Método              | Función                                    |
| ------------------- | ------------------------------------------ |
| addActionListener() | Engade un listener para detectar selección |
| setText()           | Cambia o texto do radio button             |
| setSelected()       | Marca ou desmarca o botón                  |
| isSelected()        | Comproba se está seleccionado              |
| setEnabled()        | Activa / desactiva                         |
| setBackground()     | Cambia a cor                               |

{% hint style="info" %}
**Documentación oficial:** <https://docs.oracle.com/javase/8/docs/api/javax/swing/JRadioButton.html>
{% endhint %}

## ButtonGroup

**ButtonGroup** é unha clase da biblioteca Swing que permite agrupar varios **JRadioButton** para que só un deles poida estar seleccionado ao mesmo tempo.

Este compoñente vainos permitir:

* Agrupar varios radio buttons.
* Garantir que só unha opción estea seleccionada.
* Xestionar seleccións exclusivas.

Algúns dos métodos máis importantes son os seguintes:

| Método           | Función                      |
| ---------------- | ---------------------------- |
| add()            | Engade un botón ao grupo     |
| remove()         | Elimina un botón do grupo    |
| clearSelection() | Deselecciona todos os botóns |
| getSelection()   | Devolve o botón seleccionado |

{% hint style="info" %}
**Documentación oficial:** <https://docs.oracle.com/javase/8/docs/api/javax/swing/ButtonGroup.html>
{% endhint %}

<figure><img src="/files/Qa1I3jxy72cNJW0qt0m3" alt=""><figcaption></figcaption></figure>

```java
package Interfaces2;
import javax.swing.*;
import java.awt.*;

    public class ExemploRadioButton extends JFrame {

        public ExemploRadioButton() {
            this.setTitle("Exemplo JRadioButton");
            this.setSize(300, 200);
            this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            this.setLayout(new FlowLayout());

            // 1. Crear os RadioButtons
            JRadioButton radio1 = new JRadioButton("Opción A");
            JRadioButton radio2 = new JRadioButton("Opción B");

            // 2. Agrupalos para que sexan excluíntes (IMPORTANTE)
            ButtonGroup grupo = new ButtonGroup();
            grupo.add(radio1);
            grupo.add(radio2);

            // Engadir ao frame
            this.add(radio1);
            this.add(radio2);

            this.setVisible(true);
        }
        public static void main(String[] args) {
            new ExemploRadioButton();
        }
    }
```

## JComboBox

**JComboBox** é un compoñente da biblioteca Swing que representa unha lista despregable na interface gráfica. Este compoñente vainos permitir:

* Mostrar unha lista de opcións ao usuario.
* Permitir seleccionar unha opción da lista.
* Capturar eventos cando cambia a selección.

Algúns dos métodos máis importantes son os seguintes:

| Método              | Función                         |
| ------------------- | ------------------------------- |
| addItem()           | Engade un elemento á lista      |
| removeItem()        | Elimina un elemento             |
| getSelectedItem()   | Devolve o elemento seleccionado |
| setSelectedItem()   | Selecciona un elemento          |
| addActionListener() | Detecta cambios na selección    |
| setEnabled()        | Activa / desactiva              |

{% hint style="info" %}
Documentación oficial: <https://docs.oracle.com/javase/8/docs/api/javax/swing/JComboBox.html>
{% endhint %}

<figure><img src="/files/4xYRAtusVks5AyfPVG1U" alt=""><figcaption></figcaption></figure>

```java
            JFrame frame = new JFrame("Ejemplo JComboBox");
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            frame.setSize(300, 200);

            // Opciones del combo
            String[] opciones = {"Opción 1", "Opción 2", "Opción 3"};

            // Crear JComboBox
            JComboBox<String> comboBox = new JComboBox<>(opciones);

            // Añadir al frame
            frame.setLayout(null);
            comboBox.setBounds(80, 50, 120, 25);
            frame.add(comboBox);

            // Mostrar ventana
            frame.setVisible(true);
```

## JProgressBar

**JProgressBar** é un compoñente da biblioteca Swing que representa unha barra de progreso na interface gráfica. Este compoñente vainos permitir:

* Mostrar o progreso dunha tarefa.
* Indicar visualmente canto falta para completar un proceso.
* Actualizar o progreso dinámicamente.

Algúns dos métodos máis importantes son os seguintes:

| Método             | Función                       |
| ------------------ | ----------------------------- |
| setValue()         | Establece o valor do progreso |
| getValue()         | Devolve o valor actual        |
| setMinimum()       | Establece o valor mínimo      |
| setMaximum()       | Establece o valor máximo      |
| setStringPainted() | Mostra a porcentaxe na barra  |
| setForeground()    | Cambia a cor da barra         |

{% hint style="info" %}
Documentación oficial: <https://docs.oracle.com/javase/8/docs/api/javax/swing/JProgressBar.html>
{% endhint %}

<figure><img src="/files/XBJeBd1YV9f2jhCWwJaA" alt=""><figcaption></figcaption></figure>

```java
        Frame frame = new JFrame("Ejemplo JProgressBar");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(300, 200);

        // Crear barra de progreso
        //Minimo 0 y máximo 100
        JProgressBar progressBar = new JProgressBar(0, 100);
        progressBar.setValue(0);
        progressBar.setStringPainted(true); // Mostrar porcentaje

        // Añadir al frame
        frame.setLayout(null);
        progressBar.setBounds(50, 70, 200, 30);
        frame.add(progressBar);
        //Marcamos el valor en 50
        progressBar.setValue(50);
        
        // Mostrar ventana
        frame.setVisible(true);
```

## JTable

**JTable** é un compoñente da biblioteca Swing que permite mostrar datos en forma de táboa na interface gráfica. Este compoñente vainos permitir:

* Mostrar información organizada en filas e columnas.
* Editar datos directamente nas celas (se está permitido).
* Traballar xunto con **DefaultTableModel** para xestionar os datos da táboa.

Algúns dos métodos máis importantes son os seguintes:

| Método              | Función                              |
| ------------------- | ------------------------------------ |
| setModel()          | Establece o modelo de datos da táboa |
| getModel()          | Devolve o modelo de datos            |
| getValueAt()        | Obtén o valor dunha cela             |
| setValueAt()        | Cambia o valor dunha cela            |
| getSelectedRow()    | Devolve a fila seleccionada          |
| getSelectedColumn() | Devolve a columna seleccionada       |
| setRowHeight()      | Cambia a altura das filas            |

{% hint style="info" %}
Documentación oficial: <https://docs.oracle.com/javase/8/docs/api/javax/swing/JTable.html>
{% endhint %}

## DefaultTableModel

**DefaultTableModel** é unha clase da biblioteca Swing que se utiliza para xestionar os datos dunha táboa (**JTable**) na interface gráfica. Este compoñente vainos permitir:

* Engadir e eliminar filas ou columnas dunha táboa.
* Modificar os datos que aparecen na táboa.
* Actualizar automaticamente a visualización da **JTable** cando cambian os datos.

Algúns dos métodos máis importantes son os seguintes:

| Método           | Función                       |
| ---------------- | ----------------------------- |
| addRow()         | Engade unha nova fila á táboa |
| removeRow()      | Elimina unha fila             |
| addColumn()      | Engade unha nova columna      |
| setValueAt()     | Cambia o valor dunha cela     |
| getValueAt()     | Obtén o valor dunha cela      |
| getRowCount()    | Devolve o número de filas     |
| getColumnCount() | Devolve o número de columnas  |

{% hint style="info" %}
Documentación oficial: <https://docs.oracle.com/javase/8/docs/api/javax/swing/table/DefaultTableModel.html>
{% endhint %}

<figure><img src="/files/nOWKZnEAKil5vehgJikS" alt=""><figcaption></figcaption></figure>

```java
JFrame frame = new JFrame("Ejemplo Tabla");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setSize(300, 200);

//Creamos el modelo con las columnas
DefaultTableModel modelo = new DefaultTableModel();
modelo.addColumn("Código");
modelo.addColumn("Módulo");
modelo.addColumn("Horas");

// Crear tabla y le pasamos el modelo
JTable tabla = new JTable(modelo);

// Añadir tabla al Panel Con Scroll
JScrollPane scroll = new JScrollPane(tabla);
frame.add(scroll);

//Añadimos los elementos
String[][] modulos = {
        {"0485", "Programación", "256"},
        {"0483", "Sistemas Informáticos", "192"},
        {"0484", "Bases de Datos", "192"},
        {"0487", "Entornos de Desarrollo", "96"},
        {"0612", "Desarrollo Web en Entorno Cliente", "126"},
        {"0613", "Desarrollo Web en Entorno Servidor", "147"},
        {"0614", "Despliegue de Aplicaciones Web", "63"},
        {"0615", "Diseño de Interfaces Web", "84"},
        {"0616", "Empresa e Iniciativa Emprendedora", "60"},
        {"0617", "Formación y Orientación Laboral", "90"},
        {"0618", "Proyecto de Desarrollo de Aplicaciones Web", "40"}
};

for (int i = 0; i < modulos.length; i++) {
    modelo.addRow(modulos[i]);
}

// Mostrar ventana
frame.setVisible(true);
```

## JSpinner

**JSpinner** é un compoñente lixeiro (herda de `JComponent`) deseñado para:

* Seleccionar valores dun conxunto limitado
* Incrementar ou decrementar datos con botóns (↑ ↓)
* Introducir valores numéricos, datas ou listas
* Controlar entradas evitando valores inválidos

Non é unha ventá. Non ten barra de título. Non interactúa co sistema operativo.

É simplemente un “selector de valores”. Permite ao usuario cambiar datos de forma controlada e precisa mediante pequenos pasos.

{% hint style="info" %}
**Documentación oficial**: <https://docs.oracle.com/javase/8/docs/api/javax/swing/JSpinner.html>
{% endhint %}

<figure><img src="/files/SqcX2Vo5P5UZTKf9i8Dy" alt=""><figcaption></figcaption></figure>

```java
public class EjemploFecha extends JFrame {

    private JSpinner spFechaNacimiento;

    public EjemploFecha() {
        setTitle("Exemplo Spinner Data");
        setSize(300, 150);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setLayout(new FlowLayout());

        boolean editable = true;

        // Etiqueta
        add(new JLabel("Fecha de nacimiento:"));

        // Spinner de data
        spFechaNacimiento = new JSpinner(new SpinnerDateModel());
        spFechaNacimiento.setEnabled(editable);
        spFechaNacimiento.setEditor(
                new JSpinner.DateEditor(spFechaNacimiento, "dd/MM/yyyy")
        );

        add(spFechaNacimiento);

        // Botón para obter valor
        JButton btnObter = new JButton("Obter data");
        add(btnObter);

        btnObter.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                String fecha = new java.text.SimpleDateFormat("dd/MM/yyyy").format(spFechaNacimiento.getValue());
                DateTimeFormatter formatter = DateTimeFormatter.ofPattern("dd/MM/yyyy");
                LocalDate fechaLD = LocalDate.parse(fecha, formatter);
                System.out.println(fechaLD);
            }
        });

        setLocationRelativeTo(null);
        setVisible(true);
    }

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


```

## JMenuBar

`JMenuBar` é un compoñente da biblioteca Swing que representa a **barra de menú dunha aplicación gráfica**, situada normalmente na parte superior da ventá. Este compoñente vainos permitir:

* Organizar opcións da aplicación en menús.
* Agrupar funcionalidades de forma clara e accesible.
* Mellorar a usabilidade da interface gráfica

{% hint style="warning" %}
**Documentación oficial**: <https://docs.oracle.com/javase/8/docs/api/javax/swing/JMenuBar.html>
{% endhint %}

## JMenu

`JMenu` é un compoñente de Swing que representa un **menú despregable** dentro dunha barra de menú. Este compoñente vainos permitir:

* Crear menús como “Arquivo”, “Editar” ou “Axuda”.
* Agrupar opcións relacionadas.
* Organizar as accións da aplicación en categorías

{% hint style="warning" %}
**Documentación oficial:** <https://docs.oracle.com/javase/8/docs/api/javax/swing/JMenu.html>
{% endhint %}

## JMenuItem

`JMenuItem` é un compoñente de Swing que representa unha **opción seleccionable dentro dun menú**. Este compoñente vainos permitir:

* Executar accións cando o usuario selecciona unha opción.
* Interactuar coa aplicación mediante menús.
* Asociar eventos a opcións concretas

{% hint style="warning" %}
**Documentación Oficial:** <https://docs.oracle.com/javase/8/docs/api/javax/swing/JMenuItem.html>
{% endhint %}

<figure><img src="/files/yjyjvQT5js5Zlt1bHf0V" alt=""><figcaption></figcaption></figure>

```java
public class MenuExemplo {

    public static void main(String[] args) {

        JFrame frame = new JFrame("Exemplo Menú");

        // Barra de menú
        JMenuBar barra = new JMenuBar();

        // Menú principal
        JMenu menu = new JMenu("Menú");

        // Opcións
        JMenuItem itemArquivo = new JMenuItem("Arquivo");
        JMenuItem itemOpcions = new JMenuItem("Opcións");
        JMenuItem itemSair = new JMenuItem("Saír");

        // Engadir opcións ao menú
        menu.add(itemArquivo);
        menu.add(itemOpcions);
        menu.add(itemSair);

        // Engadir menú á barra
        barra.add(menu);

        // Asociar barra ao JFrame
        frame.setJMenuBar(barra);

        // Acción para saír
        itemSair.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                System.out.println("Pulsado o botón sair");
            }
        });

        itemOpcions.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                System.out.println("Pulsado o botón opcions");
            }
        });

        itemArquivo.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                System.out.println("Pulsado o botón Arquivo");
            }
        });


        // Configuración da ventá
        frame.setSize(300, 200);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setVisible(true);
    }
}


```


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://educacion.gitbook.io/programacion/ud5-entrada-e-saida-da-informacion/interfaces-graficas/componentes.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.