Componentes de Texto en Swing

Componentes de texto

`JLabel`

JLabel es un componente de interfaz utilizado para mostrar texto o imágenes no editables.

Se usa para proporcionar etiquetas descriptivas a otros componentes, mostrar información estática o imágenes simples.

Uso

Se crea una instancia de JLabel con texto y/o un icono.
Se puede configurar su alineación, fuente y otras propiedades.
Se añade a un contenedor (como JPanel o JFrame).

Ejemplo práctico:

1
import javax.swing.*;
2
import java.awt.*;
3

4
public class EjemploJLabel {
5
    private JFrame frame;
6

7
    public EjemploJLabel() {
8
        inicializarComponentes();
9
    }
10

11
    private void inicializarComponentes() {
12
        frame = new JFrame("Ejemplo JLabel");
13
        frame.setSize(300, 200);
14
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
15
        frame.setLayout(new FlowLayout());
16
        frame.setLocationRelativeTo(null); // Centrar la ventana en la pantalla
17

18
        // JLabel simple
19
        JLabel labelSimple = new JLabel("Etiqueta Simple");
20
        frame.add(labelSimple);
21

22
        // JLabel con fuente personalizada
23
        JLabel labelConFuente = new JLabel("Etiqueta con Fuente");
24
        labelConFuente.setFont(new Font("Arial", Font.BOLD, 16));
25
        frame.add(labelConFuente);
26

27
        // JLabel con HTML
28
        JLabel labelHTML = new JLabel("<html><b>Etiqueta</b> con <i>formato</i> HTML</html>");
29
        frame.add(labelHTML);
30
    }
31

32
    public void mostrar() {
33
        frame.setVisible(true);
34
    }
35

36
    public static void main(String[] args) {
37
        SwingUtilities.invokeLater(() -> {
38
            EjemploJLabel app = new EjemploJLabel();
39
            app.mostrar();
40
        });
41
    }
42
}

Información:

Creamos tres tipos diferentes de JLabel:

Una etiqueta simple con texto plano.
Una etiqueta con una fuente personalizada (Arial, negrita, tamaño 16).
Una etiqueta que utiliza HTML para formatear el texto.

`JTextField`

JTextField es un componente que permite al usuario ingresar una línea de texto.

Se utiliza para recoger entradas cortas del usuario, como nombres, direcciones de correo electrónico o cualquier otro dato de una sola línea.

Uso

Se crea una instancia de JTextField, opcionalmente especificando el ancho en columnas.
Se puede configurar el texto inicial, el tipo de contenido permitido, y añadir listeners para eventos.
Se añade a un contenedor.

Ejemplo:

1
import javax.swing.*;
2
import java.awt.*;
3
import java.awt.event.ActionEvent;
4
import java.awt.event.ActionListener;
5

6
public class EjemploJTextField {
7
    private JFrame frame;
8
    private JTextField campoTexto;
9
    private JLabel etiquetaResultado;
10

11
    public EjemploJTextField() {
12
        inicializarComponentes();
13
    }
14

15
    private void inicializarComponentes() {
16
        frame = new JFrame("Ejemplo JTextField");
17
        frame.setSize(300, 150);
18
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
19
        frame.setLayout(new FlowLayout());
20
        frame.setLocationRelativeTo(null); // Centrar la ventana en la pantalla
21

22
        // Crear y configurar JTextField
23
        campoTexto = new JTextField(20);
24
        frame.add(new JLabel("Nombre:"));
25
        frame.add(campoTexto);
26

27
        // Botón para procesar el texto
28
        JButton boton = new JButton("Saludar");
29
        frame.add(boton);
30

31
        // Etiqueta para mostrar el resultado
32
        etiquetaResultado = new JLabel("Resultado: ");
33
        frame.add(etiquetaResultado);
34

35
        // Añadir acción al botón
36
        boton.addActionListener(new ActionListener() {
37
            @Override
38
            public void actionPerformed(ActionEvent e) {
39
                String nombre = campoTexto.getText();
40
                etiquetaResultado.setText("Resultado: Hola, " + nombre + "!");
41
            }
42
        });
43
    }
44

45
    public void mostrar() {
46
        frame.setVisible(true);
47
    }
48

49
    public static void main(String[] args) {
50
        SwingUtilities.invokeLater(() -> {
51
            EjemploJTextField app = new EjemploJTextField();
52
            app.mostrar();
53
        });
54
    }
55
}

Información:

Creamos un JTextField con un ancho de 20 columnas.
Añadimos un botón que, al ser presionado, lee el texto del JTextField.
Mostramos un saludo personalizado en una etiqueta basado en el texto ingresado.

`JTextArea`

JTextArea es un componente que permite al usuario ingresar o mostrar múltiples líneas de texto.

Se utiliza para entradas o visualizaciones de texto más largas, como comentarios, descripciones o logs.

Uso

Se crea una instancia de JTextArea, opcionalmente especificando el número de filas y columnas.
Se pueden configurar propiedades como el ajuste de línea o la editabilidad.
Generalmente se coloca dentro de un JScrollPane para manejar texto extenso.
Se añade a un contenedor.

Ejemplo:

1
import javax.swing.*;
2
import java.awt.*;
3

4
public class EjemploJTextArea {
5
    private JFrame frame;
6
    private JTextArea areaTexto;
7

8
    public EjemploJTextArea() {
9
        inicializarComponentes();
10
    }
11

12
    private void inicializarComponentes() {
13
        frame = new JFrame("Ejemplo JTextArea");
14
        frame.setSize(400, 300);
15
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
16
        frame.setLayout(new BorderLayout());
17
        frame.setLocationRelativeTo(null); // Centrar la ventana en la pantalla
18

19
        // Crear y configurar JTextArea
20
        areaTexto = new JTextArea(10, 30);
21
        areaTexto.setLineWrap(true);
22
        areaTexto.setWrapStyleWord(true);
23
        JScrollPane scrollPane = new JScrollPane(areaTexto);
24
        frame.add(scrollPane, BorderLayout.CENTER);
25

26
        // Botón para añadir texto
27
        JButton botonAñadir = new JButton("Añadir Texto");
28
        frame.add(botonAñadir, BorderLayout.SOUTH);
29

30
        botonAñadir.addActionListener(e -> {
31
            areaTexto.append("Nueva línea de texto añadida.\n");
32
        });
33
    }
34

35
    public void mostrar() {
36
        frame.setVisible(true);
37
    }
38

39
    public static void main(String[] args) {
40
        SwingUtilities.invokeLater(() -> {
41
            EjemploJTextArea app = new EjemploJTextArea();
42
            app.mostrar();
43
        });
44
    }
45
}

Información:

Creamos un JTextArea con 10 filas y 30 columnas.
Activamos el ajuste de línea (lineWrap) para que continúe debajo, y el ajuste por palabras (wrapStyleWord) para que no corte las palabras en los bordes al continuar debajo.
Colocamos el JTextArea dentro de un JScrollPane para manejar contenido extenso.
Añadimos un botón que, al ser presionado, agrega una nueva línea de texto al JTextArea.

JPasswordField

JPasswordField es un componente especializado similar a JTextField, pero diseñado para la entrada segura de contraseñas.

Se utiliza para recoger contraseñas o cualquier otro texto sensible que no deba ser visible mientras se escribe.

Uso

Se crea una instancia de JPasswordField, similar a JTextField.
Se puede configurar el carácter de enmascaramiento (por defecto es ’•’).
Se utiliza el método getPassword() para obtener la contraseña como un array de caracteres, en lugar de getText().

Ejemplo:

1
import javax.swing.*;
2
import java.awt.*;
3
import java.util.Arrays;
4
import java.awt.event.ActionEvent;
5
import java.awt.event.ActionListener;
6

7
public class EjemploJPasswordField {
8
    private JFrame frame;
9
    private JPasswordField campoPassword;
10
    private JToggleButton toggleButton;
11

12
    private char defaultEchoChar;
13

14
    public EjemploJPasswordField() {
15
        inicializarComponentes();
16
    }
17

18
    private void inicializarComponentes() {
19
        frame = new JFrame("Ejemplo JPasswordField");
20
        frame.setSize(400, 120);
21
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
22
        frame.setLayout(new FlowLayout());
23
        frame.setLocationRelativeTo(null); // Centrar la ventana en la pantalla
24

25
        // Crear y configurar JPasswordField
26
        campoPassword = new JPasswordField(20);
27
        defaultEchoChar = campoPassword.getEchoChar();
28

29
        frame.add(new JLabel("Contraseña:"));
30
        frame.add(campoPassword);
31

32
        toggleButton = new JToggleButton("Ver");
33
        toggleButton.setFocusPainted(false);
34

35
        toggleButton.addActionListener(new ActionListener() {
36
            @Override
37
            public void actionPerformed(ActionEvent e) {
38
                if (toggleButton.isSelected()) {
39
                    campoPassword.setEchoChar((char) 0);
40
                } else {
41
                    campoPassword.setEchoChar(defaultEchoChar);
42
                }
43
            }
44
        });
45
        frame.add(toggleButton);
46

47
        // Botón para verificar la contraseña
48
        JButton botonVerificar = new JButton("Verificar");
49
        frame.add(botonVerificar);
50

51
        botonVerificar.addActionListener(e -> {
52
            char[] password = campoPassword.getPassword();
53
            if (Arrays.equals(password, "passwordseguro".toCharArray())) {
54
                JOptionPane.showMessageDialog(frame, "Contraseña correcta!");
55
            } else {
56
                JOptionPane.showMessageDialog(frame, "Contraseña incorrecta.");
57
            }
58
            // Limpiar la contraseña de la memoria
59
            Arrays.fill(password, '0');
60
        });
61
    }
62

63
    public void mostrar() {
64
        frame.setVisible(true);
65
    }
66

67
    public static void main(String[] args) {
68
        SwingUtilities.invokeLater(() -> {
69
            EjemploJPasswordField app = new EjemploJPasswordField();
70
            app.mostrar();
71
        });
72
    }
73
}

Información:

Creación del JPasswordField:
```
1
campoPassword = new JPasswordField(20);
```
Creamos un JPasswordField con un ancho de 20 columnas. Este componente mostrará asteriscos o puntos en lugar de los caracteres reales que el usuario escribe.
Añadir componentes al frame:
```
1
frame.add(new JLabel("Contraseña:"));
2
frame.add(campoPassword);
```
Añadimos una etiqueta para indicar el propósito del campo y luego el JPasswordField.
Manejo de eventos:
```
1
botonVerificar.addActionListener(e -> {
2
    // ... código de verificación ...
3
});
```
Añadimos un ActionListener al botón para manejar el evento de clic. Trabajamos de manera similar con toggleButton para tener la posibilidad de mostrar u ocultar la contraseña.
Obtener y verificar la contraseña:
```
1
char[] password = campoPassword.getPassword();
2
if (Arrays.equals(password, "secreto".toCharArray())) {
3
    // ...
4
}
```
Utilizamos getPassword() en lugar de getText(). Este método devuelve un array de caracteres, que es más seguro que una String porque puede ser sobrescrito después de su uso.
Limpiar la contraseña de la memoria:
```
1
Arrays.fill(password, '0');
```
Es una buena práctica de seguridad sobrescribir el array de caracteres de la contraseña después de usarlo. Esto asegura que la contraseña no permanezca en la memoria más tiempo del necesario.
Mostrar resultados: Utilizamos JOptionPane.showMessageDialog() para mostrar si la contraseña es correcta o no.

Este ejemplo nos muestra cómo usar JPasswordField de manera segura, incluyendo la obtención de la contraseña como un array de caracteres y la limpieza de la memoria después de su uso. Es importante notar que en una aplicación real, nunca deberíamos comparar contraseñas directamente con un string hardcodeado como “passwordseguro”. En cambio, deberíamos usar técnicas de hashing y comparar los hashes.