Hola, ¿qué tal? En este post vamos a ver los eventos
que se pueden producir en los cuadros de texto, algunas veces será necesario
controlar lo que se escribe en el campo de texto, el texto que se ha borrado,
el texto que se ha introducido, etc.
Ya sabemos que la clase JTextField es
la que nos construye los campos de texto que a su vez hereda de la JTextComponent,
esta clase tiene un método getDocument() que también hereda de
la clase JTextField, cuando se aplica este método lo que nos
devuelve es un Document que es un modelo o representación del
texto que hay dentro del cuadro de texto. Document es una
interfaz que tiene un método addDocumentListener(), esto implica
que si Document sufre algún cambio, bien porque se ha
modificado el texto o porque se ha borrado al haberse aplicado el método addDocumentListener() se
dispara el evento de tipo documentEvent(). Si en este caso tenemos
creada una clase que gestione estos eventos, es decir, una clase ReceptoraEvento controlaremos
estos eventos. La particularidad que tiene que tener esta clase es que ha de
implementar la interfaz DocumentListener, esta interfaz contiene
tres métodos:
·
removeUpdate(): se ejecuta al borrar texto.
·
insertUpdate(): se ejecuta al introducir texto
·
changedUpdate(): se ejecuta al modificar texto.
Con lo cual estamos obligados a declarar estos
métodos.
Pues después de esta explicación vamos a verlo sobre
la práctica, nos creamos una nueva clase cuyo código es el siguiente:
package swing;
import
javax.swing.JFrame;
import
javax.swing.JPanel;
import
javax.swing.JTextField;
public class EventosTexto {
public static void main(String[] args) {
MarcoTxt mimarco = new MarcoTxt();
mimarco.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}
class MarcoTxt
extends JFrame {
public MarcoTxt() {
setBounds(500, 400, 500, 150);
LaminaTxt milamina = new LaminaTxt();
add(milamina);
setVisible(true);
}
}
class LaminaTxt
extends JPanel{
public LaminaTxt() {
JTextField micampo = new JTextField(20);
add(micampo);
}
}
Probamos:
Lo que vamos a hacer en esta práctica es que al
introducir texto en el campo de texto que nos imprima en consola que hemos
introducido texto y si borramos texto del campo de texto que también nos salga
por consola que hemos borrado texto.
Lo primero que vamos a hacer es crear una clase
receptora que gestione estos eventos, va a ser una clase interna de la clase LaminaTxt:
private class EscuchaTexto implements DocumentListener{
}
Aplicamos los métodos:
private class EscuchaTexto implements
DocumentListener{
@Override
public void
insertUpdate(DocumentEvent e) {
// TODO
Auto-generated method stub
}
@Override
public void
removeUpdate(DocumentEvent e) {
// TODO
Auto-generated method stub
}
@Override
public void
changedUpdate(DocumentEvent e) {
// TODO
Auto-generated method stub
}
}
Dentro del método insertUpdate escribimos
un System.out que es el que nos va a indicar que hemos escrito
texto en el campo de texto:
public void
insertUpdate(DocumentEvent e) {
System.out.println("Has
introducido texto");
}
Y en el método removeUpdate otro System.out para
cuando borremos texto del campo de texto:
public void
removeUpdate(DocumentEvent e) {
System.out.println("Has
borrado texto");
}
Luego hay que poner el objeto JTextField a
la escucha nos creamos un objeto de tipo Document
y posteriormente lo ponemos a la escucha:
public LaminaTxt() {
JTextField micampo = new JTextField(20);
Document midoc = micampo.getDocument();
midoc.addDocumentListener(el_evento);
add(micampo);
}
Le pasamos como parámetro una instancia el_evento que
creamos posteriormente:
public LaminaTxt() {
JTextField micampo = new JTextField(20);
EscuchaTexto el_evento = new EscuchaTexto();
Document midoc = micampo.getDocument();
midoc.addDocumentListener(el_evento);
add(micampo);
}
Y con esto ya lo tendríamos terminado. Probamos:
Y si borramos texto:
Vamos a crear otros ejemplo, va a consistir en una
aplicación que va a contener dos campos de texto, uno va ser el campo de texto
usuario y el otro campo de texto va a ser la contraseña que tendrá un mínimo de
8 caracteres y un máximo de 12, es decir, que no va a poder tener menos de 8
caracteres y más de 12. Si no introducimos una contraseña correcta que la
aplicación nos avise, por ejemplo, que el campo de texto de la contraseña este
resaltado en rojo, en el momento que la contraseña cumpla con los requisitos
establecidos que se quite ese sombreado en rojo del campo de texto.
Para ello empezamos creando una nueva clase a la que
vamos a llamar CampoPassword con el
siguiente código:
package swing;
import
javax.swing.JFrame;
import
javax.swing.JPanel;
public class CampoPassword {
public static void main(String[] args) {
MarcoPassword
mimarco = new MarcoPassword();
mimarco.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}
class MarcoPassword extends JFrame {
public MarcoPassword()
{
setBounds(400, 300, 550, 400);
LaminaPassword milamina = new
LaminaPassword();
add(milamina);
setVisible(true);
}
}
class LaminaPassword
extends JPanel{
public
LaminaPassword() {
}
}
Es un código que tiene un marco y una lámina, si lo probamos:
Lo que queremos es añadir estos objetos a la ventana:
Para distribuir estos objetos la lamina principal
tendría que tener un layout tipo BorderLayout
para que en la parte norte podamos incluir una segunda lamina que tenga una
distribución tipo GridLayout, de
forma que tenga dos filas y dos columnas, esta lámina estará en la zona norte
de la principal.
En la parte inferior de la lámina principal, en la
zona sur incluir el botón.
Así que empezamos indicando a la lámina principal su
ubicación:
public
LaminaPassword() {
setLayout(new BorderLayout());
}
Nos creamos la segunda lámina y le indicamos como
tiene que estar distribuida y le indicamos que ha de tener dos columnas y dos
filas:
public
LaminaPassword() {
setLayout(new BorderLayout());
JPanel lamina_superior = new JPanel();
lamina_superior.setLayout(new GridLayout(2,2));
}
Tenemos que indicarle que esta segunda lámina tiene
que estar en la parte superior:
public
LaminaPassword() {
setLayout(new
BorderLayout());
JPanel lamina_superior = new JPanel();
lamina_superior.setLayout(new
GridLayout(2,2));
add(lamina_superior, BorderLayout.NORTH);
}
A continuación nos creamos las dos etiquetas: usuario y password:
JLabel etiqueta1 = new JLabel("Usuario");
JLabel
etiqueta2 = new
JLabel("Password");
Creamos los campos de texto:
JTextField c_user = new JTextField(15);
JPasswordField
c_pass = new
JPasswordField(15);
Ambos campos de texto tendrán una longitud de 15, para
crear el campo de texto de la contraseña para que los caracteres aparezcan
encriptados, es decir, con asteriscos utilizamos la clase JPasswordField.
Una vez hecho esto tenemos que indicarle que estos
elementos van en la segunda lámina, en la parte superior:
lamina_superior.add(etiqueta1);
lamina_superior.add(c_user);
lamina_superior.add(etiqueta2);
lamina_superior.add(c_pass);
Nos creamos el botón que va a estar incluido en la lámina
principal y va tener un layout en la zona sur:
JButton
enviar = new JButton("Enviar");
add(enviar,
BorderLayout.SOUTH);
Con esto tenemos la interfaz gráfica, probamos:
Nos falta darle funcionalidad, que va a consistir que
en el campo de texto Password en el
momento que estemos escribiendo la contraseña el campo va a estar sombreado de
rojo hasta que escribamos el carácter ocho que quitará el sombreado rojo, si
nos pasamos del carácter doce volverá a sombrearse de color rojo el campo de
texto.
Lo primero es crearnos una clase receptora de los
eventos, a continuación del constructor de la lámina nos vamos a crear una
clase interna que sea capaz de gestionar estos eventos:
private class Comprobar_Pass implements DocumentListener{
}
Añadimos los métodos:
private class Comprobar_Pass
implements
DocumentListener{
@Override
public void
insertUpdate(DocumentEvent e) {
// TODO
Auto-generated method stub
}
@Override
public void
removeUpdate(DocumentEvent e) {
// TODO
Auto-generated method stub
}
@Override
public void
changedUpdate(DocumentEvent e) {
// TODO
Auto-generated method stub
}
}
Para recorrer los caracteres de la contraseña vamos a
utilizar el método length() y para
capturar los caracteres que hayamos introducido en el campo de texto vamos a
utilizar el método getPassword().
Nos situamos dentro del método insertUpdate(),
nos vamos a crear una variable de tipo char al que vamos a llamar password y
vamos a almacenar en esta variable en el campo contraseña:
public void
insertUpdate(DocumentEvent e) {
char[]password;
password = c_pass.getPassword();
}
Sin embargo, lo que almacenamos dentro de esta
variable nos da un error, esto es debido a que se esta utilizando el campo de
texto de la contraseña que esta declarado en el constructor de la lamina, para
solucionarlo tenemos que declararlo fuera para que la clase interna también
pueda hacer uso de este campo de texto. Por lo que eliminamos JPasswordField en el constructor de la
lámina:
JPasswordField c_pass = new
JPasswordField(15);
Y lo declaramos fuera:
JPasswordField
c_pass;
De esta forma en la variable password hemos conseguido almacenar cada uno de los caracteres de
la contraseña. Luego mediante un condicional if le tenemos que indicar que si la contraseña tiene menos de 8
caracteres o más de 12 que el campo de texto tenga un color de fondo rojo,
sino, que tenga el color blanco.
if(password.length<8 || password.length>12) {
c_pass.setBackground(Color.red);
}else {
c_pass.setBackground(Color.white);
}
}
Nos falta instanciar esta clase y poner el campo de la
contraseña a la escucha. Nos situamos dentro del constructor de la lámina,
después del campo c_user lo ponemos
a la escucha del evento de tipo Document:
c_pass.getDocument().addDocumentListener(mievento);
Como parámetro le hemos pasado una instancia mievento
que ahora la creamos, en unas líneas más arriba del constructor de la lámina
nos creamos la instancia de la clase interna:
Comprobar_Pass
mievento = new
Comprobar_Pass();
Con esto ya estaría terminado, probamos:
Hasta que no tengamos 8 caracteres en el campo de texto de la contraseña el sombreado rojo no se va a quitar, una vez que llegamos a los 8 caracteres:
Y si nos pasamos de 12 caracteres se vuelve a sombrear en rojo:
Con cualquier duda podéis hacerlo a través de los
comentarios del blog. Hasta pronto!
7.1 CUADROS DE TEXTO << >> 7.3 ÁREAS DETEXTO
No hay comentarios:
Publicar un comentario