> 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/contenedores.md).

# Elementos Contenedores

En Swing, un contenedor é un compoñente que pode conter outros compoñentes dentro del. Todo o que ves nunha aplicación gráfica vive dentro dun contenedor. Non podes poñer un botón “no aire”. Sempre necesita un pai.

As clases Component, Container, JComponent e Window son abstractas e non se poden instanciar

{% @mermaid/diagram content="classDiagram
class Component {
<<abstract>>
\#x: int
\#y: int
\#width: int
\#height: int
+paint(g: Graphics): void
+repaint(): void
}

```
class Container {
    <<abstract>>
    -components: List~Component~
    +add(comp: Component): void
    +remove(comp: Component): void
    +doLayout(): void
}

class JComponent {
    <<abstract>>
    -border: Border
    -opaque: boolean
    +setBorder(b: Border): void
    +setOpaque(o: boolean): void
}

class Window {
    <<abstract>>
    +pack(): void
    +setVisible(b: boolean): void
}

class Frame {
    +setTitle(title: String): void
    +setMenuBar(mb: MenuBar): void
}

class Dialog {
    +setModal(b: boolean): void
}

class JFrame {
    +setDefaultCloseOperation(op: int): void
    +getContentPane(): Container
}

class JDialog {
    +setTitle(title: String): void
}

class JPanel {
    +setLayout(layout: LayoutManager): void
}

class JScrollPane {
    +setViewportView(view: Component): void
    +setHorizontalScrollBarPolicy(p: int): void
}

Component <|-- Container 
Container <|-- Window 
Container <|-- JComponent 
Window <|-- Frame 
Window <|-- Dialog 
Frame <|-- JFrame 
Dialog <|-- JDialog 
JComponent <|-- JPanel 
JComponent <|-- JScrollPane " %}
```

{% hint style="warning" %}
**As relación entre contenedor e compoñentes en Swing adoitan ser relacións de composición**.
{% endhint %}

## JFrame

É o contenedor de máis alto nivel (top-level container). Representa a ventá da aplicación.

Características:

* Ten barra de título
* Pode minimizarse / maximizarse
* Ten botón de peche
* Contén un `contentPane`

Un `JFrame` é un **obxecto complexo composto por outros obxectos**, cada un cunha responsabilidade específica.

```
JFrame
 └── JRootPane 
      ├── glassPane -> Capa superior opcional que pode interceptar eventos
      ├── layeredPane -> Permite organizar compoñentes en capas
      └── contentPane -> É onde se engaden realmente os compoñentes da interface
```

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

| Método                               | Descrición                                                          |
| ------------------------------------ | ------------------------------------------------------------------- |
| `setTitle(String titulo)`            | Establece o título da ventá                                         |
| `setSize(int ancho, int alto)`       | Define o tamaño da ventá                                            |
| `setLocation(int x, int y)`          | Establece a posición na pantalla                                    |
| `setLocationRelativeTo(Component c)` | Centra a ventá (con `null`) ou posición relativa a outro compoñente |
| `setVisible(boolean visible)`        | Mostra ou oculta a ventá                                            |
| `setDefaultCloseOperation(int op)`   | Define a acción ao pechar a ventá                                   |
| `add(Component comp)`                | Engade un compoñente á ventá                                        |
| `getContentPane()`                   | Obtén o contedor principal da ventá                                 |
| `setLayout(LayoutManager layout)`    | Define o tipo de distribución dos compoñentes                       |
| `pack()`                             | Axusta automaticamente o tamaño ao contido                          |
| `setResizable(boolean resizable)`    | Permite ou impide redimensionar a ventá                             |
| `setIconImage(Image img)`            | Establece o icono da ventá                                          |
| `setJMenuBar(JMenuBar bar)`          | Engade unha barra de menú á ventá                                   |

### Operación de peche

Existen diferentes operacións de peche para contenedores en Swing:

| Opción             | Que fai                                                       |
| ------------------ | ------------------------------------------------------------- |
| `EXIT_ON_CLOSE`    | Pecha a ventá e o programa                                    |
| `DISPOSE_ON_CLOSE` | Pecha só a ventá. Se existen mais ventás o programa continua. |
| `HIDE_ON_CLOSE`    | Oculta a ventá. O programa continua.                          |

{% hint style="warning" %}
O peche por defecto de **JFrame** adoita ser EXIT\_ON\_CLOSE. Non está dispoñible para JDialog

O peche por defecto para **JDialog** adoita ser DISPOSE\_ON\_CLOSE.

**EXIT\_ON\_CLOSE non está dispoñible para JDialog**
{% endhint %}

## JPanel

`JPanel` é un contenedor lixeiro (herda de `JComponent`) deseñado para:

* Organizar compoñentes
* Dividir a interface en bloques lóxicos
* Aplicar layouts independentes
* Personalizar zonas da UI

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

**É simplemente unha “superficie organizadora”. Cada sección importante da UI unha clase que estende JPanel.**

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

```java
package Interfaces;

import javax.swing.*;
import java.awt.*;

public class App {

    public static void main(String[] args) {

        //Configuramos el JFrame
        JFrame frame = new JFrame();
        frame.setTitle("Ventana principal");
        frame.setSize(600,400);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setVisible(true);

        //Configuramos el panel
        JPanel panelHeader = new JPanel();
        JPanel panelBody = new JPanel();
        JPanel panelFooter = new JPanel();
            //Color de fondo
        panelHeader.setBackground(Color.GREEN);
        panelBody.setBackground(Color.YELLOW);
        panelFooter.setBackground(Color.CYAN);
            //Dimensiones
        panelHeader.setPreferredSize(new Dimension(600, 80));
        panelFooter.setPreferredSize(new Dimension(600, 60));
            //Añadimos los paneles al frame
        frame.add(panelHeader, BorderLayout.NORTH);
        frame.add(panelBody, BorderLayout.CENTER);
        frame.add(panelFooter, BorderLayout.SOUTH);

    }
}

```

## JDialog

JDialog en Swing é un contenedor que respresenta unha ventana secundaria. Utilízase para mostrar información adicional, pedir confirmacións ou solicitar datos ao usuario.

Esta ventana caracterízase porque:

* Complementa a ventá principal
* Úsase para formularios pequenos, mensaxes ou configuracións
* Ten barra de título
* Pode ter botón de peche
* Depende normalmente dun JFrame (ventá pai)
* Contén un contentPane onde se engaden os compoñentes

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

## JScrollPane

**ScrollPane** é un contedor lixeiro (herda de `JComponent`) deseñado para:

* Engadir barras de desprazamento (vertical e horizontal)
* Permitir visualizar contido máis grande que a zona visible
* Envolver compoñentes como `JTable`, `JTextArea`, `JList`, etc.
* Xestionar automaticamente o scroll segundo o tamaño do contido

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

É simplemente un “contedor con scroll”. Encapsula outro compoñente para poder desprazarse por el cando non cabe na pantalla.

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

## LayoutManager

Un **LayoutManager** en Swing é o obxecto responsable de xestionar automaticamente a disposición espacial dos compoñentes dentro dun contenedor. A súa finalidade é organizar os elementos da interface gráfica segundo un conxunto de regras de distribución predefinidas.

Estes cálculos realízanse tendo en conta:

* As regras propias do tipo de layout utilizado.
* O tamaño dispoñible no contenedor.
* As dimensións preferidas de cada compoñente.

O resultado é unha distribución automática e coherente dos elementos na interface.

* O posicionamento en Swing non se realiza por coordenadas absolutas
* Cada **contenedor, como JFrame ou JPanel, ten asociado un LayoutManager, no seu contentPane**

{% @mermaid/diagram content="classDiagram
class LayoutManager {
<<interface>>
"O obxecto que coloca os compoñentes"
}

```
class FlowLayout {
    "En fila"
    +FlowLayout()
}

class BorderLayout {
    "5 rexións: N, S, E, W, C"
    +BorderLayout()
}

class GridLayout {
    "Táboa con celas"
    +GridLayout(2,3)
}

LayoutManager <|.. FlowLayout : implements
LayoutManager <|.. BorderLayout : implements
LayoutManager <|.. GridLayout : implements" %}
```

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

## BorderLayout

**BorderLayout** é un LayoutManager que organiza os compoñentes dividindo o contenedor en cinco rexións diferenciadas. Cada rexión cumpre unha función estrutural dentro da interface.

* Divide o espazo en cinco zonas: NORTH, SOUTH, EAST, WEST e CENTER.
* Só permite un compoñente por cada rexión.
* A zona CENTER ocupa automaticamente o espazo restante.
* Adáptase ao redimensionamento da ventá reorganizando os tamaños.
* É o layout por defecto dos `JFrame`.

Este layout é especialmente adecuado para **estruturar a interface principal dunha aplicación**.

## FlowLayout

**FlowLayout** é un LayoutManager que organiza os compoñentes en liña, seguindo unha orde secuencial.

* Coloca os compoñentes de esquerda a dereita.
* Cando non hai espazo suficiente, salta automaticamente á seguinte liña.
* Respecta o tamaño preferido de cada compoñente.
* Permite aliñación (esquerda, centro ou dereita).
* É o layout por defecto dos `JPanel`.

É apropiado para **disposicións simples e para agrupar controis básicos.**

## GridLayout

**GridLayout** é un LayoutManager que distribúe os compoñentes nunha grella de filas e columnas.

* Divide o contenedor en celas iguais.
* Todos os compoñentes teñen exactamente o mesmo tamaño.
* Non respecta o tamaño preferido individual.
* O número de filas e columnas determínase na súa creación.
* Adáptase automaticamente ao tamaño do contenedor.

É útil para e**struturas uniformes como formularios sinxelos ou paneis tipo teclado**.

### GridBagLayout

**GridBagLayout** é un **LayoutManager** avanzado que permite organizar compoñentes nunha grella flexible de filas e columnas.

* Divide o contenedor nunha grella, pero **as celas poden ter tamaños diferentes**.
* Permite que os compoñentes **ocupen varias filas ou columnas**.
* Utiliza un obxecto **GridBagConstraints** para definir a posición e o comportamento de cada compoñente.
* Respecta mellor o **tamaño preferido dos compoñentes**.
* Permite controlar **aliñación, espazos, expansión e posición** dos elementos.
* Os compoñentes poden **expandirse horizontal ou verticalmente** segundo a configuración.
* É moi flexible pero tamén **máis complexo de usar** ca outros layouts.
* É útil para **formularios complexos, interfaces detalladas e deseños máis personalizados**.


---

# 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, and the optional `goal` query parameter:

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

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.