Skip to content

4 Contenedores

Introducción

Como ya hemos visto, existen diferentes componentes en Swing. Los contenedores son unos componentes especiales encargados de agrupar otros componentes. El JFrame tiene por defecto un ContentPane como contenedor que puede ser modificado por cualquier otro componente.

Entre los contenedores más comunes de Swing, encontramos:

  • JFrame: Es el contenedor de nivel superior más utilizado en una aplicación Swing. Representa una ventana con un borde, un título, botones de cierre y maximización, etc.
  • JPanel: Es un contenedor genérico que se utiliza para organizar y agrupar otros componentes. Puede actuar como un contenedor para otros paneles o para componentes individuales.
  • JDialog: Similar a un JFrame, pero se utiliza para crear cuadros de diálogo modales o no modales.
  • JApplet: Es un contenedor específico para las applets de Java, aunque su uso ha disminuido significativamente en favor de las aplicaciones Java independientes.
  • JScrollPane: Es un contenedor especializado que proporciona barras de desplazamiento para ver contenido que no cabe completamente dentro del área visible.
  • JTabbedPane: Organiza los componentes secundarios en pestañas, permitiendo al usuario cambiar entre diferentes conjuntos de componentes.
  • JSplitPane: Divide el área disponible en dos (horizontal o verticalmente) y permite al usuario ajustar el tamaño relativo de las dos áreas.
  • JToolBar: Es un contenedor que normalmente se encuentra en la parte superior de una ventana y contiene botones u otros componentes para realizar acciones comunes.
  • JDesktopPane y JInternalFrame: Estos contenedores se utilizan para crear interfaces de múltiples ventanas, donde las ventanas internas (JInternalFrame) se pueden mover y redimensionar dentro del área de trabajo (JDesktopPane).

JPanel

JPanel es una clase en Java Swing que actúa como un contenedor genérico para organizar y agrupar otros componentes Swing. Funciona como un lienzo en el que puedes colocar y organizar varios componentes, como botones, etiquetas, campos de texto, etc. Los paneles se utilizan comúnmente para dividir la interfaz de usuario en secciones lógicas y para aplicar diseños específicos a grupos de componentes.

public class JPanelExample {
    public void show() {
        // Crear un JFrame
        JFrame frame = new JFrame("Ejemplo de JPanel");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        // Crear un JPanel
        JPanel panel = new JPanel();
        panel.setBackground(Color.WHITE);

        // Añadir componentes al panel
        JLabel label = new JLabel("Hola, mundo!");
        JButton button = new JButton("Haz clic aquí");
        panel.add(label);
        panel.add(button);

        // Añadir el panel al JFrame
        frame.getContentPane().add(panel);

        // Ajustar el tamaño del JFrame y hacerlo visible
        frame.setSize(300, 200);
        frame.setLocationRelativeTo(null); // Centrar la ventana en la pantalla
        frame.setVisible(true);
    }

    public static void main(String[] args) {
        new JPanelExample().show();
    }
}

JDialog

JDialog es una clase en Java Swing que representa un cuadro de diálogo en una aplicación. Se utiliza para mostrar mensajes, solicitar información al usuario o realizar acciones que requieren su atención. Un JDialog puede ser modal o no modal, lo que significa que puede bloquear o no bloquear la interacción con otras ventanas de la aplicación mientras está abierto.

Un JDialog modal bloquea la interacción con otras ventanas de la aplicación hasta que se cierra. Esto es útil para alertas importantes o solicitudes de información crítica que requieren la atención inmediata del usuario.

public class JDialogExample {

    public void show(){
        // Crear un JFrame
        JFrame frame = new JFrame("Ejemplo de JDialog");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        // Crear un JButton para mostrar el cuadro de diálogo
        JButton button = new JButton("Mostrar Diálogo");
        button.addActionListener(e -> {
            // Crear un JDialog modal
            JDialog dialog = new JDialog(frame, "Cuadro de Diálogo", true);

            // Añadir un JLabel al cuadro de diálogo
            JLabel label = new JLabel("¡Hola desde el cuadro de diálogo!");
            dialog.add(label);

            // Establecer el tamaño del cuadro de diálogo
            dialog.setSize(200, 100);

            // Hacer visible el cuadro de diálogo
            dialog.setVisible(true);
        });

        // Añadir el JButton al JFrame
        frame.getContentPane().add(button);

        // Ajustar el tamaño del JFrame y hacerlo visible
        frame.setSize(300, 200);
        frame.setLocationRelativeTo(null); // Centrar la ventana en la pantalla
        frame.setVisible(true);
    }

    public static void main(String[] args) {
        new JDialogExample().show();
    }

}

JScrollPane

JScrollPane es un contenedor especializado en Java Swing que proporciona barras de desplazamiento para permitir al usuario desplazarse por el contenido que no cabe completamente dentro del área visible del contenedor. Se utiliza comúnmente para mostrar componentes que contienen grandes cantidades de datos, como listas largas, tablas extensas o áreas de texto grandes. JScrollPane agrega barras de desplazamiento vertical y horizontal automáticamente cuando el contenido del componente supera el tamaño del área visible.

Permite al usuario desplazarse suavemente por el contenido utilizando las barras de desplazamiento o, en el caso de dispositivos con pantalla táctil, mediante gestos de desplazamiento. Se puede personalizar el comportamiento y la apariencia de las barras de desplazamiento utilizando métodos como setVerticalScrollBarPolicy(int policy) y setHorizontalScrollBarPolicy(int policy).

public class JScrollPaneExample {
    public void show() {
        // Crear un JFrame
        JFrame frame = new JFrame("Ejemplo de JScrollPane");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        // Crear un JTextArea con un texto largo
        JTextArea textArea = new JTextArea(10, 20);
        for (int i = 0; i < 100; i++) {
            textArea.append("Línea " + (i + 1) + "\n");
        }

        // Crear un JScrollPane con el JTextArea como contenido
        JScrollPane scrollPane = new JScrollPane(textArea);

        // Añadir el JScrollPane al JFrame
        frame.getContentPane().add(scrollPane);

        // Ajustar el tamaño del JFrame y hacerlo visible
        frame.setSize(300, 200);
        frame.setLocationRelativeTo(null); // Centrar la ventana en la pantalla
        frame.setVisible(true);
    }

    public static void main(String[] args) {
        new JScrollPaneExample().show();
    }
}

JTabbedPane

JTabbedPane es un componente en Java Swing que permite a los desarrolladores organizar la interfaz de usuario en pestañas, cada una de las cuales puede contener su propio conjunto de componentes. Este componente es muy útil para presentar diferentes vistas o secciones de una aplicación de manera organizada y accesible. Cada pestaña puede contener cualquier componente Swing, como paneles, botones, etiquetas, campos de texto, etc.

Las pestañas pueden colocarse en diferentes posiciones (TOP, BOTTOM, LEFT, RIGHT) utilizando el método setTabPlacement(int tabPlacement). Puedes añadir iconos y títulos a las pestañas para una identificación visual más fácil utilizando los métodos addTab(String title, Icon icon, Component component) y variantes.

Puedes añadir ChangeListener para manejar eventos de cambio de pestaña, lo que te permite ejecutar código cuando el usuario cambia de una pestaña a otra.

public class JTabbedPaneExample {
    public void show() {
        // Crear un JFrame
        JFrame frame = new JFrame("Ejemplo de JTabbedPane");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(400, 300);
        frame.setLocationRelativeTo(null); // Centrar la ventana en la pantalla

        // Crear un JTabbedPane
        JTabbedPane tabbedPane = new JTabbedPane();

        // Crear paneles para las pestañas
        JPanel panel1 = new JPanel();
        panel1.add(new JLabel("Contenido de la Pestaña 1"));

        JPanel panel2 = new JPanel();
        panel2.add(new JLabel("Contenido de la Pestaña 2"));

        JPanel panel3 = new JPanel();
        panel3.add(new JLabel("Contenido de la Pestaña 3"));

        // Añadir las pestañas al JTabbedPane
        tabbedPane.addTab("Pestaña 1", panel1);
        tabbedPane.addTab("Pestaña 2", panel2);
        tabbedPane.addTab("Pestaña 3", panel3);

        // Añadir el JTabbedPane al JFrame
        frame.getContentPane().add(tabbedPane, BorderLayout.CENTER);

        // Hacer visible el JFrame
        frame.setVisible(true);
    }

    public static void main(String[] args) {
        new JTabbedPaneExample().show();
    }
}

JSplitPane

JSplitPane es un componente de Java Swing que divide el área de visualización en dos componentes ajustables. Estos componentes pueden ser organizados horizontal o verticalmente y el usuario puede cambiar el tamaño de cada área arrastrando el divisor. JSplitPane es útil cuando se necesita presentar dos componentes que el usuario puede querer ver simultáneamente pero ajustar el tamaño relativo de cada uno según sus necesidades.

Se puedes configurar el JSplitPane para que divida los componentes horizontalmente (JSplitPane.HORIZONTAL_SPLIT) o verticalmente (JSplitPane.VERTICAL_SPLIT). El divisor entre los dos componentes es ajustable por el usuario, permitiendo cambiar el tamaño de las áreas de visualización.

Se puede establecer la posición inicial del divisor utilizando el método setDividerLocation(int location). También se puede bloquear el divisor para evitar que el usuario cambie el tamaño de las áreas de visualización utilizando el método setEnabled(boolean enabled).

Además se puede añadir PropertyChangeListener para manejar eventos cuando cambia la posición del divisor.

public class JSplitPaneExample {

    public void show(){
        // Crear un JFrame
        JFrame frame = new JFrame("Ejemplo de JSplitPane");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(500, 300);
        frame.setLocationRelativeTo(null); // Centrar la ventana en la pantalla

        // Crear dos paneles para dividir
        JPanel leftPanel = new JPanel();
        leftPanel.setBackground(Color.CYAN);
        leftPanel.add(new JLabel("Panel Izquierdo"));

        JPanel rightPanel = new JPanel();
        rightPanel.setBackground(Color.LIGHT_GRAY);
        rightPanel.add(new JLabel("Panel Derecho"));

        // Crear un JSplitPane con división horizontal
        JSplitPane splitPane = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, leftPanel, rightPanel);
        splitPane.setDividerLocation(150); // Posición inicial del divisor

        // Añadir el JSplitPane al JFrame
        frame.getContentPane().add(splitPane);

        // Hacer visible el JFrame
        frame.setVisible(true);
    }

    public static void main(String[] args) {
        new JSplitPaneExample().show();
    }

}

JToolbar

JToolBar es un componente en Java Swing que se utiliza para crear barras de herramientas en la interfaz de usuario. Estas barras de herramientas suelen contener botones, iconos y otros componentes interactivos que permiten al usuario realizar acciones comunes o acceder rápidamente a funciones específicas de la aplicación. JToolBar puede ser flotante o anclado a los bordes de un contenedor, como un JFrame. Puede ser orientado horizontalmente (JToolBar.HORIZONTAL) o verticalmente (JToolBar.VERTICAL). Además puede añadir separadores (JToolBar.Separator) para organizar los componentes en grupos lógicos.

public class JToolbar {
    public void show() {
        JFrame frame = new JFrame("Ejemplo de JToolBar");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(400, 300);
        frame.setLocationRelativeTo(null); // Centrar la ventana en la pantalla

        // Crear un JToolBar
        JToolBar toolBar = new JToolBar();
        toolBar.setFloatable(true); // Permitir que la barra de herramientas sea flotante

        // Crear botones para la barra de herramientas
        JButton newButton = new JButton(new ImageIcon("icons/new.png")); // Asegúrate de tener un icono llamado "new.png"
        newButton.setToolTipText("Nuevo");
        toolBar.add(newButton);

        JButton openButton = new JButton(new ImageIcon("icons/open.png")); // Asegúrate de tener un icono llamado "open.png"
        openButton.setToolTipText("Abrir");
        toolBar.add(openButton);

        JButton saveButton = new JButton(new ImageIcon("icons/save.png")); // Asegúrate de tener un icono llamado "save.png"
        saveButton.setToolTipText("Guardar");
        toolBar.add(saveButton);

        // Añadir un separador
        toolBar.addSeparator();

        // Añadir otro botón
        JButton exitButton = new JButton(new ImageIcon("icons/exit.png")); // Asegúrate de tener un icono llamado "exit.png"
        exitButton.setToolTipText("Salir");
        toolBar.add(exitButton);

        // Añadir ActionListener para el botón de salir
        exitButton.addActionListener(e -> System.exit(0));

        // Añadir el JToolBar al JFrame
        frame.getContentPane().add(toolBar, "North"); // Añadir la barra de herramientas en la parte superior

        // Hacer visible el JFrame
        frame.setVisible(true);
    }

    public static void main(String[] args) {
        new JToolbar().show();
    }
}

Se puede hacer flotante haciendo uso del método setFlotable(boolean).

JDesktopPane y JInternalFrame

JDesktopPane y JInternalFrame son componentes de Java Swing que se utilizan para crear aplicaciones que tienen múltiples documentos o ventanas internas, similares a un entorno de escritorio. Estos componentes son útiles para implementar el patrón MDI (Multiple Document Interface), donde una sola ventana principal contiene varias sub-ventanas internas que pueden ser gestionadas de forma independiente.

JDesktopPane es un contenedor que actúa como el escritorio virtual sobre el cual se pueden colocar múltiples JInternalFrame. Es similar a la ventana de un sistema operativo donde se pueden abrir y organizar varias ventanas internas. Con la propiedad Z-Order se puede gestionar la superposición de las ventanas internas, controlando cuál está en primer plano.

JInternalFrame es un componente similar a JFrame, pero diseñado para ser utilizado dentro de un JDesktopPane. Tiene la apariencia y el comportamiento de una ventana interna, incluyendo bordes, barra de título y botones de control (cerrar, minimizar, maximizar).