Elementos de texto en interfaces gráficas con Swing

En esta sección, aprenderás a utilizar componentes de texto en interfaces gráficas utilizando la biblioteca Swing de Java. Los componentes de texto son esenciales para interactuar con los usuarios, ya que permiten la entrada y visualización de información.

Componentes de texto en Swing

Swing ofrece varios componentes de texto que puedes utilizar en tus interfaces gráficas:

• JLabel: Se utiliza para mostrar texto estático en la interfaz. No es editable por el usuario.
• JTextField: Permite la entrada de una sola línea de texto. Es útil para formularios y campos de entrada.
• JTextArea: Permite la entrada de múltiples líneas de texto. Es ideal para áreas de comentarios o descripciones largas.
• JPasswordField: Similar a JTextField, pero oculta el texto ingresado, lo que es útil para contraseñas.
• JFormattedTextField: Permite la entrada de texto con un formato específico, como fechas o números.

JLabel

El componente JLabel se utiliza para mostrar texto estático en la interfaz gráfica. Aquí tienes un ejemplo de cómo crear y utilizar un JLabel:

JLabel label = new JLabel("Hola, Mundo!");
label.setFont(new Font("Arial", Font.PLAIN, 16));
label.setForeground(Color.BLUE);
panel.add(label);

Ahora analicemos cada línea del código:

1. JLabel label = new JLabel("Hola, Mundo!");: Crea un nuevo objeto JLabel con el texto "Hola, Mundo!".
2. label.setFont(new Font("Arial", Font.PLAIN, 16));: Establece la fuente del texto a Arial, con estilo normal y tamaño 16.
3. label.setForeground(Color.BLUE);: Cambia el color del texto a azul.
4. panel.add(label);: Agrega el JLabel al panel de la interfaz gráfica.

Así mismo, puedes personalizar otros aspectos del JLabel, como el fondo, la alineación y el borde. Mediante estos métodos, puedes adaptar el JLabel a las necesidades de tu interfaz gráfica.

Estos métodos te permiten personalizar el componente JLabel y el resto de los componentes de texto según tus necesidades.

JTextField

El componente JTextField permite la entrada de una sola línea de texto. Aquí tienes un ejemplo de cómo crear y utilizar un JTextField:

JTextField textField = new JTextField(20);
textField.setFont(new Font("Arial", Font.PLAIN, 14));
textField.setForeground(Color.BLACK);
panel.add(textField);

JTextArea

El componente JTextArea permite la entrada de múltiples líneas de texto. Aquí tienes un ejemplo de cómo crear y utilizar un JTextArea:

JTextArea textArea = new JTextArea(5, 20);
textArea.setFont(new Font("Arial", Font.PLAIN, 14));
textArea.setLineWrap(true);
textArea.setWrapStyleWord(true);
JScrollPane scrollPane = new JScrollPane(textArea);
panel.add(scrollPane);

JPasswordField

El componente JPasswordField es similar a JTextField, pero oculta el texto ingresado, lo que es útil para contraseñas. Aquí tienes un ejemplo de cómo crear y utilizar un JPasswordField:

JPasswordField passwordField = new JPasswordField(20);
passwordField.setFont(new Font("Arial", Font.PLAIN, 14));
panel.add(passwordField);

JFormattedTextField

El componente JFormattedTextField permite la entrada de texto con un formato específico, como fechas o números. Aquí tienes un ejemplo de cómo crear y utilizar un JFormattedTextField para ingresar una fecha:

import javax.swing.text.MaskFormatter;
MaskFormatter dateFormatter = new MaskFormatter("##/##/####");
JFormattedTextField formattedTextField = new JFormattedTextField(dateFormatter);
formattedTextField.setColumns(10);
formattedTextField.setFont(new Font("Arial", Font.PLAIN, 14));
panel.add(formattedTextField);

Sin embargo, ten en cuenta que MaskFormatter puede lanzar una excepción ParseException, por lo que debes manejarla adecuadamente.

Así mismo, podemos crear un formateador para números:

import javax.swing.text.NumberFormatter;
import java.text.NumberFormat;
NumberFormat numberFormat = NumberFormat.getIntegerInstance();
NumberFormatter numberFormatter = new NumberFormatter(numberFormat);
numberFormatter.setValueClass(Integer.class);
numberFormatter.setMinimum(0);
numberFormatter.setMaximum(100);
JFormattedTextField numberField = new JFormattedTextField(numberFormatter);
numberField.setColumns(10);
numberField.setFont(new Font("Arial", Font.PLAIN, 14));
panel.add(numberField);

Oh aún mejor, crear una clase que extienda de DefaultFormatter para crear un formateador personalizado:

import javax.swing.text.DefaultFormatter;
import java.text.ParseException;

public class UpperCaseFormatter extends DefaultFormatter {
    @Override
    public Object stringToValue(String text) throws ParseException {
        if(text != null) {
            return text.toUpperCase();
        }else {
            throw new ParseException("Formato inválido", 0);
        }
    }
}

Las expresiones regulares

Una expresión regular (regex) es una secuencia de caracteres que forma un patrón de búsqueda. En Java, las expresiones regulares se utilizan para buscar y manipular cadenas de texto. Puedes utilizar expresiones regulares para validar la entrada del usuario en componentes de texto como JTextField o JFormattedTextField. Aquí tienes un ejemplo de cómo utilizar una expresión regular para validar una dirección de correo electrónico en un JTextField:

JTextField emailField = new JTextField(20);
emailField.setInputVerifier(new InputVerifier() {
    @Override
    public boolean verify(JComponent input) {
        String emailPattern = "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,6}$";
        String email = ((JTextField) input).getText();
        return email.matches(emailPattern);
    }
});
panel.add(emailField);

Por otro lado, una forma avanzada de validar la entrada de texto en un JFormattedTextField es utilizando expresiones regulares. Puedes crear un formateador personalizado que utilice una expresión regular para validar el texto ingresado. Aquí tienes un ejemplo:

import javax.swing.text.DefaultFormatter;
import java.text.ParseException;
import java.util.regex.Pattern;

public class RegexFormatter extends DefaultFormatter {
    private Pattern pattern;

    public RegexFormatter(String regex) {
        this.pattern = Pattern.compile(regex);
    }

    @Override
    public Object stringToValue(String text) throws ParseException {
        if(pattern.matcher(text).matches()) {
            return text;
        } else {
            throw new ParseException("Formato inválido", 0);
        }
    }
}

Luego, puedes utilizar este formateador en un JFormattedTextField de la siguiente manera:

RegexFormatter emailFormatter = new RegexFormatter("^[A-Za-z0-9+_.-]+@(.+)$");
JFormattedTextField emailField = new JFormattedTextField(emailFormatter);
emailField.setColumns(20);
emailField.setFont(new Font("Arial", Font.PLAIN, 14));
panel.add(emailField);

Aquí puedes consultar más sobre las expresiones regulares en Java: Documentación de Java sobre Expresiones Regulares.

Tablas de expresiones regulares comunes

Conclusión

Con estos componentes de texto y sus respectivas personalizaciones, podrás crear interfaces gráficas interactivas y funcionales utilizando Swing en Java. Experimenta con diferentes configuraciones y estilos para adaptarlos a las necesidades de tu aplicación.