Heyyyyyyyyyyyyyyy

Aprende a programar microcontroladores en C... http://tecdigitaldelbajio.com/software-tarjeta.html

domingo, 27 de septiembre de 2009

Como se usan los objetos de tipo TableItem



Hoy vamos a aprender como se usan los objetos que provienen de la clase TableItem. Con este tipo de objetos se pueden crear rápidamente tablas que consisten de una o más columnas y de uno o más renglones. Cabe mencionar que la clase TableItem es un componente creado por los diseñadores del NetBeans y no es un estándar qué proviene directamente de las clases de Java Micro Edition, esa es la razón del por qué este componente no está en la ayuda estándar de Java.

La figura siguiente muestra como se ve una tabla creada con objetos de tipo TableItem, en un emulador de un celular, con el cursor se puede navegar entre todas y cada una de las celdas de la tabla.




El componente se encuentra en la paleta de componentes. La figura siguiente muestra la ubicación exacta de este componente en el NetBeans, ya se ha visto con otros componentes, para crearlo, basta con arrastrar y soltar en el Form (puedes dar clic en la imagen para verla más grande si lo deseas).
 

Después de arrastrar y soltar en el Form la tabla, se crea el objeto. La figura siguiente muestra el objeto tableItem en el Form y los pasos que siguen para crear la tabla.



(1) Clic en el objeto TableItem, para seleccionar la Tabla
(2) Se debe elegir un modelo de tabla (table Model) usamos la opción que se muestra “ New SimpleTableModel”
(3) Se da clic en el botón indicado en la figura para crear las columnas y renglones de la tabla.

Realizando lo anterior se muestra un nuevo cuadro de dialogo para crear los renglones y columnas de la tabla. La figura siguiente muestra la creación de una tabla de tres columnas por cuatro renglones.




Siguiendo todos los pasos anteriores ya se tiene lista la tabla ahora lo interesante es ver como se pueden enviar datos a ella.

Enviando datos al objeto TableItem

Para enviar datos a la tabla se usa el objeto simpleTableModel y su método setValue, tal y como se muestra en la sentencia siguiente:
simpleTableModel.setValue(columna, renglón, valorString);

columna = Aqui va el número de columna
renglón = aqui va el número de renglón
valorString = Valor que sedesea que aparezca en la tabla debe ser de tipo String
Por ejemplo la siguiente sentencia envía el número 8 a la columna 3 y el renglón 2

simpleTableModel.setValue( 3, 5, “8”);

Se agrega la instrucción siguiente, para repintar en la pantalla del celular y mostar los cambios agregados a la tabla.
simpleTableModel.fireTableModelChanged();

El método fireTableModelChanged() detecta cuando hay un cambio en algún valor de la celda y repinta la tabla para poder observar ese valor o esos valores

Ejemplo
Realizar un segmento de código para la serie armónica vista en el post anterior para un valor de N=10, enviar los valores que se van generando en cada iteración a una tabla de 2 columnas y 10 renglones, la primer columna debe mostrar el valor de la iteración( 0, 1, 2, 3… 10) y la segunda los cálculos que se van generando de la serie armónica.

Solución

La solución a este problema se analizó en el post anterior, aquí se reproduce completamente el código y se adapta para el valor fijo de N=10 
   suma=0;
   for (int i = 1; i<=10; i++) {
     suma = suma + (float) 1/i;               
   }
   stringItem.setText("El resultado de la serie con N=10 es " + suma);

Si se desea mostrar en la tabla, en la columna el valor de la iteración basta con escribir el código siguiente dentro del ciclo de repetición:
simpleTableModel.setValue(0, i-1, ""+i);

La columna es la 0, y el renglón debe iniciar en 0 (por eso el valor de i-1), recuerde que Ia serie empieza en i=1, después simplemente se muestra el valor, ya se había visto esto, la i es entero y para convertirlo a String y poder usarlo en la sentencia, basta con agregar “” + i y listo se convierte a String y se puede usar en la sentencia.

Como la sentencia anterior, estará dentro del ciclo, además se sabe que la i inicia en 1, entonces este código enviará el valor de 0 a la celda (0,0) después el valor de 1 a la celda (0, 1), luego el valor de 2 a la celda (0,2) y así sucesivamente por que la i va cambiando como ya se vio en el post anterior.

De igual forma para mostrar las sumas acumuladas, solo que estas van en la columna 1, la sentencia es la siguiente:

simpleTableModel.setValue(1, i-1, ""+suma);

Al finalizar el ciclo se agrega la instrucción para repintar la tabla con los nuevos valores y listo, el segmento de código con los cambios indicados arriba, se muestra enseguida:

suma=0;
for (int i = 1; i<=10; i++) {
   suma = suma + (float) 1/i;
   simpleTableModel.setValue(0, i-1, ""+i);
   simpleTableModel.setValue(1, i-1, ""+suma);
}
simpleTableModel.fireTableModelChanged();
stringItem.setText("El resultado de la serie con N=10 es " + suma);

La figura siguiente muestra una imagen con un par de pantallas del emulador de teléfonos celulares con la solución de este ejercicio.



El código anterior, lo probe en el celular Sony Ericsson W595 y funciono bien, a excepción de que al presionar el comando para calcular los datos, habia que mover el cursor una vez entre las celdas para actualizarla y ver el resultado.

Si lo desea el lector puede bajar el código completo de este ejemplo, el archivo esta comprimido en formato RAR, da clic aqui para bajarlo. Al descomprimir aparece la carpeta con todos los archivos generados por el NetBeans, cabe mencionar que esta realizado usando la nueva  versión del  NetBeans la 6.7.1



Clic AQUI para leer más...!

jueves, 24 de septiembre de 2009

Estructuras de repetición: “Ciclo For”



Como su nombre lo indica estas estructuras permiten repetir una o varias instrucciones un número determinado de veces. Existen varios tipos de estructuras de repetición en java:

• Ciclo For
• Ciclo Whie
• Ciclo do-while

Vamos a analizar una por una, hoy se inicia con el ciclo For.

Ciclo For

Un ejemplo vale más que mil palabras, en la imagen siguiente se muestra la sintaxis del ciclo for. El ciclo for de la imagen se diseño para repetir las instrucciones que van en su cuerpo 10 veces.




Veamos como se construye, se usa la palabra reservada

for

Entre paréntesis va la llamada variable de control, esta es la que lleva la cuenta de las repeticiones, se acostumbre llamar a la variable i. La variable de control se debe inicializar en algún valor, se acostumbra el 0, por eso lleva el valor de:

i=0

Aunque puede ser cualquier valor, inclusive números negativos, lo que se requiere para la aplicación. Después sigue el  ; seguido de la condición de finalización del ciclo, que en este caso es:

i <= 10 

La condición de finalización me permite terminar el número de repeticiones, en el ejemplo el ciclo se va a repetir "desde i= 0 hasta que i sea menor que 10", al terminar las 10 repeticiones se continua con el flujo de programa.

Después de la condición de finalización sigue un  ;  para finalmente terminar, con el incremento de la variable de control, de la siguiente forma


i++

Ya se había visto el operador de incremento ++, le suma 1 a la variable i.

A continuación se muestra una animación del ciclo for que está definido en la imagen anterior. Simplemente dar clic en el botón de inicio. La animación muestra la ejecución del ciclo for como si se ejecutará paso a paso el programa usando el debugger. Ahí también se ven los valores que va tomando la variable i, se agrego también un stringItem en el cuerpo del for que también muestra el valor de la variable i.





>


Note como el ciclo se hace 10 veces inicia la i en 0 y termina en 10, solo que al llegar la i a 10 ya no se ejecuta el cuerpo del for, por eso es que la i llega a 10 mientras que el StingItem solo muestra hasta 9.

Se muestra a continuación una serie de ejemplos que se resuelven usando el ciclo for, esto para que el lector vea algunos ejemplos de la aplicación del ciclo. En los ejemplos solo se muestra el segmento de código para el ciclo, dejamos pendiente lo de la interfaz de usuario.

Problema #1

Realizar el segmento de código en Java que sume los primeros 50 números positivos, mostrar el resultado en un stringItem.

Solución.

Un ciclo for que vaya de 0 a 50, puede resolver este problema, la sintaxis es así:

for (i=0; i <= 50; i++) {

}

Nótese que se uso el <= en la condición de terminación para que se incluya el 50. Ahora, para sumar los números, primero recordar que la variable i, toma los valores desde 0 hasta 50 (como se ve en la animación, la variable i, recorre desde el valor inicial hasta la condición de terminación), entonces basta con un enunciado como el siguiente para ir acumulando la suma de los 50 números:

suma = suma + i

Para mostrar el resultado de la suma, al finalizar las 50 repeticiones, se usa el stringItem, usando su método setText y agregando la variable suma, así:

stringItem.setText(“El resultado de sumar los números del 0 al 50 es de “ + suma);

Finalmente se muestra el segmento de código completo conm comentarios para la solución de este problema:

suma = 0; // se inicializa la variable suma en 0
for (i=0; i <= 50; i++) { //ciclo for de 0 a 50
   suma = suma  + i // se acumula la suma
}
stringItem.setText(“El resultado es de “ +  suma); // se muestra el resultado

Por supuesto que ahí no se ve la declaración de las variables, pero la i y la variable suma se deben declarar antes de ese código y deben declararse de tipo int, por cierto el resultado final es de 1275, por si algún lector desea intentar hacer el ejemplo completo en el NetBeans.

Para que el lector tenga confianza al código y sobre todo a la sentencia que acumula la suma se muestra en la siguiente tabla los valores de las variables involucradas para 5 repeticiones (o más comúnmente se les llama iteraciones).

           Suma     I    Suma = suma + i
             0      0          0
             0      1          1
             1      2          3
             3      3          6
             6      4         10
            10      5         15
 
Ejemplo #2

Escriba un segmento de código en java para calcular los valores de la llamada serie armónica que se define como sigue:

X = 1 + 1/2 + 1/3 + 1/4 + 1/5 + 1/6 +1/7 + … 1/N

El programa debe pedir que se ingrese el valor de N paraposterormente realizar el cálculo respectivo de la serie y mostrará el resultado final en un stringItem.

Solución

Se supone que la interfaz de usuario contiene un objeto TextField para ingresar el valor deseado de N, así que otra vez por enésima ocasión se repite el código para capturarlo y convertirlo a entero.


strN = textField.getText();

N = Integer.ParseInt(strN);


Las variables strN debe declarase String y N de tipo int, así el valor que ingresa el usuario para N se debe usar como terminación del ciclo, entonces la definición del ciclo queda así:

for (i=1; i <= N; i++) {
   
}

Note como se inicializa la variable en 1, contrario a los ejemplos de párrafos anteriores ¿Por qué?

Ahora vea la serie del enunciado del problema, vea la fracción siempre hay un 1 arriba en el numerador y abajo en el denominador parece que toma los valores de la variable i, puesto que se observa el denominador así 1, 2, 3, 4, 5, 6, etc… entonces como el ejemplo anterior basta con acumular la suma usando la sentencia siguiente:
Suma = suma + 1/i;
Por cierto, la serie inicia con un 1 por eso se inicializa la variable de control así con 1 (i=1).
El segmento de código completo para solucionar este problema quedaría así:

//**** Ciclo para la solución de la serie armónica ****
strN = textField.getText();
N = Integer.ParseInt(strN);
Suma = 0;
for (i=1; i <= N; i++) {
suma = suma + 1/i
}
stringItem.setText(“El resultado de calcular los valores de la serie es “ + suma);

En este caso la variable suma, hay que declararla de tipo float, por que va almacenar decimales ya que se hace una división (1/i), por cierto, la división 1/i, Java la detecta como una división de enteros y da como resultado un entero, con lo que la parte decimal se desaparece, lo que se hace es forzar la división a tipo float para que me de el resultado correcto, basta con agregar el operador (float) entonces esa sentencia queda asi:


suma = suma + (float) 1/i

Ejemplo #3

Realizar un segmento de código en java para calcular el factorial de un número introducido por el usuario.

Solución


Bueno el clásico programa que calcula el factorial no podía faltar en este blog y más si se está mostrando en el post el ciclo for. Bueno, el factorial de un número es simplemente la multiplicación de los números que van de 1 a dicho número, en matemáticas se dice que la definición de factorial es la siguiente:

n! = 1 * 2 * 3 * 4 * 5 * 6… * N

Bueno hay un caso especial que no cumple esta regla, que es el 0! (factorial de 0) el resultado es 1 por cierto. La interfaz de usuario es igual que el anterior un TextField para capturar el valor de N y un StringItem para mostrar el resultado. Así que la definición del ciclo queda de la siguiente forma:

for (i=1; i <= N; i++) {


 }


Para realizar el factorial basta con ir acumulando pero multiplicaciones, ya se sabe que la variable i toma los valores de 1, 2, 3, 4… así que la sentencia puede quedar así:


Mult = mult * i;

El segmento completo para el factorial queda entonces así:


strN = textField.getText();
N = Integer.ParseInt(strN);
mult = 1; 
for (i=1; i <= N; i++) {
   mult = mult  * i
}
stringItem.setText(“El resultado del factorial es es “ +  factorial);

Vea como la variable que acumula los valores (mult) se inicializa en 1, como son multiplicaciones acumuladas es imposible inicializar en 0 por que entonces todo seria 0 siempre, además recuerde el factorial de 0 es 1, por cierto agregando un if al código anterior se puede determinar el caso especial que es cuando se ingresa un 0, entonces el código completo queda así:

strN = textField.getText();
N = Integer.ParseInt(strN);
If (N == 0) 
    stringItem.setText(“El resultado del factorial es 1”);
else {
    mult = 1; 
    for (i=1; i <= N; i++) {
        mult = mult  * i
     }
   stringItem.setText(“El resultado del factorial es “ +  factorial);
}

Bueno hasta aquí termina este post, para no variar, la próxima entrada mostrará un ejemplo completo con este ciclo, con su respectivo video como se acostumbra


Clic AQUI para leer más...!

sábado, 19 de septiembre de 2009

Uso del Debugger en NetBeans -- Parte II (ejemplo #12)



Al final del post anterior se inicio con lo del depurador de java. Ahí se vio que para iniciar el depurador se hacían dos cosas: Crear un “Break Point” y ejecutar el programa con el botón del depurador.

Al hacer lo anterior se ejecuta el programa, aparece la interfaz de usuario en el emulador. El ejemplo que se está analizando (viene del post anterior) tiene un textField para ingresar una carácter alfanumérico y además un stringItem para mostrar que tipo de carácter es (ver la parte I si no recuerdas esto) haa y un okCommand que al presionarse me indica que tipo de caracter es, es posible ingresar muchos caracteres, pero a final de cuentas solo interesa el primero que se ingresa, la figura siguiente muestra el emulador con el valor que se ingreso que es el “9E” todo ello ocurre justo antes de presionar el botón OK





Al dar clic en el comando OK justo la ejecución se detiene y aparece la línea verde y la barra de herramientas del debugger como se ve en la figura.




Recuerde, la ejecución se detiene cuando el programa llega al break point. A partir de ahí se inicia el análisis del código usando las herramientas del debugger. Justo aquí puedo iniciar la ejecución “paso a paso” con los botones que se muestran en la figura o también presionando F7 y F8.

Ejecutar paso a paso

Permite ejecutar el programa instrucción por instrucción, esto para ir analizando lo que va pasando en el programa, dando clic una vez se ejecuta la instrucción que está en la línea verde, la herramienta se activa también por medio de la tecla F8, a veces resulta más cómodo presionar varias veces la tecla F8 que dar clic con el mouse.

La figura siguiente muestra como cambia la línea verde cuando se presiona dos veces la tecla F8.




Entonces lo anterior significa que se han ejecutado las dos instrucciones siguientes:

Valor = textField.getString();
chValor = valor.charAt(0);

y, recuerde la línea verde indica la próxima instrucción a ejecutarse, en este caso el switch. Bueno como se ejecutaron dos instrucciones es posible saber qué valor tomaron, las variables involucradas en las líneas de código anteriores. El lector ya imaginara que si se ingreso el “9E” y se ejecutaron las instrucciones anteriores entonces las variables involucradas toman los valores siguientes:

valor = “9E”
chValor = ‘9’

Precisamente el debugger sirve para rastrear los errores, él nos puede sacar de dudas para saber si es cierto que toman esos valores, con solo colocar el mouse encima de la variable podemos ver el valor que van tomando, la figura siguiente muestra esto:



De igual forma se puede ver el valor de la variable chValor que es de ‘9’ tal y como se esperaba, recuerde que esa instrucción solo toma el primer carácter de la cadena introducida.

Otra forma de ver las variables y sus valores, sin necesidad de colocar el mouse es desde la ventana de variables, una figura vale más que mil palabras.



Dando clic en “Enter new Watch” se agregan las variables.

En este punto se puede seguir presionando la tecla F7 ( o F8) y seguir ejecutando el programa paso a paso, el lector podrá ver por dónde se va la ejecución del programa cuando es un número (como en este caso), se puede ver que hace lo correcto, el problema es con las vocales.

La solución al problema se puede ver en el video siguiente que muestra todo el proceso desde la creación del código visto en el post anterior, el uso del debugger hasta llegar a corregir el error.




Clic AQUI para leer más...!

sábado, 12 de septiembre de 2009

Uso del Debugger de NetBeans ---Parte I



Hoy se va a mostrar un ejemplo de un programa que tiene varios objetivos de aprendizaje, se pretende mostrar el uso de variables char, también muestra de nuevo la instrucción switch y aparte servirá para mostrar como se usa el depurador del NetBeans, dando clic aquí aquí puedes ver la definición de lo que es un depurador desde la wikipedia.
Ejemplo
Realizar un programa que ingrese un solo valor alfanumérico (letra, número o un símbolo) y que muestre en pantalla si el carácter introducido es un número, o si es una letra, o si es un carácter de otro tipo, cuando se detecte que es una letra deberá decir si la letra es vocal y que vocal es. Para fines didácticos, Restringir el problema solo a las primeras 10 letras del alfabeto (esto para no teclear tanto código a la hora de hacer el video), además todas las vocales y solo letras mayúsculas.

Solución:

Paso 1 Interfaz de usuario

La interfaz de usuario es bien sencilla, requiere de un TextField para que se ingrese el valor alfanumérico y un StringItem para mostrar el resultado, obviamente requiere de un okCommand para ejecutar la acción deseada.

Paso 2 Código

Pues lo de siempre, leer el valor del TextField, este valor recuérdese es de tipo String, lo leemos así:
Valor = textField.getString();
Previamente se declara la variable Valor de tipo String.

Recuerde, el String es una cadena de caracteres, yo solo requiero de un solo carácter, el primero que se ingrese, busco en la documentación de la clase String (se supone que ya se sabe como acceder a la documentación de JME, si no pues da clic aqui), ahí doy clic en la clase String, busco en sus métodos, tengo que encontrar uno que me regrese el primer carácter de la cadena ingresada, no me da trabajo, lo encuentro rápido, es el primer método que aparece en la documentación se llama charAt.
El método, regresa un carácter y dice la documentación que entre paréntesis se coloca el valor del índice, el índice toma los valores de 0 hasta el total de letras de la cadena, así el índice 0 indica el primer carácter el índice 2 indica el segundo carácter y así sucesivamente. Entonces ya esta resulto mi problemita, puedo leer el primer carácter de de la cadena del TextField que está en la variable llamada Valor con la instrucción siguiente:
chValor = Valor.charAt(0);

Previamente se declara la variable chValor de tipo char.

Listo ya tengo le primera letra ¿Qué sigue? Pues saber si es letra, número o símbolo, esto con la nueva instrucción que acabamos de conocer, el switch, así que como se vio en el post anterior, se inicia la instrucción como sigue:
switch (chValor) {
Después de la instrucción siguen los casos, primero hay que saber si, el carácter ingresado es un número, hay 10 posibilidades, se puede escribir de la siguiente forma para detectar cada caso:

       case '0': stringItem.setText("Se ingreso un número" );
                 break;
       case '1': stringItem.setText("Se ingreso un número" );
                 break;
       case '2': stringItem.setText("Se ingreso un número" );
                 break;
       case '3': stringItem.setText("Se ingreso un número" );
                 break;
Y así sucesivamente, dos cosas: una las comparaciones con una variable de tipo carácter se realizan colocando los casos entre apostrofes ‘ ‘, y otra cosa en el problema no se pide que nos digan que número es, simplemente si es número o no, así que es posible reducir los casos anteriores al código el siguiente:
  
       case '0': 
       case '1': 
       case '2': 
         …. Etc.
       case '9': stringItem.setText("Se ingreso un número" );
                 break;
Después de que ya se dejaron listos los casos para los números siguen las letras se procede de igual forma tomando en cuenta las restricciones, solo las primeras 10 letras del alfabeto y solo mayúsculas, las vocales llevan un trato diferente puesto que hay que mostrar que vocal se ingreso en la pantalla, así que las evaluamos después, entonces el código empieza a partir de la letra B, así:
     
       case 'B': 
       case 'C': 
       case 'D': 
       …. Etc.
       case 'J': stringItem.setText("Se ingreso una letra " );
                 break;

Como se menciono arriba, se pide que cuando la letra sea vocal se indique y se muestre en pantalla, el anterior código indica cuando es letra, así que se modifica el caso ‘J’ para detectar la vocal, puesto que ahí en el caso ‘J’, se detectan las letras. Para hacer más emocionante la detección de la vocal se va a realizar con otro switch (si un switch dentro de otro switch). Asi se veria el caso ‘J’:
case 'J': switch( chValor) {
           case ‘A’: stringItem.setText("Se ingreso la vocal A " );
                     break;
           case ‘E’: stringItem.setText("Se ingreso la vocal E " );
                     break;
           case ‘I’: stringItem.setText("Se ingreso la vocal I " );
                     break;
           case ‘O’: stringItem.setText("Se ingreso la vocal O " );
                     break;
           case ‘U’: stringItem.setText("Se ingreso la vocal U " );
                     break;
           default: stringItem.setText("Se ingreso una letra " );
                     break;          
         }
         break;

Finalmente el caso default del switch principal, me permitirá indicar si el valor leído es un símbolo, puesto que es el último caso se puede usar el caso “default”, esto lo realizamos así:
   default: stringItem.setText("Se ingreso un símbolo" );
            break;
}

Ya sin comentarios el presunto código que realiza la solución al problema es mostrado completo enseguida:
   String valor;
   char chValor;
   valor = textField.getString();
   chValor = valor.charAt(0);
   switch (chValor) {
      case '0': 
      case '1': 
      case '2': 
      case '3': stringItem.setText("Se ingreso un número" );
                break;
      case 'B':
      case 'C':
      case 'D':
      case 'F':
      case 'G':
      case 'H':
      case 'I':
      case 'J':switch( chValor) {
                 case 'A':stringItem.setText("Se ingreso la vocal A " );
                          break;
                 case 'E':stringItem.setText("Se ingreso la vocal E " );
                          break;
                 case 'I': stringItem.setText("Se ingreso la vocal I " );
                          break;
                 case 'O': stringItem.setText("Se ingreso la vocal O " );
                          break;
                 case 'U': stringItem.setText("Se ingreso la vocal U " );
                          break;
                 default: stringItem.setText("Se ingreso una letra " );
                          break;
                }
               break;
      default: stringItem.setText("Se ingreso un símbolo" );
               break;
   }

Paso 3 Compilar y probar el código

Después de terminar el código se compila y se ejecuta para probar si hace lo deseado. La figura siguiente muestra la ejecución del programa cuando se ingresa un número (el 3) y una letra (la B).

Bueno hasta ahí parece que todo va muy bien. Ahora vean la siguiente figura donde se muestra el programa, cuando se ingresa una vocal (la E) y un símbolo cualquiera (la @), vean los resultados:

¡¡El código está mal!!, cuando se teclea una vocal se envía el mensaje como si fuera un símbolo, debería enviar que es una vocal, incluso debería enviar que vocal era y no. Tenemos un error en tiempo de ejecución.
Existen varios tipos de errores, los errores de sintaxis cuando se teclea alguna instrucción mal, quizá ya les ha pasado, estos se corrigen fácilmente, porque el NetBeans indica el error automáticamente o si no lo notamos cuando se compila el NetBeans nos indica este tipo de error, hasta que no se corrige se puede ejecutar el programa.
Existen por otro lado los errores en tiempo de ejecución, errores de lógica, errores como el código mostrado en este post, sintácticamente está bien, pero no da el resultado deseado.
Quizá lectores experimentados puedan corregir el error, con solo ver el código, pero quizá en un futuro el código sea más complejo y el error no se nota tan fácilmente, es justo en este punto, donde entra el “debugger” de NetBeans: para identificar errores en tiempo de ejecución.

El Debugger de NetBeans

NetBeans es un entorno poderosísimo, ya se ha visto muchas veces, en los ejemplos de este blog, pero además tiene un poderoso depurador de programas, para, como se menciono en el párrafo anterior, encontrar errores en tiempo de ejecución, el debugger o depurador (lo usaremos indistintamente) permite examinar la ejecución del programa con lujo de detalles.
Para iniciar el depurador se crea un “break point”, justo donde se desea que se analice el código. Para crear el “break point” basta con dar un simple clic con el mouse, como se ve en la figura (1), después se da clic en el botón para ejecutar el debugger (2) y listo.

Se crea el “break point” en el punto donde inicia la lectura de datos del TextField, desde ahí se puede analizar todo el código, al dar clic aparece la línea de color rosa, que significa ya se ha creado el “break point”, al dar clic en el botón para ejecutar con el debugger, el programa inicia su ejecución parece que va todo normal, aparece el emulador, aparece el textField para ingresar el dato, el usuario ingresa el dato y al presionar el okCommand, de pronto la ejecución se detiene y el NetBeans se transforma.
Aparece una línea verde ahora, justo en el “break point” que se había creado, la figura siguiente muestra esto, esa línea verde indica que la ejecución del programa se detuvo y espera la orden del usuario para continuar la ejecución, las ordenes vienen de la barra de herramientas tal y como se observa en la figura siguiente
Desde ahí podemos empezar a realizar el análisis del código, pero eso lo dejamos para otro post, puesto que este ha sido ya muy largo y faltan muchas cosas por analizar.




Clic AQUI para leer más...!

miércoles, 9 de septiembre de 2009

Instrucción de selección Múltiple



Hasta el momento se ha mostrado en el blog, programas que hacen uso de sentencias if que nos llevan a realizar una o dos acciones, aunque usando if’s anidados se pueden realizar más acciones, pero el código se vuelve, podemos decir más complejo.
Existe en java una instrucción que me permite evaluar el valor de una variable y decidir qué acción tomar de una o muchas más acciones, un diagrama de la instrucción se puede ver en la figura siguiente.


Usando esta estructura se evalúa el valor de la variable, esta variable puede tomar “n” valores y según el valor de la variable sigue uno de todos los caminos posibles.

Sintaxis para la instrucción de selección múltiple

La sintaxis exacta de esta instrucción es la siguiente:

Inicia con la sentencia siguiente:

switch ( variable ) {

Entre paréntesis se escribe la variable a evaluar, después de la anterior sentencia se escriben cada uno de los casos posibles, usando las sentencias siguientes:


case 0: //Instrucciones para cuando la variable vale 0
                                                     break;
                                          case 1: //Instrucciones para cuando la variable vale 1
                                                     break;



El break es usado para decirle a Java que se termina el caso y se finaliza la instrucción, se procede de esa forma a colocar los casos necesarios, existe un caso, el denominado “default”, que si no se cumple ningún caso de los anteriores, ejecuta ese caso, su sintaxis es:
                                        
                                          default: //Instrucciones para cuando la variable no cumple ningún caso anterior
                                                    break;

finalmente con una } se cierra el switch y se termina la instrucción. Enseguida se ve un ejemplo para que les quede más claro a os lectores.

Ejemplo

Imagínese que me piden realizar un programa que pida un número entre 1 y 7 y que me diga que día de la semana es, suponiendo que 1 es el día lunes, 2 el martes y así sucesivamente.

Solución

Se crea la interfaz de usuario, se requiere un simple objeto TextField para ingresar el número y un objeto stringItem para mostrar el resultado. Primero se lee el valor usando las sentencia getString() como ya se ha visto infinidad de veces, se cambia el valor a entero, por si el lector no lo recuera enseguida se muestra el código que hace lo dicho anteriormente:

Valor = TextField.getText();
intValor = Integer.ParseInt(valor)


Enseguida se realizan las comparciones respectivas para mostrar el mensaje correspondiente, esto como se imaginaran se puede realizar fácilmente con varios if´s, pero el objetivo es usar la nueva instrucción, la sintaxis de la instrucción de selección múltiple es como sigue:

switch( intValor) {
case 1: stringItem.setText(“El día es lunes”);
case 2: stringItem.setText(“El día es martes”);
case 3: stringItem.setText(“El día es lunes”);
// … etc…
case 7: stringItem.setText(“El dia es lunes”);
case default: stringItem.setText(“ERROR: ingresaste un número incorrecto, debe ser entre 1 y 7”);
}


Para reforzar el tema se muestra en la animación siguiente los caminos que toma la instrucción cuando se ejecuta el código anterior. Basta con que el lector coloque un número en el cuadro de texto y de clic en el botón para que se ejecute la animación, inclusive puede el lector colocar números negativos o mayores a 7 para que vea el camino que sigue el flujo de programa




>



Pues creo que con la animación quedo muy claro comofunciona la instrucción, recuerde, se evalua el valor y se sigue un solo camino de instrucciones de muchos posibles y se termina la instrucción.
Bueno eso es todo de esta instrucción, en el post siguiente mostraremos un ejemplo completo de esta instrucción y hablaremos de cómo buscar errores lógicos en un programa o como comúnmente se le llama se verá como depurar o “debuggear” el programa usando netbeans.



Clic AQUI para leer más...!

sábado, 5 de septiembre de 2009

Más de operadores, tipos de datos y la clase Math



Perdón pero en los algunos post anteriores se uso sintaxis de Java que no se había analizado en ningún lado del blog, este es el momento, se hizo de esta forma para que salieran a la luz los ejemplos #10 y #11, así que empecemos.

Operadores de incremento/decremento y asignación

En el ejemplos #10, se observo la instrucción siguiente

total++
ahí se dijo que “el operador ++ significa incremento”, bueno pues enseguida se ven más operadores como el anterior:

Operador            Descripción              Expresión equivalente

 var1++         Incrementa una unidad          var1 = var1 + 1

 var1--         Decrementa una unidad          var1 = var1 - 1

var1 += var2    Suma las variables             var1 = var1 + var2

var1 - = var2   Resta las variables            var1 = var1 – var2

var1 /= var2    Divide las variables           var1 = var1 / var2

var1 %= var2    Obtiene el residuo de          var1 = var1 % var2
                var1 / var2

Ejemplos

El siguiente segmento de código muestra que valores toman las variables y y x
int x; // x = 0, al declarar una variable se inicializa automáticamente en 0

int y = 3; // y = 3, es posible declarar e inicializar una variable en este caso con 3

x = 5; // se asigna un valor a x de 5

x++; // Se incrementa x, Antes x = 5 después x = 6

y--; // se decrementa y, antes y = 3, después y = 2

x++; // Se incrementa x, x = 7

y--; // Se decrementa y, y = 1

x += y; // equivale a x = x + y, después de la instrucción x = 8

y -= x; //equivale a y = y – x, después de la instrucción y = -7

Tipos de datos

En un post de junio que puedes ver desde aquí se mostraron algunos tipos de datos que maneja Java, ahí se mencionó lo siguiente:

“A continuación se muestran tres tipos de datos que maneja Java:

String. Usado para almacenar cadenas de caracteres.

int. Usado para almacenar números enteros.

float. Usado para almacenar números decimales.

Pues en el ejemplo #11 en algún momento en el video, en el código para calcular el área de un círculo se puede ver que se utiliza la siguiente sentencia:
double area

Esa sentencia me permite declarar una variable de tipo double que en este caso se llama area, esta variable servirá para almacenar el resultado del área.

Las variables double permiten almacenar números con decimales o también llamados números reales, las variables double mucha mayor capacidad que una variable de tipo float, a continuación se muestran más tipos de datos que maneja Java:

boolean. Usado para almacenar una variable booleana cuyo valor es verdadero (true) o falso (false).

byte. Almacena información que no rebase 8 bits, esto equivale a números entre 127 y - 128

char. Se usa para almacenar una letra o un número, o un valor alfanumérico como #, %, $ etc. Estas variables solo almacenan un solo valor alfanumérico.

short. Usado par almacenar números enteros, tiene menos capacidad que variables de tipo int.

long. Usado para almacenar números enteros, tiene mucha más capacidad que variables de tipo int.

Por cierto en el ejemplo #11 se usan variables de tipo doublé, porque la clase Math así lo requería.

La clase Math

Esta clase contiene funciones matemáticas ya diseñadas por los creadores de Java, para que el usuario simplemente las use, por ejemplo, en el post anterior, se muestra la solución de la ecuación cuadrática usando la formula general, para aplicar esta fórmula se necesita obtener una raíz cuadrada, la sentencia que obtiene la raíz cuadrada es:
Math.sqrt(dis);

El método para obtener la raíz cuadrada se llama sqrt, en la sentencia anterior se obtiene la raíz de la variable llamada dis, el método sqrt está diseñado dentro de la clase Math.

También se puede observar como en la parte donde se obtiene el área de un círculo se puede ver que se usa la siguiente sentencia para la formula:
Math.PI

Esta sentencia contiene el valor de la constante PI, 3.1425927, simplemente la usamos como fue el caso.

La clase Math fue diseñada para incluir muchas funciones matemáticas, para que el usuario las utilice, algunas funciones más de esta clase son las siguientes:
   Función                                  Descripción  

Math.sin( double a )          devuelve el seno del ángulo a en radianes

Math.cos( double a )          devuelve el coseno del ángulo a en radianes

Math.tan( double a )          devuelve la tangente del ángulo a en radianes

Math.log( double x )          devuelve el logaritmo natural de x

Math.sqrt( double x )         devuelve la raíz cuadrada de x

Math.pow( double x,double y ) devuelve y elevado a x

La documentación de la clase Math, es bien clara, usa variables de tipo double, esa es la razón de por que se declararon en el ejemplo #11 variables de tipo double, para que fueran compatibles con las funciones de esta clase.
Se anima al lector para que investigue más funciones de esta clase en la documentación de Java, igual y algún día se le ofrece usarlas, en este post se indica como acceder a la documentación ahí se puede buscar la clase Math y ver todos los métodos.



Clic AQUI para leer más...!