Creando un JTextField con Mascara en NetBeans [números, letras y más...]

Hace algún tiempo, estuve intentando crear un JTextField que me restringiera la entrada de caracteres utilizando el IDE NetBeans. Por ejemplo que sólo se pudieran ingresar números, letras, o cualquier otro tipo de caracteres que yo quisiera.

A continuación comparto con ustedes la solución que le hallé a mi problema.

 Los pasos a seguir son los siguientes:

  1. Implementamos una clase que herede de JTextField.

  2. Incluimos dos arreglos  que van a contener los caracteres y teclas que queremos que nuestro campo de texto valide.

  3. Sustituimos el método processKeyEvent de la clase  JTextField. En este metodo se va a hacer uso de los dos arreglos mencionados anteriormente. Si la tecla o el caracter es válido (incluido en los arreglos), entonces el campo de texto va a procesar el evento del teclado (super.processKeyEvent(e)); en caso contrario lo va a omitir (e.consume())

En este ejemplo, vamos a permitir que el campo de texto procese eventos de teclado que incluyan los siguientes caracteres: '#', '&','%' y el caracter del espacio (' '). Igualmente los eventos correspondientes a las teclas de direccion "derecha", "izquierda", para poder desplazarnos en el texto,  y el "backspace" para borrar. Finalmente va a procesar cualquier digito (0-9).

A continuación les presento el código fuente de los tres pasos anteriores:

import java.awt.event.KeyEvent;
import javax.swing.JTextField;

public class FormattedTextField extends JTextField {

    private int [] keyCodeArray = {KeyEvent.VK_RIGHT,KeyEvent.VK_LEFT,KeyEvent.VK_BACK_SPACE};
    private char [] charArray = {'#','&','%',' '};

    public FormattedTextField() {
    }

    public void processKeyEvent(KeyEvent e) {
        int keyCode = e.getKeyCode();
        char character=e.getKeyChar();
        if (containsInteger(keyCode)||Character.isDigit(e.getKeyChar())||containsCharacter(character)) {
            super.processKeyEvent(e);                        
        } else {
            e.consume();
        }
    }
    
    private boolean containsInteger(int keyCode){
        for (int i = 0; i < keyCodeArray.length; i++) {
            int code = keyCodeArray[i];
            if (keyCode==code) {
                return true;
            }
        }
        return false;
    }
    
    private boolean containsCharacter(char character){
        for (int i = 0; i < charArray.length; i++) {
            Character c = charArray[i];
            if (c.equals(character)) {
                return true;
            }
        }
        return false;
    }
}

Continuando con el procedimiento para integrar nuestro campo de texto:

   4. En el IDE NetBeans arrastran un sólo componente JTextField desde la paleta. Así requieran más de un campo de texto con la mascara, yo recomiendo que realicen el proceso que a continución se describe con uno sólo. Más adelante explicaré la razón.

Después, para que pueda ser agregada la mascara, deben personalizar el código que genera el IDE para inicializar el objeto de tipo JTextField. Para ello deben seguir los siguientes pasos:

Tener en cuenta que el NetBeans lo estoy usando en el idioma inglés.

   a. Clic derecho sobre el JTextField que arrastraron desde la paleta y seleccionan la opción "Customize Code":

   b. Luego, en el combo que dice "default code", cambiamos la opción por "custom creation":

   c. Después de que se ha seleccionado la opción "custom creation" podremos inicializar el objeto a    nuestro gusto, en este caso inicializamos el campo de texto con un objeto de tipo "FormattedTextField()", reemplazando el fragmento de linea: new javax.swing.JTextField(); 
por este otro: new FormattedTextField();

 Esto es posible debido a que la clase "FormattedTextField" hereda de JTextField, de modo que en última instancia estamos creando un objeto JTextField, que es el tipo de objeto con el que el IDE declara el campo de texto.

Eso es todo!!! Ya podemos ejecutar nuestra aplicación...

Ahora sí. Si requieren más campos de texto del tipo que hemos creado ("FormattedTextField"), no es necesario repetir los últimos pasos. En vez de arrastrar más JTextField desde la paleta, sólo es cuestión de que demos clic encima del campo de texto al que le hemos añadido la máscara, luego lo copiamos (ctrl + c), lo pegamos (ctrl + v) y por último lo arrastramos hasta la posición deseada. De esta forma podremos añadir todos los campos de texto con máscara, las veces que queramos. 

Importante: En este caso estamos dando por sentado que la clase "FormattedTextField" esta en el mismo paquete que la ventana (JFrame), por eso, en el momento de inicializar el objeto, no hubo necesidad de incluir nombres de paquetes. En el caso de que, por ejemplo, la clase "FormattedTextField" se encuentre en el paquete "mypackage1.mypackage2" (y la ventana en otro distinto), este se debe incluir en la inicializacion del objeto:

Osea que en vez de haber puesto: new FormattedTextField();
Se debería poner en tal caso: new mypackage1.mypackage2.FormattedTextField();

En caso de necesitar entrada de solo letras, excluyendo los números:

Unicamente cambiamos el fragmento de linea en el metodo "processKeyEvent" que dice:  Character.isDigit  por este otro: Character.isLetter

En caso de necesitar entrada de ambos tipos de caracteres, letras y números:
Unicamente añadimos al fragmento de linea en el metodo "processKeyEvent" que dice:   Character.isDigit(ev.getKeyChar()) el operador lógico "or" (||) con la validación de letras: || Character.isLetter(ev.getKeyChar()), de esta manera:

Character.isDigit(ev.getKeyChar())||Character.isLetter(ev.getKeyChar()).

Espero les haya sido útil este tip y espero sus comentarios!!!  

Hasta pronto!!!