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 programación java. Mostrar todas las entradas

sábado, 20 de abril de 2013

Java: Swing: JCheckBox, JRadioButton y ButtonGroup

5 comentarios :

Introducción

Esta vez aprenderemos a crear dos elementos nuevos de interfaz de usuario en Java, los JCheckBox, primero que todo para los que no saben que son, los checkbox son unos cuadros que salen en un formulario -por ejemplo- cuando te preguntan: "¿Que te gusta?", salen un montón de opciones y puedes marcar más de una, por otro lado están los JRadioButton son parecidos a los checkbox pero son redondos, 

Los radiobutton, son para opciones mutuamente excluyentes, por ejemplo un caso hipotético, en un cuestionario te preguntan "¿Que género eres?", las posibles opciones son "masculino" o "femenino" pero, no puedes tener ambas condiciones a la vez. 

Por último tenemos al ButtonGroup, los radiobutton por si solos no pueden ser mutuamente excluyentes, porque son elementos individuales y si no usamos buttonGroup tendríamos que validar esa característica desde código, pero con un buttonGroup lo hacemos automáticamente.

Imaginemos el ButtonGroup como una caja, donde tendremos unas bolitas -los radiobutton- y cerramos la caja, ahora hacemos una salida en la caja por la cual solo puede pasar una bolita a la vez pero, con la condición de que solo puedes sacar una bolita y si la quieres cambiar tienes que devolverla a la caja, entonces si queremos una bolita podremos sacar una -solamente una-, no podemos hacernos de ninguna más, si queremos otra tendremos que devolver la bolita actual y tomar la otra, en caso contrario los checkbox podemos tener todas las bolitas que queramos.

Desarollo

Ahora si todo bien claro a programar, iniciaremos con el JCheckBox:

 //Creamos nuestra variable global
 private JCheckBox check1;
 //Creamos el método que regresará el checkbox
 private JCheckBox getCheck1() {
 //inicializamo
 check1 = new JCheckBox();
 //le asignamos una posición
 check1.setBounds(80, 30, 20, 20);
 //Decimos que esté seleccionado por defecto
 check1.setSelected(true);
 //por ultimo retornamos
 return check1;
 }

Como ven el método no tiene nada del otro mundo, es muy sencillo crearlos, lo de decir que este seleccionado por defecto es opcional.

 Vamos ahora por el JRadioButton:

 //Creamos la variable Global
 private JRadioButton radio1;
 
 //Método que retorna el radiobutton
 private JRadioButton getRadio1() {
 //inicializamos
 radio1 = new JRadioButton();
 //seleccionamos por defecto
 radio1.setSelected(true);
 //posicionamos
 radio1.setBounds(80, 100, 20, 20);
 //retornamos el objeto
 return radio1;
 }

Es más util usar el selected(boolean) en los radiobutton, para que siempre exista una opción por defecto y no quede vacío.

Bien ya sabemos crearlos entonces, vamos a hacer un ejemplo rápido con estos dos elementos e integramos lo que es el buttonGroup, primero crearemos: seis Jlabel para los textos, dos radioButton y dos Checkbox, acá les dejo el código de todos ellos:

private JLabel getLabel1() {
 JLabel l = new JLabel("Seleccione que le gusta");
 l.setBounds(10, 5, 180, 30);
 return l;
 }

 private JLabel getLabel2() {
 JLabel l = new JLabel("Comer");
 l.setBounds(10, 30, 80, 30);
 return l;
 }

 private JLabel getLabel3() {
 JLabel l = new JLabel("Dormir");
 l.setBounds(10, 50, 80, 30);
 return l;
 }

 private JCheckBox getCheck1() {
 check1 = new JCheckBox();
 check1.setBounds(80, 30, 20, 20);
 check1.setSelected(true);
 return check1;
 }

 private JCheckBox getCheck2() {
 check2 = new JCheckBox();
 check2.setBounds(80, 53, 20, 20);
 return check2;
 }

 private JLabel getLabel4() {
 JLabel l = new JLabel("Genero");
 l.setBounds(10, 80, 80, 30);
 return l;
 }

 private JLabel getLabel5() {
 JLabel l = new JLabel("Masculino");
 l.setBounds(10, 100, 80, 30);
 return l;
 }

 private JLabel getLabel6() {
 JLabel l = new JLabel("Femenino");
 l.setBounds(10, 115, 80, 30);
 return l;
 }

 private JRadioButton getRadio1() {
 radio1 = new JRadioButton();
 radio1.setSelected(true);
 radio1.setBounds(80, 100, 20, 20);
 return radio1;
 }

 private JRadioButton getRadio2() {
 radio2 = new JRadioButton();
 radio2.setBounds(80, 120, 20, 20);
 return radio2;
 }

Hasta ahora todo normal, entonces vamos a crear el buttongroup con el siguiente código:

//Creación del grupo de botones recibe nuestro radiobutton creados
 //anteriormente
 private void getButtonGroup (JRadioButton radio1, JRadioButton radio2){
 //creamos el objeto
 ButtonGroup bgroup = new ButtonGroup();
 //añadimos al grupo el primer radioButton
 bgroup.add(radio1);
 //añadimos al grupo el segundo radioButton
 bgroup.add(radio2); 
 }

Como vemos en un método void y esto ¿porque? ¿no lo deberíamos agregar a nuestro JFrame?, la respuesta es no, lo que agregamos son los radiobutton que pueden estar en distintos lugares nosotros solo usamos dos pero, pueden ser muchos más, entonces, para que se entienda mejor diremos que el grupo de botones trabaja por debajo.

Lo llamamos en el constructor más solo trabaja en lógica, no es un elemento de interfaz.

Finalmente agregamos todos los elementos al JFrame, mi costructor quedaría así:

public Checs() {
   add(getCheck1());
   add(getCheck2());
   add(getLabel1());
   add(getLabel2());
   add(getLabel3());
   add(getLabel4());
   add(getLabel5());
   add(getLabel6());
   // acá se añaden los radiobutton al buttongruop
   getButtonGroup(getRadio1(), getRadio2());
   add(this.radio1);
   add(this.radio2);
   inicializador();
 }

Prestemos atención que llamamos a nuestro método de crear el grupo y le pasamos como parámetro nuestros dos métodos para crear los radioButton, y luego agregamos los radiobutton al JFrame. Al final de todo mi clase queda de la siguiente manera: 

import javax.swing.ButtonGroup;
import javax.swing.JCheckBox;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JRadioButton;

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

 private JCheckBox check1;
 private JCheckBox check2;
 private JRadioButton radio1;
 private JRadioButton radio2;

 public Checs() {
 add(getCheck1());
 add(getCheck2());
 add(getLabel1());
 add(getLabel2());
 add(getLabel3());
 add(getLabel4());
 add(getLabel5());
 add(getLabel6());
 getButtonGroup(getRadio1(), getRadio2());
 add(this.radio1);
 add(this.radio2);
 inicializador();
 }

 private void inicializador() {
 setSize(400, 300);
 setLayout(null);
 setTitle("Aprendiendo Checkbox");
 setLocationRelativeTo(null);
 setVisible(true);
 setResizable(false);
 setDefaultCloseOperation(EXIT_ON_CLOSE);
 }

 private JLabel getLabel1() {
 JLabel l = new JLabel("Seleccione que le gusta");
 l.setBounds(10, 5, 180, 30);
 return l;
 }

 private JLabel getLabel2() {
 JLabel l = new JLabel("Comer");
 l.setBounds(10, 30, 80, 30);
 return l;
 }

 private JLabel getLabel3() {
 JLabel l = new JLabel("Dormir");
 l.setBounds(10, 50, 80, 30);
 return l;
 }

 private JCheckBox getCheck1() {
 check1 = new JCheckBox();
 check1.setBounds(80, 30, 20, 20);
 check1.setSelected(true);
 return check1;
 }

 private JCheckBox getCheck2() {
 check2 = new JCheckBox();
 check2.setBounds(80, 53, 20, 20);
 return check2;
 }

 private JLabel getLabel4() {
 JLabel l = new JLabel("Genero");
 l.setBounds(10, 80, 80, 30);
 return l;
 }

 private JLabel getLabel5() {
 JLabel l = new JLabel("Masculino");
 l.setBounds(10, 100, 80, 30);
 return l;
 }

 private JLabel getLabel6() {
 JLabel l = new JLabel("Femenino");
 l.setBounds(10, 115, 80, 30);
 return l;
 }

 private JRadioButton getRadio1() {
 radio1 = new JRadioButton();
 radio1.setSelected(true);
 radio1.setBounds(80, 100, 20, 20);
 return radio1;
 }

 private JRadioButton getRadio2() {
 radio2 = new JRadioButton();
 radio2.setBounds(80, 120, 20, 20);
 return radio2;
 }
 
 //Creación del grupo de botones recibe nuestro radiobutton creados
 //anteriormente
 private void getButtonGroup (JRadioButton radio1, JRadioButton radio2){
 //creamos el objeto
 ButtonGroup bgroup = new ButtonGroup();
 //añadimos al grupo el primer radioButton
 bgroup.add(radio1);
 //añadimos al grupo el segundo radioButton
 bgroup.add(radio2); 
 }

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

}

Conclusión

Todos los elementos que aprendimos anteriormente, son muy utilizados al momento de crear formularios, debido a que brindan muchas facilidades e inclusive en muchos casos se libera de las validaciones.


viernes, 19 de abril de 2013

Java: Manejo de excepciones con Try/Catch/Finally.

3 comentarios :
Introducción

Las excepciones vienen siendo fallos que se pueden controlar, por ejemplo la división por cero, esto no es un error, sino simplemente es algo que matemáticamente no está definido. En java existen formas de controlar estas excepciones usando los try/catch, en esta entrada se va a explicar como funcionan y como se programan estos try/catch. Además de algunos ejemplo en los cuales nos vendrían a ayudar, a que nuestro programa no se venga abajo por pequeños inconvenientes a la hora de no validar en nuestro código.

Desarrollo

Antes que todo en Java existen errores y excepciones acá les dejo una imagen con algunos (no son todos debido a que hay clases específicas que traen sus propios manejos de excepciones como java.text) errores y excepciones tomada de : http://leo.ugr.es/J2ME/CLDC/transjava/node10.html

Los componentes del try/catch/finally se explican a continuación, dentro del bloque de try se escribe el código inconsistente, en otras palabra, el código que puede llevarnos a tener una excepción, luego viene el bloque catch, la función de este es capturar las excepciones de nuestro código en el try, pueden existir más de una sentencia catch en el conjunto, por ejemplo una para errores aritméticos y otra para un puntero nulo , por último pero no menos importante el finally, el código de este bloque se ejecutará sin importar que haya sucedido en los bloques try y catch.

Para programar esto en Java, se sigue esta estructura base:
  try {
   //Código inconsistente
  } catch (Exception e) {
   //En caso de una excepción
  }
  finally{
   //Código que siempre se ejecutará
  } 


Ahora realizaremos unos ejemplo para entender un poco mejor como funciona este manejo de excepciones.

Ejemplo #1: Crear una Mascara que aprendimos en : maskformatter y jformattedtextfield

MaskFormatter mascara = new MaskFormatter();
  try {
   mascara = new MaskFormatter("?#####");
  } catch (ParseException e) {
    //Por lo general uno coloca esto, lo que
    //hace es mostrar el mensaje de error    
   e.printStackTrace();
  }

Ejemplo #2: La validación de una cadena para saber si es un número:
//Variable que nos dirá si es un número o no
  boolean entero = true;
  //Cadena que evaluaremos
  String cadena = "ABC";
  try{
   //Parseo de String a Integer
   Integer.parseInt(cadena);
  }catch(NumberFormatException nfe){
   //En caso de excepción
   JOptionPane.showMessageDialog(null, "Error " + nfe.getLocalizedMessage());
   entero = false;
  }
  finally{
   //Mostramos el resultado de la evaluación
   JOptionPane.showMessageDialog(null, entero);
  }

Ejemplo #3: Este ejemplo podría parecerles algo tonto pero bueno:
//Declaramos un vector String
  String[] vector = {"1","2"};
  //Recorremos ese vector, pero ATENCIÓN, lo recorremos
  //hasta una posición más de la total (vector.length + 1) 
  for (int i = 0; i < vector.length + 1; i++) {
   try {
    //Codigo inconsistente
    System.out.println(vector[i]);
   } catch (ArrayIndexOutOfBoundsException e) {
    //Mensaje de excepción
    JOptionPane.showMessageDialog(null, "Se salió del vector");
   } 
  }


Conclusiones

El manejo de excepciones es una parte muy importante al momento de realizar aplicaciones, sin importar el lenguaje.
Java brinda esta estructura para un manejo adecuado y ordenado de las excepciones.
Existen muchas clases que tienen excepciones propias por lo cual es nada más investigar cuales son y cuando se producen.

martes, 19 de marzo de 2013

Java: Crear un JAR con recursos desde Eclipse

No hay comentarios :
Introducción

Muchas veces necesitamos trasladar nuestro proyecto Java de un lugar a otro, o de una computadora a otra, y en muchas ocasiones al llegar al destino la aplicación se ve un tanto diferente, más que todo por recursos como imágenes y demás que colocamos en la aplicación.

En esta entrada aprenderemos a como crear un archivo .jar, con el IDE Eclipse, de nuestro proyecto en java.

Desarrollo

Para el ejemplo cree dos clases: una es el Main y la otra una interfaz que solo contiene un mensaje JOptionPane, en esta interfaz cabe resaltar la manera correcta de importar un recurso que sería getClass.getResourse("ruta de la imagen local"). Acá las imágenes del código del proyecto. 




Una vez tenemos nuestro proyecto, presionamos click derecho sobre el proyecto y seleccionamos "Export":



Se nos habrirá una ventana en la cual seleccionaremos "Runnable JAR file"



Luego donde dice "Launch configuration" escogemos nuestra clase main, damos una ruta y nombre del archivo para guardarlo y finalmente seleccionamos "Package requiered libraries into generated JAR" esto lo que hará es que todos los recursos que tenemos en nuestro proyecto se empaqueten junto con el código ejecutable dentro de nuestro archivo JAR de esta manera donde quiera que lo ejecutemos se mostraran los recursos. 

 

Conclusiones

Es muy fácil crear un JAR para poder ejecutar nuestra aplicación en otra máquina, sin embargo se debe tener en cuenta que esa otra máquina donde queramos ejecutar nuestro JAR, debe tener java instalado (JRE).


domingo, 20 de enero de 2013

Java: Swing: JFormattedTextField y MaskFormatter

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

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

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

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

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.

miércoles, 5 de diciembre de 2012

Java: Swing: JLabel

No hay comentarios :
Introducción

Los JLabel son textos que podemos colocar en un Frame, pero además de textos podemos colocar imágenes (animadas o no) para darle una buena presentación a nuestra ventana, los JLabel a mi parecer son esenciales al momento de crear una interfaz de usuario.

Desarrollo

Primero para crear un JLabel necesitamos importar la librería necesaria para eso:
import javax.swing.JLabel;
Ahora por orden y para que se vea bien crearemos un método para cada JLabel que queremos introducir a nuestro frame de manera tal que sea más fácil su ubicación y posterior modificación, esto lo digo porque por internet, se encuentran códigos que tienen todo en el constructor y en ocasiones tienden a confundir y se ve desordenado por eso de mi parte lo encontrarán en métodos separados.

Bien, mi método de un JLabel sencillo sería el siguiente (se supone que ya tenemos un JFrame creado para poder agregarlo, sino mira acá):


//JLabel que agrega un texto
 private JLabel verJLabel() {

  //Se crea el objeto JLabel
  JLabel ejemplo = new JLabel();
  //Le asignamos un texto
  ejemplo.setText("HOLA MUNDO!!");
  //Le damos una ubicación dentro del Frame
  ejemplo.setBounds(30, 10, 400, 200);
  //Le asignamos un tipo de Tipografía
  ejemplo.setFont(new Font("Arial", 0, 18));
  
  return ejemplo;
 }

Para agregar un JLabel con una imagen podríamos hacer algo como esto por ejemplo:

// JLabel que agrega un texto
 private JLabel verImagenJLabel() {

  // Se crea el objeto JLabel
  JLabel ejemplo = new JLabel(new ImageIcon("src/ejemplo.PNG"));
  // Le damos una ubicación dentro del Frame
  ejemplo.setBounds(200, 10, 400, 200);

  return ejemplo;
 }

Como ven los JLabel nos van a ayudar mucho en el desarrollo de nuestras interfaces, mi clase de ejemplo quedaría así:

import java.awt.Font;

import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JLabel;

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

 public JFrames() {
  add(verJLabel());
  add(verImagenJLabel());
  inicializador();
 }

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

 // JLabel que agrega un texto
 private JLabel verJLabel() {

  // Se crea el objeto JLabel
  JLabel ejemplo = new JLabel();
  // Le asignamos un texto
  ejemplo.setText("HOLA MUNDO!!");
  // Le damos una ubicación dentro del Frame
  ejemplo.setBounds(30, 10, 200, 200);
  // Le asignamos un tipo de Tipografía
  ejemplo.setFont(new Font("Arial", 0, 18));

  return ejemplo;
 }

 // JLabel que agrega un texto
 private JLabel verImagenJLabel() {

  // Se crea el objeto JLabel
  JLabel ejemplo = new JLabel(new ImageIcon("src/ejemplo.PNG"));
  // Le damos una ubicación dentro del Frame
  ejemplo.setBounds(200, 10, 400, 200);

  return ejemplo;
 }

}

Y bueno esto es lo básico de los JLabel, acá les dejo la Documentación de Java por si desean saber más: http://docs.oracle.com/javase/8/docs/api/javax/swing/JLabel.html

Conclusiones

Los JLabel son elementos que siempre o en la mayoría de los casos tendremos que utilizar y tendremos que tratar con ellos una y otra vez. 

Para un mejor orden dividir todas nuestras funcionalidades en métodos, para que así se pueda manejar y modificar de mejor manera el código.

Java: Swing: JFrame

No hay comentarios :
Introducción

En java para hacer interfaces de usuario se puede utilizar los JFrame, que vienen siendo las ventanas en las que el usuario puede navegar por la aplicación. En esta entrada y las siguientes aprenderemos sobre este elementos y sobre muchos otros.

Desarrollo

Existen varias formas de crear JFrames en Java pero siempre utilizo una por ser más ordenada y porque me gusta más, que es extendiendo de la Clase JFrame y no creando un objeto JFrame dentro de mi clase, más bien mi clase es el JFrame.

Para crear un JFrame se tiene que importar la librería:

import javax.swing.JFrame;

Luego de importarla vamos a crear un método para inicializar nuestra ventana, debido a que extendemos directamente de JFrame podemos utilizar los métodos de esta directamente, por ejemplo un inicializador sencillo para nuestra ventana sería el siguiente:

private void inicializador(){
  //Tamaño de la ventana
  setSize(800,600);
  //Layout de la ventana
  setLayout(null);
  //Titulo
  setTitle("Mi ventana");
  //Posicion (aparecerá en el centro de la pantalla)
  setLocationRelativeTo(null);
  //Visible
  setVisible(true);
  //Modificación de tamaño (no se puede modificar el tamaño del frame)
  setResizable(false);
  //Cierra el proceso del frame cuando se cierra la ventana
  setDefaultCloseOperation(EXIT_ON_CLOSE);
 }

Este método se tiene que llamar en el constructor de nuestra clase para poder ver nuestro frame, aunque solo con esto nuestra ventana parece aburrida, podemos agregarle componentes con funcionalidades como JLabel, botones, checkBox, radioButon, paneles, barras de desplazamiento entre muchas otras cosas, pero eso será en las entradas siguientes.

Al final mi clase quedará así:

import javax.swing.JFrame;
//Esta linea quita una advertencia (Para el que no le guste tener advertencias)
@SuppressWarnings("serial")
public class JFrames extends JFrame {

 public JFrames() {
  inicializador();
 }
 
 private void inicializador(){
  //Tamaño de la ventana
  setSize(800,600);
  //Layout de la ventana
  setLayout(null);
  //Titulo
  setTitle("Mi ventana");
  //Posicion (aparecerá en el centro de la pantalla)
  setLocationRelativeTo(null);
  //Visible
  setVisible(true);
  //Modificación de tamaño (no se puede modificar el tamaño del frame)
  setResizable(false);
  //Cierra el proceso del frame cuando se cierra la ventana
  setDefaultCloseOperation(EXIT_ON_CLOSE);
 }
}

Con estro creamos una ventana con Java, en la cual podremos colocar diversos elementos.

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

Conclusiones

Los JFrames nos dan la bienvenida a una interfaz de usuario más personalizada y compleja en Java.

Con estas ventanas se pueden realizar acciones e interacciones muy completas.

sábado, 22 de septiembre de 2012

Java: List/LinkedList

No hay comentarios :
Introducción

Java tiene listas que están formadas por un grupo de nodos, estos nodos contienen datos más una referencia al siguiente elemento de la lista (null cuando es el último elemento de la lista), cuando solo tienen la referencia del siguiente se dice que es una lista simplemente enlazada.
En esta entrada aprenderemos como crearla y entender su funcionamiento.

Desarrollo

En Java para importar esta librería se utilizan las siguientes líneas de código:

import java.util.LinkedList;
import java.util.List;

Una lista común y corriente sería inicializada de esta manera:

 List<TipoDato> lista = new LinkedList<TipoDato>();

Analicemos la inicialización anterior:
 - List: tipo de variable.
 - <TipoDato>: las listas van a contener algún tipo de dato ya sea enteros, cadenas, vectores o inclusive puede contener otras listas, esta parte se puede omitir, sin embargo se recomienda colocarla para luego no tener que hacer un parseo o algo por el estilo en el momento que queramos extraer los datos de la lista.
 - lista: nombre de la variable:
 - new LinkedList<TipoDato>();: Se crea el nuevo objeto tipo lista enlazada que va a contener un tipo determinado de varible.

Cuando se inicializa una lista de esta manera algunos métodos propios de la linked list se ven omitidos, por ejemplo agregar al inicio de la lista con solo invocar al método .addFirst(). Pero todo depende de que es lo que queramos hacer.

Para tener un mayor número de funciones en nuestra lista podríamos optar por hacer una linked list:

LinkedList<TipoDato> lista = new LinkedList<TipoDato>();

Importando solo la primera de las librerias anteriormente mencionadas, esto nos daría varios métodos más que nos pueden llegar a facilitar un poco la labor en la utilización de la lista.

Una lista como se mencionó antes está constituida por nodos, para entender mejor esta relación veremos el siguiente dibujo (imagen obtenida de google images):


Como se aprecia el nodo contiene dos campos uno para el dato y otro para la referencia del siguiente nodo, luego tenemos un conjunto de nodos enlazados, conformando así una lista simplemente enlazada.

Algo bueno de esta estructura de datos es ser dinámica, no se requiere decir cuando elementos va a contener (puede contener tantos como la memoria física de la máquina puede almacenar), se pueden implementar los métodos de eliminación, inserción (al inicio, final, o cualquier otro lugar dentro de la lista) y modificación que son los principales funciones que se realizan en las estructuras.

Estas lista funcionan muy parecido a la Clase Vector en la que hablamos en una entrada pasada pasado.

Esta vez no voy escribir los métodos y lo que hacen sino que les dejo directamente la dirección de la documentación de Java:


Les aconsejo que lean bien esas dos páginas para que así tengan un buen conocimiento de los propiedades de las listas y todo lo que se puede hacer con ellas, verán en un futuro que son muy útiles, más no siempre se acoplan a lo que queremos.

Conclusiones

Al ser estructuras dinámicas se facilita su manejo, sin embargo, se tiene que conocer más a fondo para conocer como trabajan.

Ayuda a mejorar el rendimiento de la aplicación debido a que solo ocupa el espacio que requieren los nodos y no reserva espacio como los arrays.

lunes, 23 de julio de 2012

Java: Clase Vector (Parte II)

No hay comentarios :
Introducción

La clase Vector al ser una librería de Java trabaja a través de métodos, en esta entrada se dan a conocer los más comunes y una breve explicación de su funcionamiento.

Desarrollo

Para todos los métodos:
    e: elemento que se quiere agregar al Vector
    index: un entero, que esté dentro del rango de Vector
Ahora sí, los métodos:

 - add(e); agrega un elemento en el final de Vector. 

 - add(index, e); agrega un elemento en una determinada posición del Vector, tenga cuidado de no poner un número que no esté dentro del rango de vector este método se puede utilizar para insertar un elemento en medio de otros. 

 - addElement(e); Agrega el componente especificado al final de este vector. Incremente el tamaño en uno. La capacidad del vector es mayor si su tamaño es mayor que su capacidad. 

 - capacity(); retorna un entero que corresponde a la capacidad que tiene nuestro vector, por defecto contiene una capacidad de 10 elementos, cuando llegamos a un onceavo elemento la capacidad de nuestro vector aumenta en 10, osea, pasaría a tener una capacidad de 20 aunque solo use 11 elementos. 

 - clear(); remueve todos los elementos de nuestro vector.

 - clone(); retorna un clón del vector. La copia contendrá una referencia de un clón de los datos internos del array, no una referencia a los datos internos originales del array.
 
 - contains(e); retorna true si el vector contiene el elemento 

 - elementAt(index); retorna el elemento en esa posición.

 - firstElement(); retorna el primer elemento (la posición cero del vector)

 - get(index); retorna el elemento en la posición indicada
 - indexOf(e); retorna la posición de la primera ocurrencia en el vector del elemento, retorna -1 si no existe.

 - insertElementAt(e, index); inserta un nuevo elemento en una posición determinada los siguientes elementos se "corren" hacia la derecha.

 - isEmpty(); retorna true si el vector no tiene ningún elemento.

 - lastElement(); retorna el último elemento (el tamaño - 1 ).

 - remove(index); elimina el elemento en dicha posición.

 - removeAllElements(); elimina todos los elementos del vector y "setea" el tamaño a cero.

 - set(index, e); reemplaza el valor del índice por el nuevo elemento e.

 - size(); retorna el tamaño del vector.

Conclusiones

Estos son los métodos que usamos más regularmente cuando utilizamos esta clase pero no son todos faltan algunos no los voy a poner acá porque puede ser un poco enredada la explicación así que para los que quieren conocer otros métodos y para que conozcan la documentación de java acá les dejo este enlace: Clase Vector documentación Java


Java: Clase Vector (Parte I)

No hay comentarios :
Introducción

La clase Vector es una estructura dinámica (no como el vector que hacemos comúnmente), esta clase pertenece a las librerías propias de Java, y en ocasiones puede llegar a ser muy útil y es muy fácil de usar.

Esta clase contiene una serie de métodos con los que podemos entre otras cosas: agregar un elemento, remover un elemento, modificar un elemento, insertar un elemento en una posición dada. Otra característica de este "vector" es que al ser dinámico no ocupa que le demos un tamaño predeterminado, el puede agrandarse y encogerse cuando lo requiera así que no va a gastar espacio innecesariamente conteniendo espacios vacíos (al menos que ustedes lo agreguen).

Desarrollo

Para importarlo escribimos esta línea:

 import java.util.Vector; 

La inicialización sería así:

Vector nombreDeMiVector = new Vector();

Esta línea seguro les dará una advertencia o se los subraya en amarillo (si programan en un IDE o algo parecido) pero por eso no se preocupen no les impondrá ningún error en el futuro lo que pasa es que esta clase ocupamos decirle que tipo de valores va a contener (integer, String, Object, entre otros), si lo desean hacen la inicialización como la anterior o para aquellos que nos molesta tener esas cosas amarillas arruinando nuestro código (por pura estética para que el código este lo mas limpio posible) tenemos dos posibilidades:

Podemos incluirle el dato que va a almacenar entre los símbolos de menor y mayor que, de la siguiente manera:

Vector<Dato> nombreDeMiVector = new Vector<Dato>();

Donde "Dato" es el tipo de dato que va a contener, eso si el nombre de la clase, a lo que me refiero con esto si van a hacer un Vector de enteros no pueden poner algo como esto:

Vector<int> nombreDeMiVector = new Vector<int>();

Debe ser la clase, de esta manera:

Vector<Integer> nombreDeMiVector = new Vector<Integer>(); 

La otra manera de quitar esas molestas advertencias es colocando:

@SuppressWarnings("unchecked") 

 Esto lo podemos colocar en varios sitios:

Función local:

Antes del método que contiene el Vector:

@SuppressWarnings("unchecked")
public void metodo(){
    //sentencias
}

Encima de nuestro Vector como tal:

public void metodo () {
    @SuppressWarnings("unchecked")
    Vector vector = new Vector();
}

La anterior en lo personal no me gusta se ve feo una línea de esas en medio del código y puede llegar a confundir.

Función global:

De esta manera si tenemos varios de estas advertencias y no queremos ponerle la línea anterior a cada uno, además que se ensucia el código, se puede colocar antes de nuestra clase de la siguiente manera y con esto quitar las advertencias que corresponda a un unchecked solamente, si existen advertencias de otro tipo no las va a quitar.

@SuppressWarnings("unchecked")
public class Clase{
    // métodos, constructor y variables globales
}

Métodos y su funcionamiento en el siguiente link:

http://www.franvarvil.blogspot.com/2012/07/clase-vector-parte-iiprogramacion-java.html

Conclusiones

La clase Vector es una herramienta muy útil y que puede ser de gran ayuda al momento de la programación.

A pesar de su utilidad se ha visto un poco suplantada por librerías como Linked List.

Al ser una estructura dinámica da un mayor grado de complejidad en el desarrollo de la aplicación, sin embargo, proporciona un mejor rendimiento que vectores o arrays estáticos.

sábado, 14 de julio de 2012

Java: Matrices

No hay comentarios :
Introducción

Una matriz es un arreglo bidimensional que está formada por filas y por columnas que se utiliza para almacenar datos y/o información en cada campo que la compone. En esta entrada aprenderemos como funciona y como utilizarla.

Desarrollo

Una matriz si la representáramos en un dibujo sería de la siguiente manera:


Y ahora se preguntarán ¿Como se programa eso en Java?

Crear una matriz en este lenguaje no es gran cosa, pero su utilización puede ser muy útil dependiendo que es lo que queramos hacer, entonces empecemos.

Para crear nuestra matriz se necesita saber que tipo de dato va a contener ya pueda ser algún tipo de dato primitivo (enteros, caracteres, entre otros) u objetos creados por nosotros, luego colocar dos pares de paréntesis cuadrados "[ ] [ ]", a diferencia de un vector acá utilizamos dos pares de paréntesis cuadrados uno corresponderá a las filas y el otro par a las columnas de nuestra matriz.

Luego le tenemos que dar un nombre a nuestra matriz, ese nombre puede ser cualquiera (el que más se ajuste a los datos que va a contener).

int[][] matrizAnios;
String[][] nombresAlumnos; 
Empleados[][] matrizEmpleados; 
/* Partimos del hecho de que existe una clase empleados con sus características correspondientes */ 

Ahora bien, solo llevamos la mitad de nuestra inicialización el resto creo que ya se nos hará mas común. Luego de lo anterior colocamos el símbolo de igual ("="), el new y luego el tipo de variable de nuestra matriz con sus correspondientes paréntesis cuadrados y el punto y coma (";"), dentro de estos últimos paréntesis cuadrados irán las medidas de nuestra matriz en filas y columnas, siguiendo el ejemplo anterior sería como a continuación:

int[][] matrizAnios = new int[14][14]; // Una matriz cuadrada
String[][] nombresAlumnos = new String[2][3];
Empleados[][] matrizEmpleados = new Empleados[8][120];
/* Partimos del hecho de que existe una clase empleados con sus características correspondientes */

Algo lógico es que no se pueden poner valores negativos en el tamaño de la matriz, por el simple hecho de que una matriz no puede tener por ejemplo "-12" filas, si lo ponen les va a mostrar este error: java.lang.NegativeArraySizeException

Algo que tiene que quedar claro es que una matriz se maneja con dos índices o un par ordenado "(filas, columnas)", donde esos índices son números positivos dentro del rango de tamaño de nuestra matriz, si colocamos valores fuera del alcance de nuestra matriz lo más probable es que se nos venga abajo con un error.

Ahora comenzaremos a hacer ejercicios para entender el funcionamiento de la matriz, para ello llenemos una matriz de enteros de tamaño 10x10, con el siguiente código:

public void llenarNumerosDelUnoAlCien(){
    int[][] numeros = new int[10][10];
    int numero = 1;
    for (int i = 0; i < numeros.length; i++){
        for(int j = 0; j < numeros[0].length; j++){
            numeros[i][j] =  numero++;
            System.out.println(numeros[i][j]);<
        }
    }
}

Bien nuestro método funciona de la siguiente manera:
 - El primer for se encarga de llevar las filas de nuestra matriz (el eje y)
 - El segundo for se encarga de llevar el control de nuestras columnas (el eje x)
 - La condición del primero for es: mientras sea menor estricto que el número de filas que contenga nuestra matriz en este caso son 10.
 - La condición del segundo for es igual que la anterior solo que se coloca un "[0]" para que cuente el número de columnas que contiene.

Se ilustra mejor en el siguiente dibujo los puntos de las condiciones.



Si queremos dar un valor a una posición determinada dentro de la matriz, solo hace falta indicar la posición y el valor que le queremos asignar, ejemplo:

String[][] nombres = new String[3][3];
nombres[0][0] = "Francisco";
nombres[2][2] = "Itzel";

Esto llenaría la primera posición de la matriz y luego la ultima, se ilustra en el siguiente dibujo.


Para obtener un valor se hace lo mismo, supongamos que con nuestra matriz anterior ya con los dos nombres ahora quiero obtener el primero e imprimirlo en consola:

System.out.println(nombres[0][0]);
/*Eso me imprimirá Francisco.*/

Conclusiones

El uso que se le puede dar a las matrices es muy variado, pero, acá les enseño solo lo básico (crearla, asignarle valores, y obtener los valores).

Las matrices son un tipo de estructura de datos estáticos al igual que los arrays o vectores vistos anteriormente, osea, no se puede modificar su tamaño una vez en ejecución.

martes, 1 de mayo de 2012

Java: Vectores o Arrays (Parte II)

No hay comentarios :
Introducción

En la parte uno, sobre este tema se dió una introducción al tema de los vectores o arrays, en esta entrada se darán ejemplos para aprender a trabajar con estas estructuras.

Desarrollo

Otra forma de llenar vectores es asignando los valores cuando se inicializa, a eso se le llama dar valores estáticos debido a que no se llenan los espacios del vector de una manera dinámica, a continuación se da un ejemplo:

String[] vector = {"Una", "Frase", "en", "el", "Vector"};

El vector de String que acabamos de crear tiene un largo de 5 (de 0 a 4), y como ven no hubo necesidad de hacer algo como lo siguiente:

String[] vector = new String[5];
vector[0] = "Una";
vector[1] = "Frase";

Y así sucesivamente hasta terminar la frase o usar el .split() para transformar el String a vector. Click acá para conocer más sobre .split()

En muchos casos necesitamos conocer el largo o tamaño del vector o array, en este caso existe una propiedad de estos que se llama length, esta propiedad lo que nos da a conocer es cuantas posiciones tiene el vector, sin embargo, la cuenta es normal, es decir, empieza en uno y no en cero como cuando se trabaja con el vector. Entonces, si el length nos retorna un cinco, quiere decir que las posiciones van de cero a cuatro.

Utilizando el array creado anteriormente y al imprimir en consola el tamaño, este nos dará como resultado cinco.

System.out.println(vector.length);

Para imprimir todo el vector solo hay que hacer un bucle for, teniendo en cuidado en definir el tamaño del vector adecuado para que no ocurra un desbordamiento.

String palabra ="";
for (int i = 0; i < vector.length; i++) {
    palabra += vector[i] + " ";
}
System.out.println(palabra);

Notar que la condición del for dice solo menor, esto porque el vector cuenta desde cero pero el punto .length no, por tanto, si le colocamos menor igual se desborda, aunque si se escribe el menor igual se puede poner un -1 al final del .length, entones el código quedaría así:

for (int i = 0; i <= vector.length - 1; i++) {
palabra += vector[i] + " ";
}

Ahora ¿para que sirve el espacio que le concatenamos a la posición del vector?, ese espacio es para que las palabras no salgan pegadas una a las otras y que el texto se pueda leer correctamente, si se quita no se van a diferenciar las palabras, por ejemplo:

Impresión con espacio: Una Frase en el Vector.
Impresión sin espacio: UnaFraseenelVector.

En el siguiente ejemplo de uso de arrays o vectores vamos a comparar contenidos.
String[] vector = { "Una", "Frase", "en", "el", "Vector" };
String[] vector2 = { "Una", "Frase", "dentro", "del", "Vector" };
String salida = "Son iguales";

for (int i = 0; i < vector.length; i++) {

    if (!(vector[i] == vector2[i])) {
        i += vector.length;
        salida = "no son iguales";
    }
}
System.out.println(salida);

En este caso tenemos vector y vector2, un String salida que nos dirá si los vectores son o no iguales, el for normal que aprendimos antes para recorrer el vector, le agregamos un if para que nos compare las posiciones con el mismo índice de los dos vectores, si ven bien el if tiene antes de evaluar la condición un signo de admiración se preguntarán ¿para que sirve eso?, bueno ese signo de admiración es para hacer la negación de algo, la condición del if lo que da es un true o false, cuando las posiciones del los vectores se evalúan el if sin el signo de admiración hace esto: ¿son iguales las dos posiciones?... sí... entonces entraría, nuestro if con el signo de admiración hace esto: ¿las posiciones del vector son distintas?... sí... entonces entra. 

Este tipo de evaluación es una alternativa, se puede hacer con != que vendría siendo lo mismo.

Explicaré mejor solo esta parte del if:

    if (vector[i] == vector2[i]) retorna true si son iguales, entonces entra,

    if (!(vector[i] == vector2[i])) la evaluación retorna true si son iguales, pero el signo de admiración lo niega, si recordamos la negación de true es false, por tanto el resultado final es false y no entra.

    if (!(vector[i] == vector2[i])) suponiendo que las posiciones son distintas retorna false, la negación de false es true, entonces entraría al if y terminaría el proceso para que no siga evaluando los demás campos si ya con solo una palabra que sea diferente los vectores serán diferentes y le asigna el otro valor al String salida.

Conclusiones

Existen muchos otros casos y posibilidades al trabajar con arrays que no se explicaron en la entrada, debido a que esta es solo una introducción y el uso que se le dé a los arrays o vectores es muy amplia.

La facilidad de utilizar vectores es de gran ayuda para el programador, porque le facilita realizar tareas con grupos de valores.

viernes, 13 de abril de 2012

Java: Vectores o Arrays (Parte I)

9 comentarios :
Introducción

Cuando se entra al mundo de la programación, una de las primeras estructuras que se encuentran son los vectores o arrays, en esta entrada se explicará que son y como funcionan lógicamente estas estructuras.

Desarrollo

¿Qué es un vector?

Según Wikipedia un vector es una zona de almacenamiento continuo, que contiene una serie de elementos del mismo tipo.

Los vectores se utilizan para almacenar información de una manera más ordenada y de esta forma será mas fácil y rápido de acceder a la información cuando la necesitemos.

Un vector es una estructura estática, que se maneja por índices, cada uno de estos índices es un espacio donde se puede almacenar un valor. Si visualizamos un vector en una imagen sería así:


Como se aprecia en la imagen, los indices del vector empiezan en cero, y cada cuadro contendría adentro un valor específico, en caso que se le hubiera dado uno, de lo contrario aparecerá por defecto como null.

Ahora bien, ¿cómo se crea un vector en java?

La forma de crear un vector en java es sumamente sencilla, es suficiente con agregar los paréntesis cuadrados, "[ ]", al final del tipo de nuestra variable, como ejemplo vamos a crear un vector de Strings, uno de enteros y otro de Object, se procede de la siguiente manera:

String[] vectorDeStrings;
int[] vectorDeEnteros;
Object[] vectorDeObjetos; 

Como ven es muy sencillo es una inicialización normal solo que le agregamos los paréntesis cuadrados, ahora se preguntarán ¿de qué tamaño es el vector? ¿cómo agrego valores dentro del vector? o ¿cuál es la manera de obtener los valores ya asignados al vector?. Todas estas preguntas se resolverán a continuación.

Bueno empezaremos por la primera pregunta, como ven la inicialización de nuestro vector no esta completa, porque necesitamos crear el nuevo vector y darle un tamaño, este tamaño será el número de elementos que el vector pueda contener.

Hay varias formas de darle el tamaño a un vector la más corriente es ponerla al final de la inicialización de la variable dentro de los paréntesis cuadrados, así:

String[] vectorDeStrings = new String[10];
int[] vectorDeEnteros = new int[256];

Como ven esta es la inicialización completa de un vector, ahora un repaso rápido:

 - Se selecciona el tipo de variables que va a contener el vector.
 - Se le da un nombre para identificar nuestra variable.
 - Creamos la nueva variable y le asignamos un tamaño.

Ya nuestro vector está listo!, ahora tenemos que agregar valores a ese vector, esta tarea no es complicada en lo absoluto, en realidad es muy sencillo como veremos con un pequeño ejemplo, con un ciclo for llenaremos un vector de enteros de tamaño 10.

int[] numeros = new int[10];

for(int indice = 0; indice < numeros.length; indice++){

    numeros[indice] = indice + 1;

}

Con este sencillo for estamos agregando valores del cero al nueve a nuestro vector de números, explicaré mas detalladamente este trozo de código:
 - Inicializamos nuestro vector como se explicó anteriormente.
 - Creamos una variable llamada indice, la función de este indice es llevar el control de los campos de nuestro vector, para que agregue cada número en una posición diferente y siguiente de la anterior para que no queden espacios nulos en medio de nuestro vector.
 - Condición indice<numeros.length, esto es para que a la hora de agregar los números al vector no se sobrepase del tamaño del mismo, porque si no nuestro programa se "caeria", la función del .length es medir el tamaño del vector como empieza a contar desde uno el tamaño seria diez pero la posición diez en nuestro vector no existe (porque va del cero al nueve) por eso se pone el "menor que" para que no se desborde debido a que no buscará una posición inexistente en el vector.
 - Se agrega un número al vector en la posición que tenga el valor de indice, como indice empieza en cero, sería en la posición cero del vector agregue el valor de indice mas uno y así sucesivamente.

Ojo, hay que tener cuidado en que índice vamos a guardar la información porque si guardamos un valor en un índice que ya tiene algo contenido, el valor anterior sera reemplazado por el entrante.

Obtener valores de un vector, si vemos gráficamente nuestro vector anterior quedó de la siguiente manera:

[1] [2] [3] [4] [5] [6] [7] [8] [9] [10]

Para obtener el valor de determinada posición se escribe:
 - El nombre de nuestro vector.
 - Paréntesis cuadrados "[]"
 - Dentro de ellos la posición de la cual queremos obtener el valor.

Ejemplo:

Voy a imprimir la suma de las posiciones 2 y 3:

System.out.println(numeros[2] + numeros[3]);

Esto tiene que dar como resultado: 7, por lo siguiente, numeros[2] = 3 y numeros[3] = 4, por tanto 3+4=7, recordar se empieza a contar desde cero en el vector.

Conclusiones

Esta estructura es una de las más básicas en la programación en java y permite generar arreglos que pueden facilitar el control y manejo de variables en la aplicación.

Siempre tener en cuenta que este tipo de vectores son estáticos, es decir, su tamaño no puede variar dentro de la ejecución del programa.