2 Componentes¶

Introducción¶

El funcionamiento de los componentes del paquete Swing, son los mismos que los componentes en AWT. Esto es debido a porque todas las clases e interfaces de dicho paquete son heredados del paquete AWT.

Sin embargo, los componentes Swing añade nuevas funcionalidades, haciéndolo más rico y útil que la biblioteca AWT.

La mayoría de los nombre de AWT y Swing coinciden en parte, teniendo un prefijo J en los componentes Swing. Por ejemplo, el componente Panel de AWT tiene un similar en Swing llamado JPanel.

JComponent¶

La clase JComponent es una clase del paquete Swing más fundamental, debido a que todos los componentes heredan de esta clase. La clase JComponent a su vez hereda de la clase Container del paquete AWT, que hereda de Component.

Proporciona el método paintComponent(Graphics g), que se utiliza para renderizar el componente. Este método ha de ser sobrescrito para renderizar componentes personalizados. Esta versión del componente permite trabajar con los bordes haciendo uso del método setBorder(Border border). Esto es útil para agregar decoraciones o delimitaciones visuales a los componentes.

Otros métodos de interés:

• setTooltipText(String text): permite crear tooltips en el componente. Los tooltips son útiles para proporcionar información adicional sobre un componente cuando el usuario pasa el cursor sobre él.
• setPreferredSize(Dimension d), setMinimumSize(Dimension d) y setMaximumSize(Dimension d) para controlar las dimensiones preferidas, mínimas y máximas del componente.
• Soporta la integración con tecnologías de asistencia mediante métodos de accesibilidad, mejorando la experiencia para usuarios con discapacidades.

JComponent proporciona el doble buffering, una técnica que reduce el parpadeo durante la actualización de gráficos, proporcionando una representación más suave.

Graphics¶

La clase Graphics en Java es parte del paquete java.awt y es fundamental para la creación de gráficos en aplicaciones Java. Proporciona los métodos necesarios para dibujar formas, texto e imágenes en componentes gráficos. Aunque Graphics es una clase abstracta, sus métodos son implementados por la clase Graphics2D, que proporciona capacidades de dibujo más avanzadas.

Veamos algunos de sus métodos:

Bordes¶

Los bordes vienen definidos en la interfaz Border del paquete Swing. Esta interfaz define una serie de métodos que deben ser implementados por las clases que definen distintos tipos de bordes que pueden ser aplicados a componentes Swing.

Los bordes se utilizan ampliamente en Swing para proporcionar delimitaciones visuales alrededor de componentes como JPanel, JButton, JTextField, entre otros. Swing proporciona varias implementaciones predeterminadas de la interfaz Border en el subpaquete javax.swing.border:

• EmptyBorder: Un borde vacío que deja espacio en blanco alrededor de un componente.
• LineBorder: Un borde simple que dibuja una línea alrededor del componente.
• EtchedBorder: Un borde con un efecto grabado.
• BevelBorder: Un borde biselado que puede dar la apariencia de relieve o hundido.
• TitledBorder: Un borde con un título.
• CompoundBorder: Un borde compuesto que permite combinar dos bordes en uno.

JFrame¶

JFrame es una clase fundamental en el paquete Swing de Java, utilizada para crear ventanas con una interfaz gráfica de usuario. Un JFrame es una ventana de nivel superior que puede contener otros componentes Swing, como botones, etiquetas, paneles y más. Proporciona una ventana con una barra de título, bordes y botones estándar para minimizar, maximizar y cerrar la ventana.

Dispone del método setDefaultCloseOperation(int operation) que permite definir que operación hacer cuando se hace clic en el botón de cerrar ventana. Entre las diferentes opciones tenemos:

• 0. No hace nada al cerrar. Se puede indicar fácilmente haciendo uso de la variable estática DO_NOTHING_ON_CLOSE de la clase JFrame.
• 1. Oculta la ventana. Es la opción por defecto, y está representada por la variable estática HIDE_ON_CLOSE.
• 2. Libera al cerrar. Está representada por DISPOSE_ON_CLOSE.
• 3. Cierra la ventana. Está representada por EXIT_ON_CLOSE.

Veamos un ejemplo:

public class JFrameExample {
    public void show() {
        JFrame frame = new JFrame("JFrame Example");
        frame.setSize(200, 200);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setVisible(true);
    }

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

ContentPane¶

ContentPane es el contenedor por defecto para los componentes de alto nivel como JFrame, en el cual se agregan los componentes que se desean mostrar en la ventana.

A través del método getContentPane() se puede acceder a dicho contenedor. A diferencia del Frame de AWT, en Swing para agregar componentes a un JFrame es necesario realizarlo a través de dicho contenedor. Por lo que, a través del método getContentPane() se puede acceder a él, y con el método add(component) de dicho contenedor, se añaden los componentes.

ContentPane utiliza un layout para posicionar los componentes. Por defecto, se utiliza BorderLayout, pero puede ser cambiado usando el método setLayout(layout).

Además, este tipo de contenedor dispone del método remove(component) que elimina el componente del contenedor.

Se puede cambiar el contenedor de un JFrame a través del método setContentPane(pane) añadiendo el contenedor que se desee.

Componentes de botones¶

• JButton: Representa un botón que se puede presionar para realizar una acción.

  JButton button = new JButton("Click Me");
  

• JCheckBox: Representa una casilla de verificación que se puede seleccionar o deseleccionar.

  JCheckBox checkBox = new JCheckBox("Accept Terms");
  

• JRadioButton: Representa un botón de opción que se puede seleccionar como parte de un grupo de botones de opción. La clase ButtonGroup agrupa los botones de un opción en un grupo, para que solo puedan ser elegido uno.

  JRadioButton radioButton1 = new JRadioButton("Option 1");
  JRadioButton radioButton2 = new JRadioButton("Option 2");
  ButtonGroup group = new ButtonGroup();
  group.add(radioButton1);
  group.add(radioButton2);
  

Componentes de Etiquetas y Áreas de Texto¶

• JLabel: Representa una etiqueta que puede mostrar texto o iconos.

  JLabel label = new JLabel("Hello, World!");
  

• JTextField: Representa un campo de texto de una sola línea donde el usuario puede ingresar datos.

  JTextField textField = new JTextField(20);
  

• JTextArea: Representa un área de texto de múltiples líneas.

  JTextArea textArea = new JTextArea(5, 20);
  

Componentes de Listas¶

• JList: Representa una lista de elementos.

String[] data = {"Item 1", "Item 2", "Item 3"};
JList<String> list = new JList<>(data);

Listado componentes¶

En Swing, existen una gran variedad de componentes.

Componentes de tablas¶

JTable es un componente de la biblioteca Swing que permite mostrar datos en forma de una tabla. Es altamente personalizable y puede mostrar datos en forma de filas y columnas. Es especialmente útil cuando necesitas mostrar grandes cantidades de datos en una interfaz de usuario de manera organizada y estructurada.

El constructor recibe una matriz con los datos y un array con el nombre de las columnas.

Algunos de sus métodos más importantes son:

• void setModel(TableModel dataModel): Establece el modelo de datos para la tabla. El modelo debe implementar la interfaz TableModel, como DefaultTableModel o AbstractTableModel.
• void setSelectionMode(int selectionMode): Establece el modo de selección de celdas. Los valores posibles son ListSelectionModel.SINGLE_SELECTION, ListSelectionModel.SINGLE_INTERVAL_SELECTION y ListSelectionModel.MULTIPLE_INTERVAL_SELECTION.
• void setShowGrid(boolean showGrid):Establece si se debe mostrar o no la cuadrícula que separa las celdas.
• void setAutoResizeMode(int mode): Establece el modo de ajuste automático del ancho de las columnas. Los valores posibles son JTable.AUTO_RESIZE_OFF, JTable.AUTO_RESIZE_NEXT_COLUMN, JTable.AUTO_RESIZE_SUBSEQUENT_COLUMNS y JTable.AUTO_RESIZE_LAST_COLUMN.
• void setRowHeight(int row, int rowHeight): Establece la altura de una fila específica.
• void setValueAt(Object value, int row, int column): Establece el valor de una celda en la posición especificada.
• void addRow(Object[] rowData): Agrega una nueva fila con los datos especificados al final del modelo de datos de la tabla.
• void removeRow(int row): Elimina la fila en la posición especificada del modelo de datos de la tabla.
• int getSelectedRow():Devuelve el índice de la fila seleccionada. Si no hay ninguna fila seleccionada, devuelve -1.
• Object getValueAt(int row, int column):Devuelve el valor de la celda en la posición especificada

Veamos un ejemplo:

public class JTableExample {
    public void show() {
        JFrame frame = new JFrame("Ejemplo de JTable");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        Object[][] data = {
                {"John", 25, "Developer"},
                {"Alice", 30, "Designer"},
                {"Bob", 35, "Manager"}
        };

        String[] columnNames = {"Nombre", "Edad", "Cargo"};

        JTable table = new JTable(data, columnNames);
        frame.getContentPane().add(table);


        frame.setSize(400, 300);
        frame.setLocationRelativeTo(null); // Centrar la ventana en la pantalla
        frame.setVisible(true);
    }

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

Para lograr que una celda ocupe dos filas en una JTable, necesitamos personalizar el renderizado de esa celda específica. Podemos hacerlo creando una clase personalizada que extienda JTable y sobrescriba el método prepareRenderer() para manejar el renderizado de la celda.

Proyecto Components¶

public class ComponentsExample {
    public void show() {
        // Crear el JFrame
        JFrame frame = new JFrame("Ejemplo de Componentes Swing");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        // Crear un JPanel para contener los componentes
        JPanel panel = new JPanel();
        panel.setLayout(new GridLayout(4, 2)); // 4 filas, 2 columnas

        // Crear etiquetas
        JLabel nameLabel = new JLabel("Nombre:");
        JLabel ageLabel = new JLabel("Edad:");

        // Crear campos de texto
        JTextField nameField = new JTextField(20);
        JTextField ageField = new JTextField(5);

        // Crear un área de texto
        JTextArea descriptionArea = new JTextArea(5, 20);
        descriptionArea.setLineWrap(true);
        JScrollPane scrollPane = new JScrollPane(descriptionArea);

        // Crear botones
        JButton submitButton = new JButton("Enviar");
        JButton clearButton = new JButton("Limpiar");

        // Añadir componentes al panel
        panel.add(nameLabel);
        panel.add(nameField);
        panel.add(ageLabel);
        panel.add(ageField);
        panel.add(new JLabel("Descripción:"));
        panel.add(scrollPane);
        panel.add(submitButton);
        panel.add(clearButton);

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

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

    }

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

Menús¶

En Java Swing, la clase JMenu representa un componente que se utiliza para crear menús desplegables en una interfaz de usuario. Un JMenu puede contener elementos de menú, como opciones, submenús u otros componentes Swing.

• Elementos de Menú: Puedes añadir elementos de menú, como JMenuItem, a un JMenu para crear las opciones que se mostrarán cuando el usuario haga clic en él.
• Submenús: También puedes añadir otros JMenu como elementos de un JMenu, lo que te permite crear submenús y organizar las opciones en una jerarquía.
• Atajos de Teclado: Los elementos de menú pueden tener atajos de teclado asociados, permitiendo al usuario activar la opción del menú utilizando combinaciones de teclas.
• Iconos: Puedes añadir iconos a los elementos de menú para proporcionar una representación visual de las opciones.
• Eventos de Acción: Puedes registrar ActionListeners en los elementos de menú para manejar eventos de acción cuando el usuario selecciona una opción del menú.

Um JMenuBar es una clase que representa un menu bar de nuestra aplicación. A esta clase se le pueden añadir los diferentes menús de JMenu. La clase JMenuItem representan los items de un menú de JMenu. Veamos un ejemplo:

public class MenuExample {

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

        // Crear la barra de menú
        JMenuBar menuBar = new JMenuBar();

        // Crear el menú "Archivo" y sus elementos de menú
        JMenu fileMenu = new JMenu("Archivo");
        JMenuItem newItem = new JMenuItem("Nuevo");
        JMenuItem openItem = new JMenuItem("Abrir");
        JMenuItem saveItem = new JMenuItem("Guardar");
        JMenuItem exitItem = new JMenuItem("Salir");

        // Agregar elementos de menú al menú "Archivo"
        fileMenu.add(newItem);
        fileMenu.add(openItem);
        fileMenu.add(saveItem);
        fileMenu.addSeparator(); // Separador
        fileMenu.add(exitItem);

        // Crear el menú "Ayuda" y sus elementos de menú
        JMenu helpMenu = new JMenu("Ayuda");
        JMenuItem aboutItem = new JMenuItem("Acerca de");

        // Agregar elementos de menú al menú "Ayuda"
        helpMenu.add(aboutItem);

        // Agregar menús a la barra de menú
        menuBar.add(fileMenu);
        menuBar.add(helpMenu);

        // Configurar el ActionListener para el elemento de menú "Salir"
        exitItem.addActionListener(e -> System.exit(0));

        // Agregar la barra de menú al JFrame
        frame.setJMenuBar(menuBar);

        // 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 MenuExample().show();
    }
}

Se le puede añadir un menú a un componente haciendo uso de la clase JPopMenú, que simula un menú que suele ser mostrador a clicar sobre el componente con el botón derecho del ratón. Veamos un ejemplo:

public class PopMenuExample {
    public void show() {

        // Crear un JFrame
        JFrame frame = new JFrame("Ejemplo de Menú en Componente");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        // Crear un botón
        JButton button = new JButton("Haz clic aquí");

        // Crear un JPopupMenu con elementos de menú
        JPopupMenu popupMenu = new JPopupMenu();
        JMenuItem menuItem1 = new JMenuItem("Opción 1");
        JMenuItem menuItem2 = new JMenuItem("Opción 2");
        popupMenu.add(menuItem1);
        popupMenu.add(menuItem2);

        // Asociar el JPopupMenu al botón
        button.setComponentPopupMenu(popupMenu);

        // Añadir el botón al JFrame
        frame.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 PopMenuExample().show();
    }
}