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.