Noticias

* Completa este formulario para conocer los temas de tu interes, te tomará unos segundos.

* Contenido actualizado diariamente!!

* Nueva categoría JavaScript!, aprender javascript está en tus manos!

* Nueva categoría VB .Net!, aprender VB .NET fácilmente con franvarvil!

* Sigue a la página para seguir creciendo!!
Mostrando entradas con la etiqueta jtextfield. Mostrar todas las entradas

domingo, 20 de enero de 2013

Java: Swing: JFormattedTextField y MaskFormatter

Francisco 9:35 , , , , , , No hay comentarios :

Introducción

Existen ocasiones en que necesitamos que el Usuario ingrese algunos valores, pero estos valores debe tener un formato, por ejemplo en mi Universidad se una un carnet alfanumérico que consta de una letra y 5 números (ejemplo: A12345), entonces para no tener que hacer validaciones ni nada cada vez que el usuario ingrese los valores creamos máscaras, que sirven para especificar un formato de entrada.

Desarrollo

Estas máscaras se usan junto con los JFormattedTextField que son los campos donde el usuario va a escribir lo que se le solicita.

Primero vamos a crear nuestra máscara, para ello importamos la librería:

import javax.swing.text.MaskFormatter;

Y vamos a crear nuestro método de la máscara:

// Mascara para nuestra contraseña
 private MaskFormatter mascara() {
     // Inicializamos el objeto
     MaskFormatter mascara = new MaskFormatter();
     // Entramos en un try/catch por alguna eventualidad
     try {
         // Creamos el formato de nuestra contraseña
         // # -> un número U -> letra mayúscula L -> letra minúscula
         // * -> cualquier caracter ' -> caracteres de escape
         // A -> cualquier letra o número ? -> cualquier caracter
         // H -> cualquier caracter hexagonal (0-9, a-f or A-F).
         mascara = new MaskFormatter("A#####");
     } catch (ParseException e) {
         // Algún error que pueda ocurrir
         e.printStackTrace();
     }
     return mascara;
 }

Como podrán apreciar existen varios "caracteres" reservador para las diferentes combinaciones que queremos hacer, ese método es para los carnet de mi Universidad, una letra y luego cinco números. Además es necesario que esté en un Try/catch por cualquier excepción (acá se explican como funciona un try/catch).

Por cierto para este try/catch tienen que importar esto:

import java.text.ParseException;

Ya con nuestra máscara creada vamos a hacer el campo de texto que tiene ese formato específico para esto importamos la librería:

import javax.swing.JFormattedTextField;

Y nuestro método sería este:

 // Espacio para ingresar el nombre de usuario
 private JFormattedTextField jtaContrasenia(MaskFormatter mascara) {
     // Se inicializa el objeto
     JFormattedTextField contrasenia = new JFormattedTextField(mascara);
     // Asignamos posición y tamaño
     contrasenia.setBounds(200, 80, 150, 20);
     // Le colocamos un texto emergente
     contrasenia.setToolTipText("Formato de la contrasenia: (a-z)#####, ejemplo: A13455 ");
     return contrasenia;
 }

Este método recibe una mascara que es la que creamos anteriormente, se la enviamos en el constructor de la clase cuando añadimos el JFormattedTextField al JFrame, sería así:

add(jtaContrasenia(mascara()));

Y con eso ya aplicamos la mascara en nuestro campo de texto y hacemos que el usuario ingrese justo lo que nosotros deseamos, hay que tener en cuenta que si el usuario no llena, en este caso los seis espacios, cuando se quiera hacer una acción con lo que esté escrito hasta el momento trabajaria con un vacío ( "" ), y puede causar malestares en el programa si no se hacen las validaciones necesarias.

La clase final sería esta:

package Parapublicar;

import java.text.ParseException;

import javax.swing.JFormattedTextField;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JTextField;
import javax.swing.text.MaskFormatter;

@SuppressWarnings("serial")
public class Mascaras extends JFrame {

    public Mascaras() {
        add(ingresarContrasenia());
        add(ingresarUsuario());
        add(jtaUsuario());
        // Le enviamos la mascara a nuestro JFormattedTextField
        add(jtaContrasenia(mascara()));
        inicializador();
    }

    // Inicializador de la Ventana
    private void inicializador() {
        setSize(400, 200);
        setLayout(null);
        setTitle("Login");
        setLocationRelativeTo(null);
        setVisible(true);
        setResizable(false);
        setDefaultCloseOperation(EXIT_ON_CLOSE);
    }

    // Texto que indica donde va el nombre de Usuario
    private JLabel ingresarUsuario() {
        JLabel usuario = new JLabel("Nombre de Usuario: ");
        usuario.setBounds(30, 30, 200, 20);
        return usuario;
    }

    // Texto que indica donde va la contraña
    private JLabel ingresarContrasenia() {
        JLabel contrasenia = new JLabel("Contrasenia: ");
        contrasenia.setBounds(30, 80, 200, 20);
        return contrasenia;
    }

    // Espacio para ingresar el nombre de usuario
    private JTextField jtaUsuario() {
        JTextField usuario = new JTextField();
        usuario.setBounds(200, 30, 150, 20);
        usuario.setToolTipText("Ingrese Nombre de Usuario");
        return usuario;
    }

    // Espacio para ingresar el nombre de usuario
    private JFormattedTextField jtaContrasenia(MaskFormatter mascara) {
        // Se inicializa el objeto
        JFormattedTextField contrasenia = new JFormattedTextField(mascara);
        // Asignamos posición y tamaño
        contrasenia.setBounds(200, 80, 150, 20);
        // Le colocamos un texto emergente
        contrasenia.setToolTipText("Ingrese la contrasenia");
        return contrasenia;
    }

    // Mascara para nuestra contraseña
    private MaskFormatter mascara() {
        // Inicializamos el objeto
        MaskFormatter mascara = new MaskFormatter();
        // Entramos en un try/catch por alguna eventualidad
        try {
            // Creamos el formato de nuestra contraseña
            // # -> un número U -> letra mayúscula L -> letra minúscula
            // * -> cualquier caracter ' -> caracteres de escape
            // A -> cualquier letra o número ? -> cualquier caracter
            // H -> cualquier caracter hexagonal (0-9, a-f or A-F).
            mascara = new MaskFormatter("A#####");
       } catch (ParseException e) {
           // Algún error que pueda ocurrir
           e.printStackTrace();
       }
       return mascara;
    }

    public static void main(String[] args) {
        new Mascaras();
   }

}


Documentación de Java sobre las máscaras:  https://docs.oracle.com/javase/8/docs/api/javax/swing/text/MaskFormatter.html
Documentación de Java sobre JFormattedTextField:  https://docs.oracle.com/javase/8/docs/api/javax/swing/JFormattedTextField.html

Conclusiones

 Utilizar máscaras puede ser de gran utilidad en diversas aplicaciones, debido a que ayudan a validar que es lo que el usuario esta digitando.

Siempre que se utilice una máscara se le debe mostrar al usuario el formato correspondiente que se desea que introduzca en el campo, debido a que esto hará que el usuario tenga una mejor noción de que es lo que se solicita.


sábado, 19 de enero de 2013

Java: Swing: JPasswordField

Francisco 8:40 , , , , , , , , , 9 comentarios :
Introducción

Cuando vamos a escribir una contraseña o alguna otra palabra que deseamos que no aparezca visualmente en el campo sino más bien algún caracter (lo más común son unos puntitos), existe lo llamado JPasswordField. Es un campo de texto (como el JTextField) solo que cuando escribimos aparecerán los puntitos o el caracter que nosotros seleccionamos.

Desarrollo

Importamos la librería necesaria para utilizar el JPasswordField:

import javax.swing.JPasswordField;

Luego procedemos a crear nuestro método, el ejemplo que daré es de un Login o un área donde colocamos usuario y contraseña para ingresar a una cuenta.

// Espacio para ingresar la contraseña
 private JPasswordField jpfContrasenia() {
     // Se inicializa el Objeto
     JPasswordField contrasenia = new JPasswordField();
     // Asignamos posición y tamaño
     contrasenia.setBounds(200, 80, 150, 20);
     // Colocamos un símbolo personalizado(opcional)
     // Si no lo colocamos aparecen los puntitos predeterminados
     contrasenia.setEchoChar('+');
     // Le asignamos un texto emergente cuando nos posamos encima del objeto
     contrasenia.setToolTipText("Ingrese Contraseña");
     return contrasenia;
 }

Y con ese método creamos nuestro campo para una contraseña, coloqué un símbolo “mas” ( + ) solo para el ejemplo y para que se conozca el método para cambiar el símbolo pero esa característica es opcional, me gustan más los puntos tradicionales. Bueno luego creamos los JLabel y el JTextField para hacer nuestra ventana de “ingresar” y mi clase final quedaría así:

import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPasswordField;
import javax.swing.JTextField;

@SuppressWarnings("serial")
public class Password extends JFrame {

    public Password() {
        add(ingresarUsuario());
        add(ingresarContrasenia());
        add(jtaUsuario());
        add(jpfContrasenia());
        inicializador();
    }

    // Inicializador de la Ventana
    private void inicializador() {
        setSize(400, 200);
        setLayout(null);
        setTitle("Login");
        setLocationRelativeTo(null);
        setVisible(true);
        setResizable(false);
        setDefaultCloseOperation(EXIT_ON_CLOSE);
    }

    // Texto que indica donde va el nombre de Usuario
    private JLabel ingresarUsuario() {
        JLabel usuario = new JLabel("Nombre de Usuario: ");
        usuario.setBounds(30, 30, 200, 20);
        return usuario;
    }

    // Texto que indica donde va la contraña
    private JLabel ingresarContrasenia() {
        JLabel contrasenia = new JLabel("Contrasenia: ");
        contrasenia.setBounds(30, 80, 200, 20);
        return contrasenia;
    }

    // Espacio para ingresar el nombre de usuario
    private JTextField jtaUsuario() {
        JTextField usuario = new JTextField();
        usuario.setBounds(200, 30, 150, 20);
        usuario.setToolTipText("Ingrese Nombre de Usuario");
        return usuario;
    }

    // Espacio para ingresar la contraseña
    private JPasswordField jpfContrasenia() {
        // Se inicializa el Objeto
        JPasswordField contrasenia = new JPasswordField();
        // Asignamos posición y tamaño
        contrasenia.setBounds(200, 80, 150, 20);
        // Colocamos un símbolo personalizado(opcional)
        contrasenia.setEchoChar('-');
        // Le asignamos un texto emergente cuando nos posamos encima del objeto
        contrasenia.setToolTipText("Ingrese Contraseña");
        return contrasenia;
    }

    public static void main(String[] args) {
        new Password();
    }

}

Como nota, también se puede agregar a un JOptionPane, elementos como paneles, labels, entre otros, acá les dejo un ejemplo para un JOptionPane tipo password.

// Objeto que hará que aparezcan los puntitos en la contraseña en vez de
// los caracteres ingresados
JPasswordField pwd = new JPasswordField();


// Primero null, luego pwd que es nuestro objeto jpassfield acá
// puedes colocar paneles, label entre otros objetos, nombre del
// titulo de la ventana, tipo de botones, sin icono

JOptionPane.showConfirmDialog(null, pwd, "Enter Password",JOptionPane.OK_CANCEL_OPTION, JOptionPane.PLAIN_MESSAGE);

Documentación: http://docs.oracle.com/javase/8/docs/api/javax/swing/JPasswordField.html

Conclusiones

 No mostrar información sensible es un método para salvaguardar a los usuarios que utilicen la aplicación.

Tampoco es bueno exagerar y colocar todo con este tipo de elemento.

viernes, 18 de enero de 2013

Java: Swing: JTextArea y JScrollPane

Francisco 16:57 , , , , , , , , No hay comentarios :
Introducción

Los JTextArea se utilizan cuando se le pide al Usuario que escriba por ejemplo un comentario, una sugerencia o cualquier otra cosa que lleve varias líneas, es algo muy parecido al JTextField, solo que para un texto más amplio.

Desarrollo

Lo primero que se hace es importar la librería:

import javax.swing.JTextArea;

Para crear nuestro objeto haríamos el siguiente método:

    // Crea un JTextArea para escribir un texto amplio
    private JTextArea jtaEscribir() {
        // Se inicializa la variable
        JTextArea area = new JTextArea();
        // Se define el salto de linea automático
        // (cuando llega al final del JTextArea hace un salto de línea)
        area.setLineWrap(true);
        // Se asigna posicion y tamaño al JTextArea
        area.setBounds(30, 30, 300, 200);
        // Le podemos asignar un color de fondo
        area.setBackground(new Color(0, 0, 0));
        // Por ende cambiamos el color de letra
        area.setForeground(new Color(255, 255, 255));
        return area;
    }

Las propiedades para definir el fondo y el color de letra solo las coloqué para que vean que si se pueden usar, mientras que el método .setLineWrap() es para cuando llegamos al final del tamaño de nuestro JTextArea salte automáticamente a la siguiente línea y eso evita que el usuario tenga que precionar enter cada vez que llegue al final o que siga escribiendo en una unica línea todo.

Ahora bien con esto existe un problema casi nunca funciona colocar los scrolls que trae por defecto el JTextArea por tanto si el usuario llega al final (de abajo en el eje Y) del JTextArea podrá seguir escribiendo pero no podrá ver que es lo que escribe, pero eso lo solucionamos con nuestro JScrollPane!!!

El JScrollPane es el que nos viene a solucionar ese pequeño defecto y a dar un toque más bonito a nuestro JTextArea, para las barra de desplazamiento importamos:

import javax.swing.JScrollPane;

Pues bien nuestro JScrollPane es un panel, ¿qué es un panel?, pues un panel es un objeto que almacena otros objetos dentro de el, por ejemplo imaginemos una cubeta en la cual colocamos algunos elementos dentro en cierto orden, cuando movemos la cubeta no hay que mover todos esos elementos dentro de ella porque ya están dentro y se mueven con ella , solo que nuestro JScrollPanel no solo contiene objetos sino que también da barras de desplazamiento.

Para crearlo haremos el siguiente método:

 // Se crea una barra de desplazamiento
 private JScrollPane jsbBarra() {
     // Se inicializa el objeto y se le agrega un JTextArea
     JScrollPane scroll = new JScrollPane(jtaEscribir());
     // Se le asigna una posicion y un tamaño
     scroll.setBounds(30, 30, 300, 200);
     return scroll;
 }

Nuestro ScrollPane va a recibir a nuestro método donde creamos nuestro JTextArea y en el JFrame no agregamos el JTextArea sino que agregamos el JScrollPane. Y a nuestro método del JTextArea le quitamos lo posición y el tamaño ya que no los necesitamos.

Al final nuestra clase quedaría así, es solo una ventana con un campo donde escribir:

import java.awt.Color;

import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;

@SuppressWarnings("serial")
public class JTextAreaYJScrollPane extends JFrame {

    public JTextAreaYJScrollPane() {
        // add(jtaEscribir());
        add(jsbBarra());
        inicializador();
    }

    // Inicializador de la Ventana
    private void inicializador() {
        setSize(400, 300);
        setLayout(null);
        setTitle("Mi ventana");
        setLocationRelativeTo(null);
        setVisible(true);
        setResizable(false);
        setDefaultCloseOperation(EXIT_ON_CLOSE);
    }

    // Crea un JTextArea para escribir un texto amplio
    private JTextArea jtaEscribir() {
        // Se inicializa la variable
        JTextArea area = new JTextArea();
        // Se define el salto de linea automático
        // (cuando llega al final del JTextArea hace un salto de línea)
        area.setLineWrap(true);
        // Se asigna posicion y tamaño al JTextArea
        // area.setBounds(30, 30, 300, 200);
        // Le podemos asignar un color de fondo
        area.setBackground(new Color(0, 0, 0));
        // Por ende cambiamos el color de letra
        area.setForeground(new Color(255, 255, 255));
        return area;
    }

    // Se crea una barra de desplazamiento
    private JScrollPane jsbBarra() {
           // Se inicializa el objeto y se le agrega un JTextArea
           JScrollPane scroll = new JScrollPane(jtaEscribir());
           // Se le asigna una posicion y un tamaño
           scroll.setBounds(30, 30, 300, 200);
           return scroll;
    }

    // El MAIN
    public static void main(String[] args) {
        new JTextAreaYJScrollPane();
    }
}

Si quieren ver las diferencias con y sin el ScrollPane pueden comentar el add() del método del Scroll y descomentar el add() del método del JTextArea (y de este método descomentar el tamaño y posición) y así verán que es más estético con un JScrollPane (por lo menos ese es mi parecer).

La Documentación de Java al respecto:
JTextArea: http://docs.oracle.com/javase/8/docs/api/javax/swing/JTextArea.html

Conclusiones

 El textArea y el scrollPane son elementos que pueden servir de mucho en nuestras aplicaciones y gracias al scrollPane, se logra tener un mejor acabado

jueves, 6 de diciembre de 2012

Java: Swing: AWT: JButton y ActionListener

Francisco 10:40 , , , , , , , , , , , , 3 comentarios :
Introducción

Los JButton, pues no hay mucho que decir son botones que se agregan en nuestro Frames para que ejecuten una acción al ser presionados por el Usuario.

Desarrollo
Primero tenemos que agregar la librería: 

import javax.swing.JButton;

Ahora vamos a crear nuestro método para el botón: 

private JButton verBoton() {
    //Inicializamos el botón
    JButton boton = new JButton();
    //agregamos texto al botón
    boton.setText("Botón");
    //agregamos coordenadas
    boton.setBounds(50, 50, 100, 50);
    //le damos una tipografía
    boton.setFont(new Font("Arial", 1, 18));
    //le damos un color a la fuente
    boton.setForeground(new Color(25,85,255));
 
    return boton;
 }

Con eso tendremos un botón con las letras azules (el color no es muy bonito pero es para que se aprecie el cambio). Nuestro botón si lo presionamos, no pasa nada entonces vamos a implementar una interface para que puedan ser "escuchados", con ser escuchados me refiero a que realicen algo cuando se les presione. 

public class MiClase extends JFrame implements ActionListener {//nuestro código}

Cuando implementamos ActionListener tenemos que colocar el método de esta interface de lo contrario nos va a mostrar un error, para los que usan un IDE es muy fácil porque lo coloca automáticamente, pero para los que no, acá está el método que tenemos que colocar:

@Override
 public void actionPerformed(ActionEvent e) {
 }

En este método tenemos que colocar las acciones que van a ejecutar, en este caso nuestros botones. 

Vamos a hacer un ejemplo reuniendo todo lo que vimos hasta ahora: JLabel, JTextField y JButton, vamos a escribir algo en un campo de texto y lo vamos a pasar (en mayúscula) a otro campo de texto que no se puede editar cuando presionemos un botón. 

Aunque se vea muy simple, es para dar un ejemplo de como usar actionListener y bueno acá va el código comentado las partes que no se han visto antes: 
import java.awt.Font;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JTextField;

@SuppressWarnings("serial")
public class JFrames extends JFrame implements ActionListener {

    //Ocupamos que nuestro botón y los jtextfield sean globales para poder acceder a ellos 
    //por medio de actionPerformed
    private JButton boton;
    private JTextField jtfPalabra;
    private JTextField jtfPalabraPasada;

    public JFrames() {
        add(verBoton());
        add(getPalabra());
        add(getIngresar());
        add(getPalabraPasada());
        inicializador();
    }
   
    private void inicializador() {
        setSize(400, 300);
        setLayout(null);
        setTitle("Mi ventana");
        setLocationRelativeTo(null);
        setVisible(true);
        setResizable(false);
        setDefaultCloseOperation(EXIT_ON_CLOSE);
    }

    private JButton verBoton() {
        boton = new JButton();
        boton.setText(">>>");
        boton.setBounds(150, 200, 100, 50);
        boton.setFont(new Font("Arial", 1, 18));
        //le incluimos la posibilidad de ser escuchado cuando se
        //le precione
        boton.addActionListener(this);
        return boton;
    }
 
    private JLabel getIngresar() {
        JLabel jlIngresar = new JLabel("Ingrese una palabra: ");
        jlIngresar.setBounds(30, 50, 150, 30);
        return jlIngresar;
    }
 
    private JTextField getPalabra() {
        jtfPalabra = new JTextField();
        jtfPalabra.setBounds(180, 50, 100, 30);
        return jtfPalabra;
    }
 
    private JTextField getPalabraPasada() {
        jtfPalabraPasada = new JTextField();
        jtfPalabraPasada.setBounds(180, 120, 150, 30);
        //Hacemos que lo que esté escrito acá no se pueda modificar
        jtfPalabraPasada.setEnabled(false);
        return jtfPalabraPasada;
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        //Para hacerlo paso a paso vamos a crear unas variables tipo
        //string para almacenamiento temporal
        String palabra = "";
 
        //si precionamos nuestro botón ejecutará una acción
        if (e.getSource() == boton){
            //Obtenemos el valor del campo de texto
            palabra = jtfPalabra.getText();
            //convertimos a mayúsculas
            palabra = palabra.toUpperCase();
            //asignamos al otro jtextfield (el que no se puede editar)
            jtfPalabraPasada.setText(palabra);
            //limpiamos el campo en el que escribimos la palabra
            jtfPalabra.setText(""); 
        }
    } 
}

Y como siempre la documentación de java con respecto a los temas tratados:
Botones: http://docs.oracle.com/javase/8/docs/api/javax/swing/JButton.html
ActionListener: http://docs.oracle.com/javase/8/docs/api/java/awt/event/ActionListener.html

Conclusiones

 Los botones y las acciones que se realizan al presionarlos son elementos que se utilizan en la gran mayoría de aplicaciones hoy en día.

El ActionListener es una interface que se implementa para poder asignarle una acción a un elemento del JFrame.

Java: Swing: JTextField

Francisco 8:54 , , , , , , , , No hay comentarios :
Introducción

Los JTextField son campos donde el usuario puede ingresar información que se le solicite, por ejemplo en un formulario para registrarse a algún servicio. En esta entrada aprenderemos a como crear este elemento.

Desarrollo

 Primero importar la librería necesaria: 

import javax.swing.JTextField;

Luego tenemos nuestro método para un JTextField: 

//Crea un campo de texto
 private JTextField verTextField() {
  //inicializamos el campo
  JTextField ejemplo = new JTextField();
  //le damos coordenadas
  ejemplo.setBounds(10, 10, 100, 20);
  return ejemplo;
 }

Como pueden ver el método para crear uno de estos es muy sencillo, lógicamente tiene otras propiedades pero como lo más básico es este que coloqué.

Y bueno mi clase quedaría así: 

import javax.swing.JFrame;
import javax.swing.JTextField;

@SuppressWarnings("serial")
public class JFrames extends JFrame {

 public JFrames() {
  add(verTextField());
  inicializador();
 }

 private void inicializador() {
  setSize(800, 600);
  setLayout(null);
  setTitle("Mi ventana");
  setLocationRelativeTo(null);
  setVisible(true);
  setResizable(false);
  setDefaultCloseOperation(EXIT_ON_CLOSE);
 }

 //Crea un campo de texto
 private JTextField verTextField() {
  //inicializamos el campo
  JTextField ejemplo = new JTextField();
  //le damos coordenadas
  ejemplo.setBounds(10, 10, 100, 20);
  return ejemplo;
 }
}


Conclusiones
Los JTextField, son elementos básicos y de gran utilidad en las aplicaciones que requieran formularios y demás. En este ejemplo fué algo muy básico, sin embargo, es suficiente para entender como crearlo, la funcionalidad varía entre una y otra aplicación.
Suscribirse a: Entradas ( Atom )

Seguidores

Envía tú opinión, comentario o sugerencia.

Nombre

Correo electrónico *

Mensaje *