Ejemplos con JTextField

De ChuWiki
Saltar a navegación, buscar
Vamos a ver aquí algunos ejemplos básicos con JTextField y cómo hacer algunas cosas
con este componente.

Contenido
[ocultar]
• 1 Instanciar el JTextField
• 2 Poner y leer texto en el JTextField
• 3 Poner y leer números en el JTextField
• 4 Deshabilitar el JTextField
• 5 Eventos en el JTextField
○ 5.1 ActionEvent y LosingFocus

Instanciar el JTextField
Instanciar un JTextField es sencillo, basta hacer un new. Sin embargo, un JTextField
coge por defecto el tamaño del texto que tiene dentro. Si lo dejamos vacío y lo metemos
en un panel, este JTextField por defecto tendrá un ancho cercano a los cero pixels. Por
ello, es mejor usar el constructor que tiene de parámetro un entero, correspondiente al
número de caracteres que queremos visibles en el JTextField
// JTextField con ancho suficiente para 20 caracteres
JTextField textField = new JTextField(20);
Hay que tener en cuenta dos cosas importantes:
• Estos 20 caracteres no son exactos. En función de la fuente de letra usada y de
las letras en concreto que pongamos, puede haber más o menos visibles. Por
ejemplo, si llenamos el JTextField de i latina, posiblemente quepan más de 20,
mientras que si lo llenamos de emes m, entonces cabrán menos.
• En ningún caso 20 es el límite máximos de caracteres que se pueden escribir,
podemos meter más. 20 es símplemente el ancho en pantalla del JTextField.

Poner y leer texto en el JTextField

Para meter texto en el JTextField desde código, usamos el método setText(). Si
queremos vaciar el contenido, usaremos también setText(), pero pasando una cadena
vacía ""
textField.setText("Hola");
// vaciar el JTextField
textField.setText("");
Para recuperar el texto, usaremos el método getText(). Si el JTextField está vacío, este
método nos devolverá la cadena vacía ""
String texto = textField.getText();
if ("".equals(texto))
System.out.println("El JTextField está vacío");

Poner y leer números en el JTextField

El JTextField sólo admite y devuelve String, por lo que si queremos meter u obtener
números, debemos hacer fuera la conversión. Para meter un número se puede hacer así
int valor = 33;
textField.setText(Integer.toString(valor));
Para obtener el número, puesto que el usuario puede escribir lo que le de la gana,
incluidas letras, debemos además hacer una comprobación
int valor;
String texto = textField.getText();
try {
valor = Integer.parseString(texto);
}
catch (NumberFormatException e) {
System.err.println("No se puede convertir a numero");
e.printStackTrace();
}

De la misma forma, si quisieramos obtener float, double, etc, usaríamos las clase Float,
Double, etc en vez de Integer.
De todas formas, para leer y escribir números en un JTextField es mejor usar un
JFormattedTextField. El siguiente ejemplo muestra como usarlo para enteros
// En el constructor pasamos el tipo de valor que queremos usar, en
este
// caso un Integer
JFormattedTextField jftf = new JFormattedTextField(new Integer(3));
...
jftf.setValue(new Integer(44)); // Le pasamos un 44
...
Integer valorRecogido = (Integer)jftf.getValue(); // recogemos el
valor escrito.
De esta forma nos ahorramos hacer nosotros las conversiones. Podemos usar igualmente
las clases Float, Double, Long, Date, etc y en general cualquier clase que tenga un
constructor que admita un String como parámetro (necesario para getValue()) y que
tenga método toString() (necesario para setValue()). ¿Por qué son estos métodos
necesarios?
• Cuando llamamos a getValue(), se recogerá el String del JFormattedTextField y
ese String se tratará de usar en el constructor de la clase a devolver. Por ejemplo,
si estamos usando Integer y el usuario escribe un 44, el método getValue()
intentará hacer algo parecido a esto
return new Integer("44");
• Cuando llamamos a setValue(unDato), se llamará al método toString() de
unDato y eso se meterá en el JFormattedTextField para que sea visible.
Deshabilitar el JTextField
Para deshabilitar un JTextField tenemos dos posibles métodos: setEditable() y
setEnabled()
El segundo método, setEnabled(), hace que no se pueda modificar el contenido del
JTextField, pero también lo pone de color gris, por lo que quizás el texto no se vea bien.
El primer método, setEditable(), hace lo mismo, pero no lo pone gris. El JTextField
tendrá toda la apariencia de ser editable, pero no se podrá modificar su contenido.

Eventos en el JTextField
ActionEvent y LosingFocus
Suele ser habitual querer enterarnos cuándo el usuario ha terminado de escribir en el
JTextField, bien para validar el texto que ha introducido, bien para realizar una acción
con él. Una opción, por supuesto, es poner en el mismo formulario algún botón estilo
"Ok", "Salvar", etc. Cuando se pulse el botón, revisamos o recogemos el texto del
JTextField.
Sin embargo, también podemos hacerlo desde el mismo JTextField, sin necesidad de un
botón auxiliar. Para ello tenemos dos posibles formas. Una es con la pulsación de la
tecla <enter> sobre el JTextField. Esto dispara en el JTextField un evento ActionEvent.
El siguiente código se entera de cuando se pulsa <enter> en el JTextField y escribe su
contenido en pantalla
textField.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
System.out.println("Pulsado enter");
System.out.println(((JTextField)e.getSource()).getText());
}
});
La otra opción es ver cuando el JTextField pierde el foco, es decir, el usuario se va a
escribir a otro sitio o pulsar algún botón o lo que sea. Se supone que si el usuario va a
otra parte de la ventana, es que ha terminado de escribir y podemos revisar el texto
escrito. El siguiente código se entera de cuando se pierde el foco y escribe el contenido
del JTextField en pantalla
textField.addFocusListener(new FocusListener() {
public void focusLost(FocusEvent e) {
System.out.println("Perdido foco");
System.out.println(((JTextField)e.getSource()).getText());
}
public void focusGained(FocusEvent e) {
// No hacemos nada
}
});
Esta segunda opción es en general más cómoda para el usuario, ya que no le obliga a
apretar <enter> cuando termine de escribir ni se puede olvidar de hacerlo. Sin embargo,
es algo más delicada, puesto que el usuario puede ir a otra parte de la ventana a hacer
algo cuando todavía no ha terminado realmente de escribir todo el texto.