Labores Básicas en Java
Cuando empezamos a desarrollar aplicaciones en Java podemos encontrar un
montón de libros que nos explican los principios sobre el uso de variables,
creación de clases, etc….
Normalmente en las aplicaciones necesitamos hacer ciertas cosas que no
encontramos en muchos manuales y son bastante necesarias.
Vamos a mostraros como empezar a desarrollar aplicaciones Java con NetBeans y
los ejemplos mencionados anteriormente.
Creamos un proyecto
Seleccionamos el directorio de trabajo
Creamos un nuevo paquete (un paquete nos vale para agrupar de un modo lógico
nuestro código y que no entre en conflicto con el código desarrollado por
otros equipos)
Damos nombre al paquete
Añadimos un nuevo elemento, listando todos los disponibles
Seleccionamos una nueva clase principal
Le asignamos un nombre
Vemos la definición básica
Y pulsamos Finalizar … el resto de las opciones de momento no nos interesan.
Vemos el código generado y en azul, una línea para mostrar un mensaje por
pantalla.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
/* * primerPrograma.java * * Created on July 16, 2003, 3:53 AM */ package roberto; /** * * @author Administrator */ public class primerPrograma { /** Creates a new instance of primerPrograma */ public primerPrograma() { } /** * @param args the command line arguments */ public static void main(String[] args) { <font color="#0000FF"><b>System.out.println("Mostramos una cadena de caracteres"); </b></font> |
|
Si pulsamos el botón ejecutar, vemos abajo y a la derecha …. el mensaje
que hemos escrito.
Referencia no Estáticas
La función de entrada, esta declarada como static, lo
que significa que para que se comporte como una clase normal, debemos crear un
objeto (del mismo tipo que la clase) …. que sea quien ejecute realmente el
trabajo.
Podemos ver que también hemos creado una función llamada depura,
donde podemos centralizar todas las salidas por pantalla.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 |
package roberto; /* * primerPrograma.java * * Created on July 16, 2003, 3:53 AM */ import java.text.*; /** * * @author Administrator */ public class <b>primerPrograma</b> { /** Constructor por defecto de la clase */ public primerPrograma() { } /** * Punto de entrada estático de la aplicación * @param args recibe los parámetros de línea de comando */ public static void <b>main</b>(String[] args) { <font color="#0000FF"><b> primerPrograma oInstanciaLocal = new primerPrograma(); oInstanciaLocal.ejecutaProceso(); </b></font> } /** * Ejecutamos el proceso como un instancia local */ private void <b>ejecutaProceso</b>() { depura("El comportamieto ya no es estático"); } void <font color="#008000"><b>depura</b></font>(String pCadena) { System.out.println(pCadena); } } |
|
Formatear números decimales
Cuando trabajamos con valores numéricos, muchas veces debemos
presentar la salida en formatos muy concretos.
En el ejemplo siguiente podemos ver como se formatea por defecto
un número y como podemos definir el formato de los números.
Con esta cadena, «#,#00.0#;(-#,#00.0#)»
definimos el formato para los número positivos y negativos
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 |
package roberto; /* * primerPrograma.java * * Created on July 16, 2003, 3:53 AM */ import java.text.*; /** * * @author Administrator */ public class <b>primerPrograma</b> { /** Constructor por defecto de la clase */ public <b>primerPrograma</b>() { } /** * Punto de entrada estático de la aplicación * @param args recibe los parámetros de línea de comando */ public static void <b>main</b>(String[] args) { primerPrograma oInstanciaLocal = new primerPrograma(); oInstanciaLocal.ejecutaProceso(); } /** * Ejecutamos el proceso como un instancia local */ private void <b>ejecutaProceso</b>() { float fNumero = <font color="#0000FF"><b>2.312f</b></font>; depura("El valor del Float es: " + fNumero); // aplicamos un formateador para definir la precisión y formato de los números <b><font color="#0000FF"> DecimalFormat formateador = new DecimalFormat(</font><font color="#FF0000">"#,#00.0#;(-#,#00.0#)"</font><font color="#0000FF">); </font></b> depura("El valor del Float formateado es: " + <b><font color="#0000FF">formateador.format(fNumero)</font></b>); } |
|
|
void depura(String pCadena) { System.out.println(pCadena); } } |
|
Mostrar enteros en formato
Hexadecimal
En algoritmos complejos se suelen utilizar operaciones a nivel
de bits, utilizando máscaras en formato hexadecimal.
Os mostramos un ejemplo de este tipo de operaciones:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 |
package roberto; /* * primerPrograma.java * * Created on July 16, 2003, 3:53 AM */ import java.text.*; /** * * @author Administrator */ public class <b>primerPrograma</b> { /** Constructor por defecto de la clase */ public <b>primerPrograma</b>() { } /** * Punto de entrada estático de la aplicación * @param args recibe los parámetros de línea de comando */ public static void <b>main</b>(String[] args) { primerPrograma oInstanciaLocal = new primerPrograma(); oInstanciaLocal.ejecutaProceso(); } /** * Ejecutamos el proceso como un instancia local */ private void <b>ejecutaProceso</b>() { <b><font color="#0000FF"> short a = 0xFF; short b = 0xEE; int c = a; c <<= 16; c |= b; depura("El valor de a es: " + c); depura("En base hexadecimal " + </font><font color="#FF0000">Integer.toHexString(c)</font><font color="#0000FF">); depura("En base hexadecimal mayúsculas " + </font><font color="#FF00FF">Integer.toHexString(c).toUpperCase</font><font color="#0000FF">()); </font></b> } void depura(String pCadena) { System.out.println(pCadena); } } |
|
La salida es:
|
|
El valor de a es: 16711918 En base hexadecimal <b><font color="#FF0000">ff00ee</font></b> En base hexadecimal mayúsculas <b><font color="#FF00FF">FF00EE</font></b> |
|
Guardar las preferencias de nuestro programa
Cuando construimos una aplicación, normalmente guardamos las preferencias del
usuario … para cuando vuelva a arrancar la aplicación.
Esta labor se ha normalizado en Java… a través de la clase Preferences
El procedimiento es bastante sencillo y os lo mostramos en el
siguiente código
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 |
package roberto; /* * primerPrograma.java * * Created on July 16, 2003, 3:53 AM */ import java.text.*; import java.util.prefs.*; /** * * @author Administrator */ public class <b>primerPrograma</b> { /** Constructor por defecto de la clase */ public <b>primerPrograma</b>() { } /** * Punto de entrada estático de la aplicación * @param args recibe los parámetros de línea de comando */ public static void <b>main</b>(String[] args) { primerPrograma oInstanciaLocal = new primerPrograma(); oInstanciaLocal.ejecutaProceso(); } /** * Ejecutamos el proceso como un instancia local */ private void <b>ejecutaProceso</b>() { this.escribirPreferencias(); this.leerPreferencias(); } void <font color="#0000FF"><b>escribirPreferencias</b></font>() { try { <font color="#0000FF"> Preferences prefs = Preferences.userNodeForPackage(this.getClass()); prefs.put("clavejava","valorjava"); prefs.flush(); </font> depura("Proceso de escritura ejecutado correctamente"); } catch(Exception e) { depura("Error al escribir preferencias"); } } void <font color="#0000FF"><b>leerPreferencias</b></font>() { try { <font color="#0000FF"> Preferences prefs = Preferences.userNodeForPackage(this.getClass()); String sValorRecuperado = prefs.get("clavejava","valorpordefecto"); depura("El valor recuperado es: " + </font><font color="#FF0000"><b>sValorRecuperado</b></font><font color="#0000FF">); </font> depura("Proceso de lectura ejecutado correctamente"); } catch(Exception e) { depura("Error al leer"); } } void depura(String pCadena) { System.out.println(pCadena); } } |
|
La salida de nuestro programa es
Proceso de escritura ejecutado correctamente
El valor recuperado es: valorjava
Proceso de lectura ejecutado correctamente |
En entorno Windows, esta clave se guarda en el Registro
Comparación entre objetos de
nuestras clases
Cuando creamos una nueva clase y queremos comparar si son
iguales dos objetos de la misma clase, podemos usar el método equals
Si vemos el siguiente trozo de código:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 |
package roberto; /* * primerPrograma.java * * Created on July 16, 2003, 3:53 AM */ import java.text.*; import java.util.prefs.*; <font color="#0000FF">class CEmpleado { String dni; String nombre; CEmpleado(String dni, String nombre) { this.dni = dni; this.nombre = nombre; } }</font> /** * * @author Administrator */ public class <b>primerPrograma</b> { /** Constructor por defecto de la clase */ public <b>primerPrograma</b>() { } /** * Punto de entrada estático de la aplicación * @param args recibe los parámetros de línea de comando */ public static void <b>main</b>(String[] args) { primerPrograma oInstanciaLocal = new primerPrograma(); oInstanciaLocal.ejecutaProceso(); } /** * Ejecutamos el proceso como un instancia local */ private void <b>ejecutaProceso</b>() { <font color="#0000FF"> CEmpleado sRoberto = new CEmpleado("1234", ""); CEmpleado sTambienRoberto = new CEmpleado("1234", ""); depura("El código interno de sRoberto es " + sRoberto.hashCode()); depura("El código interno de sTambienRoberto es " + sTambienRoberto.hashCode()); if (sRoberto.equals(sTambienRoberto) == true) { depura("Lo dos objetos son iguales"); } else { depura("Los dos objetos son distintos"); }</font> } void <b>depura</b>(String pCadena) { System.out.println(pCadena); } } |
|
El resultado obtenido es el siguiente
|
|
El código interno de sRoberto es 3541984 El código interno de sTambienRoberto es 4565111 <b>Los dos objetos son distintos</b> |
|
¿Podría ser?
Es decir, los objetos se consideran distintos porque la representación
interna en Java de ellos es distinta y Java no tiene que realizar ningún trabajo
adicional para hacer la comparación.
Para que el código anterior diese el mismo resultado (dos objetos iguales), podríamos redefinir
el método equals ….
En este caso …. vamos a dar por iguales dos objetos con el mismo DNI
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 |
package roberto; /* * primerPrograma.java * * Created on July 16, 2003, 3:53 AM */ import java.text.*; import java.util.prefs.*; class <b>CEmpleado</b> { String dni; String nombre; <b>CEmpleado</b>(String dni, String nombre) { this.dni = dni; this.nombre = nombre; } <font color="#0000FF"><b> public boolean equals(Object obj) { if( obj instanceof CEmpleado) { CEmpleado oObjetoLocal = (CEmpleado)obj; if(this.dni.compareTo(oObjetoLocal.dni) == 0) { return true; } } return false; } </b></font> } /** * * @author Administrator */ public class <b>primerPrograma</b> { /** Constructor por defecto de la clase */ public <b>primerPrograma</b>() { } /** * Punto de entrada estático de la aplicación * @param args recibe los parámetros de línea de comando */ public static void <b>main</b>(String[] args) { primerPrograma oInstanciaLocal = new primerPrograma(); oInstanciaLocal.ejecutaProceso(); } /** * Ejecutamos el proceso como un instancia local */ private void <b>ejecutaProceso</b>() { CEmpleado sRoberto = new CEmpleado("44", ""); CEmpleado sTambienRoberto = new CEmpleado("44", ""); depura("El código interno de sRoberto es " + sRoberto.hashCode()); depura("El código interno de sTambienRoberto es " + sTambienRoberto.hashCode()); if (sRoberto.equals(sTambienRoberto) == true) { depura("Lo dos objetos son iguales"); } else { depura("Los dos objetos son distintos"); } } void <b>depura</b>(String pCadena) { System.out.println(pCadena); } } |
|
La salida en este caso será:
|
|
El código interno de sRoberto es 3541984 El código interno de sTambienRoberto es 4565111 <font color="#0000FF"><b>Lo dos objetos son iguales</b></font> |
|
Por mantener principios de Java, cuando dos objetos son considerados como
iguales, el metodo hashCode de ambos debe retornar el mismo valor.
Creamos un método (aunque un poco chapuza)
public int hashCode()
{
return Integer.parseInt(dni);
} |
Sobre el
Autor ..
