Bienvenidos a todos a un nuevo bloque de programación
en Java, empezamos una retahíla de posts sobre los Componentes Swing, vamos a empezar viendo los cuadros de texto.
Para la creación de los cuadros de texto se utilizan
dos clases: JTextField que son los campos de texto que ocupan
solo una línea y JTextArea que son los campos de texto que
ocupan varias líneas. Ambas clases heredan de la clase JTextComponent.
Sería interesante que revisarais la API de Java para obtener más información acerca
de estas clases y ver su uso, para cuando estemos realizando la práctica lo
veáis más claro.
Para explicar los cuadros de texto nos creamos un
nuevo proyecto al que vamos a llamar ComponentesSwing,
dentro de este proyecto creamos un paquete al que vamos a llamar swing y dentro del paquete nos creamos
una nueva clase cuyo código es el siguiente:
package swing;
import javax.swing.JFrame;
import
javax.swing.JPanel;
public class PruebaTexto {
public static void main(String[] args) {
MarcoTexto mimarco = new MarcoTexto();
mimarco.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}
class MarcoTexto
extends JFrame {
public MarcoTexto() {
setBounds(500, 300, 600, 150);
LaminaTexto milamina=new LaminaTexto();
add(milamina);
setVisible(true);
}
}
class LaminaTexto
extends JPanel {
public LaminaTexto() {
}
}
No es necesario comentar nada acerca del código ya que
lo hemos visto en los apartados anteriores.
Lo primero que vamos a hacer es crear un campo de
texto, nos situamos dentro del constructor de la clase LaminaTexto:
JTextField campo1 = new JTextField();
add(campo1);
Probamos la aplicación:
Vemos que se ha creado el campo de texto pero ha
cogido las medidas de forma predefinida, apenas se visualiza. Podemos indicar
que aparezca un texto por defecto y esto se hace pasándolo por parámetro en la
instancia:
JTextField campo1 = new JTextField("Escribe
aquí");
add(campo1);
Le podemos indicar el número de columnas:
JTextField campo1 = new JTextField("Escribe
aquí", 20);
add(campo1);
Probamos de nuevo:
Con el método getText() podemos
capturar el texto, es decir, lo que hay dentro del campo de texto mediante
un System.out que imprima el texto que hemos escrito en la
consola:
JTextField campo1 = new JTextField("Escribe
aquí", 20);
add(campo1);
System.out.println(campo1.getText());
Probamos:
Con esta breve introducción de cómo crear los campos
de texto vamos a realizar otra práctica en la cual vamos a crear un botón al
lado del campo de texto, de forma que cuando escribamos algo en el cuadro de
texto al pulsar el botón nos capture el texto y lo imprima en consola.
Primero lo que tenemos que hacer es crearnos el botón,
para capturar el texto se va a gestionar en otra clase que crearemos
posteriormente pero de momento la vamos a instanciar a continuación de la creación
del botón, luego lo pondremos en escucha con el método addActionListener() y finalmente lo añadiremos a la lámina:
public LaminaTexto() {
JTextField campo1 = new JTextField(20);
add(campo1);
JButton miboton = new JButton("Pulsar");
PulsaTexto mievento = new PulsaTexto();
miboton.addActionListener(mievento);
add(miboton);
}
Si revisamos el código en la instancia le habíamos
pasado como primer parámetro un texto, en esta ocasión lo vamos a eliminar,
solo le pasamos el número de columnas, y como he comentado anteriormente,
creamos el botón, instanciamos la clase PulsaTexto que vamos a
crearla ahora, ponemos el botón a la escucha y finalmente añadimos el botón a
la lámina.
Lo siguiente que vamos a hacer es crearnos la clase interna PulsaTexto
que va a heredar de ActionListener,
contiene un método obligatorio que hay que declarar que es el método actionPerformed y dentro de este método
vamos a escribir el System.out.println:
private class PulsaTexto implements ActionListener{
@Override
public void
actionPerformed(ActionEvent e) {
System.out.println(campo1.getText().trim());
}
}
private JTextField campo1;
}
Dentro del System.out
hemos capturado el texto que vamos a escribir en el cuadro de texto con el
método getText(), el método trim() lo vamos a
utilizar para que no tenga en cuenta los espacios que pueda haber tras escribir
el texto. Sin embargo, esto nos daría un error ya que estamos utilizando un
objeto (campo1) que está declarado en otro método diferente. Para solucionarlo
hemos de declarar la variable campo1 para que se pueda utilizar en todos los
métodos y no declararla dentro del constructor de la laminaTexto.
JTextField campo1 = new JTextField(20);
Probamos:
Comprobamos que gracias al método trim() no
ha tenido en cuenta el espacio que había delante de la frase.
Siguiendo con el ejemplo, vamos a escribir una
dirección mail en el campo de texto y nos va a indicar si es correcta o no,
será correcta si dispone de un arroba (@). Nos situamos dentro del método
actionPerformed nos creamos una variable de tipo entero a la que vamos a llamar
correo que la vamos a inicializar a 0, esta variable nos va a evaluar cuantas @
hay. Luego creamos una variable de tipo String que vamos a llamar mail que va
ser la que va a quedar registrada en el campo de texto junto con el método
trim() por si hay espacios al principio o al final para que nos los tenga en
cuenta:
public void
actionPerformed(ActionEvent e) {
int correcto = 0;
String
mail = campo1.getText().trim();
}
Mediante un for vamos a recorrer la variable mail,
dentro de este for crearemos un condicional if que nos va a evaluar si hay un
arroba, más de un arroba o si no lo hay:
public void
actionPerformed(ActionEvent e) {
int correcto = 0;
String
mail = campo1.getText().trim();
for(int i=0; i<mail.length(); i++) {
if(mail.charAt(i)=='@') {
correcto++;
}
}
if(correcto!=1) {
System.out.println("Incorrecto");
}else {
System.out.println("Correcto");
}
}
Lo probamos, indicamos un mail con un arroba:
Nos indica en consola que el mail es correcto, vamos a añadirle un arroba más:
Nos indica que es incorrecto. Sin ninguna arroba:
Con lo que la aplicación está funcionando
correctamente.
Sin embargo, en lugar de que nos los muestre en la consola si la dirección introducida es correcta o incorrecta que nos lo muestre en la misma ventana mediante una etiqueta de texto o label:
Lo primero que tenemos que hacer es declarar una
variable de tipo JLabel a la que vamos a llamar resultado.
private JLabel resultado;
Después vamos a iniciar esta variable dentro del
constructor de la LaminaTexto():
resultado = new JLabel();
Tenemos que indicar ahora donde queremos que aparezca
esta etiqueta, queremos que aparezca entre el campo de texto y el botón, por lo
que hay que mirar en el constructor donde están ubicados el campo de texto y el
botón para ponerlo entre estos dos elementos:
public LaminaTexto() {
resultado = new JLabel();
campo1 = new JTextField(20);
add(campo1);
add(resultado);
JButton miboton = new JButton("Pulsar");
PulsaTexto mievento = new PulsaTexto();
miboton.addActionListener(mievento);
add(miboton);
}
En el condicional que mediante un System.out
indicábamos si la dirección era correcta o incorrecta hay que modificarlo de la
siguiente forma:
if(correcto!=1) {
resultado.setText("Incorrecto");
}else {
resultado.setText("Correcto");
}
}
Probamos:
Si no escribimos más de un arroba o no escribimos ninguna:
Si en lugar de que aparezca la etiqueta entre el campo
de texto y el botón queremos que aparezca debajo, tenemos que trabajar con las disposiciones o layouts. Para ello vamos a crearnos una segunda lámina, la lámina
que tenemos creada tiene una disposición BorderLayout
que es la disposición por defecto. La segunda lámina va a tener una disposición
FlowLayout, en esta lámina vamos a
colocar el campo de texto y el botón, que estarán en la zona norte, y la
etiqueta donde me indica Correcto o Incorrecto va a estar en la zona del
centro.
Lo primero vamos a indicar la disposición que va a
tener la lámina que ya tenemos creada y a continuación creamos la segunda
lámina y le indicamos la disposición:
public LaminaTexto() {
setLayout(new
BorderLayout());
JPanel milamina2 = new JPanel();
milamina2.setLayout(new
FlowLayout());
Le indicamos que los componentes tienen que estar
ubicados en la segunda lamina:
public LaminaTexto() {
setLayout(new
BorderLayout());
JPanel milamina2 = new JPanel();
milamina2.setLayout(new FlowLayout());
resultado = new JLabel();
campo1 = new JTextField(20);
milamina2.add(campo1);
add(resultado);
JButton miboton = new JButton("Pulsar");
PulsaTexto mievento = new PulsaTexto();
miboton.addActionListener(mievento);
milamina2.add(miboton);
}
Tenemos que indicar que esta segunda lámina la agregue
en la zona norte de la lámina principal:
add(milamina2,BorderLayout.NORTH);
Nos falta por indicar donde queremos que ubique la
etiqueta que nos indica si es correcto o no el mail en la zona norte de la lámina
principal.
add(resultado, BorderLayout.CENTER);
Y en la variable le indicamos la alineación:
resultado = new JLabel("", JLabel.CENTER);
Probamos:
Si añadimos un mail incorrecto:
Con cualquier duda lo podéis hacer a través de los comentarios
del blog. Hasta pronto!
6.4 GRIDLAYOUT << >> 7.2 EVENTOS EN CUADROSDE TEXTO
No hay comentarios:
Publicar un comentario