Ejemplos con JTextField
Vamos a ver aquí algunos ejemplos básicos con JTextField y cómo hacer algunas cosas con este componente.
Instanciar el JTextField[editar]
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[editar]
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[editar]
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[editar]
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[editar]
ActionEvent y LosingFocus[editar]
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.