Heyyyyyyyyyyyyyyy

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

jueves, 29 de octubre de 2009

La Clase Canvas Parte II



En el post anterior aprendimos a crear una clase que hereda de la clase Canvas, NetBeans crea el código, en este post se va a analizar el código generado. En primer lugar está la definición de la clase la cual ya se hablo mucho en el post anterior, aquí se reproduce:

Public class HelloCanvas extends Canvas implements CommandListener {

     //Aqui va el código generado por NetBeans

}

Esta clase contiene varios métodos generados por NetBeans como ya se mencionó, los cuales se analizan de una forma un tanto superficial porque hay código que no interesa ver en detalle, al menos no ahora pero que NetBeans lo agrega, asi que iniciemos.

Constructor de la Clase HelloCanvas

No se había mencionado nunca en este blog, pero una clase consta de atributos y métodos pero también lleva un método especial llamado constructor.

El nombre del constructor es igual al nombre de la clase, generalmente se usa para inicializar los objetos con valores iníciales, recuerde todo el código analizado en este post, es creado por NetBeans, en el caso del constructor su código generado es el siguiente:



public HelloCanvas() {
  try {
     // Set up this canvas to listen to command events
     setCommandListener(this);
     // Add the Exit command
     addCommand(new Command("Exit", Command.EXIT, 1));
  } catch(Exception e) {
     e.printStackTrace();
  }
 }


Hay mucho código que no es el momento de explicar en detalle todavía, por ejemplo la pareja de instrucciones:


Try {

}
Catch (exeption e) {

}

Sirven para manejar las llamadas excepciones, esto es código que puede lanzar un error en tiempo de ejecución, no nos interesan detalles de esto ahora, recuerde nos interesa realizar el primer ejemplo con interfaces de bajo nivel, así que por lo pronto no diremos más de estas instrucciones

Además el constructor también lleva las siguientes sentencias:

// Set up this canvas to listen to command events
  setCommandListener(this);
// Add the Exit command
  addCommand(new Command("Exit", Command.EXIT, 1));

Con comentarios NetBeans nos explica cada instrucción, en resumen, agrega un exitCommand al Canvas, así al ejecutar el código aparece en la sección de comandos un botón que puede servir para salir de la ejecución, antes no me preocupaba por el código puesto que yo solo arrastraba y soltaba el comando, pero recuerde al usar la clase Canvas hay que hacer todo con código. Entonces el código anterior agrega exitCommand y con la instrucción: setCommandListener deja listo al Canvas para “escuchar” los comandos, en otras palabras para detectar cuando se presiona el exitCommand.

El método paint


Otro método de la clase HelloCanvas es el método paint, se usa para dibujar en el Canvas y mostrarse en la pantalla del celular, en este método se pueden dibujar líneas rectángulos, imágenes etc. pero esto solo se puede hacer por medio de la clase Graphics. Vea el código que genera NetBeans de este método:

public void paint(Graphics g) {
   g.drawString("Sample Text",0,0,Graphics.TOP|Graphics.LEFT);
}


El método lleva entre ( ) lo siguiente:

Graphics g

Esa sentencia crea un objeto de la clase Graphics, el objeto se llama g.

La clase Graphics

La clase Graphics posee todos los métodos necesarios para dibujar en pantalla, mostrar gráficos y mostrar textos. Recuerde, g es el objeto de la clase Graphics, con el objeto creado se pueden usar los métodos de la clase. Por cierto, la clase Graphics tiene muchísimos métodos que me permiten dibujar en el Canvas, como se verá después, por lo pronto entre estos métodos está el método drawString(), que es el que se muestra en el método paint como se ve en la sección anterior.

El método se llama drawString y sirve para dibujar una cadena de caracteres dentro del Canvas, La figura siguiente muestra la descripción de cada parámetro del drawString:






El texto “Sample Text” es el que aparece en la pantalla del celular, después siguen las coordenadas de ubicación del texto que en este caso es (0, 0), después sigue el punto de referencia para situar el texto, en este post no nos interesa ese punto de referencia, luego se discute más a detalle.


Por cierto J2ME divide la pantalla del celular en puntos denominados pixeles el primer punto se ubica en la coordenada (0, 0), la figura siguiente muestra el sistema de coordenadas de Java Micro Edition:





Bueno después de los detalles sigamos con el código que genera NetBeans para la clase HelloCanvas

Métodos para detectar eventos relacionados con las pulsaciones de una tecla

Siguiendo con el código de la clase HelloCanvas se tienen los siguientes métodos en la clase:

protected  void keyPressed(int keyCode) {
}
protected  void keyReleased(int keyCode) {
}
protected  void keyRepeated(int keyCode) {
}


La siguiente tabla describe que hace cada método:

   Método                            Descripción                 
keyPressed()              Se ejecuta cuando se presiona una tecla
keyReleased()             Se ejecuta cuando se suelta una tecla
keyRepeated()             Se ejecuta cuando se deja presionada una tecla

Métodos para detectar eventos relacionados con apuntadores


También la clase Canvas tiene métodos para detectar los eventos relacionados con
apuntadores o mouse estos los genera Netbeans y son:

protected  void pointerDragged(int x, int y) {
}
protected  void pointerPressed(int x, int y) {
}
protected  void pointerReleased(int x, int y) {
}

Cabe aclarar que estos métodos solo son validos en dispositivos que lo soportan, no todos los celulares tienen un apuntador, asi que no se ven más detalles de estos métodos.

Metodo para procesar comandos

El último método de la clase es mostrado en seguida:

public void commandAction(Command command, Displayable displayable) {

}


Cuando se presiona un comando ya sea un okCommnad o un exitCommand se invoca o se ejecuta el método commandAction(), entonces este método me sirve para procesar los comandos.

Bueno ahora si por fin se tienen todos los medios para realizar un ejemplo completo que muestre el mensaje "Hola Mundo" usando Canvas, pero esto lo dejamos para el siguiente post.



Clic AQUI para leer más...!

jueves, 22 de octubre de 2009

La Clase Canvas



Introducción

La siguiente figura muestra la ya conocida jerarquía de clases de Java Micro Edition. Ahí se ve claramente las clases que se han usado a lo largo de este blog, con las cuales se crean programas con las llamadas interfaces de alto nivel.




Vea la figura, también está la clase Canvas usada para crear las interfaces de bajo nivel, desgraciadamente esta clase se maneja diferente a lo visto hasta ahorita en el blog, la clase Canvas, NO SE PUEDE ARRASTRAR Y SOLTAR, como las clases que crean interfaces de alto nivel vistas en los ejemplos de este blog, el tratamiento es diferente como se ve a continuación, así que comencemos a analizarla.


La clase Canvas

La clase Canvas es usada para crear las interfaces de bajo nivel. Esta clase contiene los mecanismos necesarios para usar la pantalla del celular como una zona de dibujo, se puede dibujar cualquier cosa en la pantalla, esta clase es usada por los desarrolladores de juegos para celulares porque permite tener control total sobre lo que se dibuja en la pantalla del celular, se tiene un control incluso sobre cada punto de la pantalla (por cierto cada punto en la pantalla es llamado pixel).

Con objetos de esta clase se tiene acceso directo a la pantalla del celular la cual tiene una área de dibujo y un área de comandos, como se observa en la figura siguiente:



La clase Canvas fue diseñada por los creadores de Java como una CLASE ABSTRACTA esto según las reglas de la programación orientada a objetos significa que no se pueden crear objetos (o instancias) a partir de ellas.

Recordemos un poquito los conceptos de la programación orientada a objetos, una clase contiene la definición de atributos y métodos que hacen algo, por ejemplo, la clase TextField, que se ha usado en muchos ejemplos, contiene el método que también ya se ha visto muchas veces: getString(). Este método lo que hace es obtener los caracteres que se han ingresado en el TextField, y los asigna a una variable.

Veamos, La clase se llama TextField, uno de sus método se llama getString(), pero recuerde, una clase es una plantilla para crear objetos, entonces para usar el método getString(), Yo necesito un objeto (o instancia) de la clase, el objeto es creado automáticamente por NetBeans, y como se ha visto en los ejemplos Netbeans le asigna el nombre de textField, si hay mas Netbeans les llama textField1, textField2, etc. Estos objetos NetBeans los genera yo no me preocupo por crearlos, yo lo único que hacía era escribir:

textField.getString();
para obtener el texto ingresado en el textField.

Otra vez, la clase se llama TextField, uno de sus métodos se llama getString(), para usarlo se requiere un objeto o instancia llamado textField, pues la clase Canvas no acepta la creación de instancias, entonces yo no puedo hacer uso de sus métodos, por ejemplo la clase Canvas tiene un método llamado paint( ). Este método me permite realizar dibujos en la pantalla del celular, pero no lo puedo usar por que la clase Canvas es abstracta, entonces estamos en un problema, por un lado necesito de la clase Canvas para dibujar en la pantalla, pero por otro lado no puedo usar la clase por que es abstracta. Pero todo se soluciona bien simple, como a continuación se explica.

Creación de clases en java

Para solucionar el problema de las clases abstractas, se crea otra clase por ejemplo una clase llamada miCanvas o el nombre que se desee.

El código para crear una clase en java es bien simple, así:

class miCanvas {


   // aqui van los atributos y métodos de la clase



}

Esa es la sintaxis para crear clases en java: la palabra reservada class, el nombre de la clase y las { }.

Otro ejemplo es:

class HelloCanvas {






}

La clase se llama HelloCanvas, recuerde ese nombre yo se lo asigno como yo lo desee.

Vemos, por un lado se tiene la clase HelloCanvas (o como se llame) y por otro lado se tiene la clase Canvas, obviamente no existe relación alguna entre ellas, son entidades diferentes, para relacionarlas se usa la HERENCIA, la herencia se agrega con la palabra “extends” de la siguiente forma:

class HelloCanvas extends Canvas {




}

Significa que la clase HelloCanvas, hereda todos los métodos y atributos de la clase Canvas, en otras palabras, con la herencia ya puedo usar el método paint() de la clase Canvas, porque ya hay una relación con la clase miCanvas. ¿Me explique?



Recuerde, la clase Canvas no permite crear instancias a partir de ella, pero la clase miCanvas creada por nosotros si permite crear objetos, por que no es abstracta, y como llevan una relación de herencia, puedo usar el método paint() para dibujar en la pantalla cualquier gráfico.

Otra cosa, la clase Canvas es “public” por eso yo puedo agregar la herencia desde la clase miCanvas, por lo que se recomienda que las clases creadas por nosotros sean públicas también, para crearlas públicas simplemente anteponga la palabra “public” así:

public class HelloCanvas extends Canvas {


}


“public” significa que la clase es pública y puede ser usada desde otra clase o desde otro paquete de clases.

Creación de la clase HelloCanvas desde NetBeans

Para crear la clase HelloCanvas desde NetBeans, primero se debe crear un proyecto, déspues se pueden seguir dos opciones similares a las del post anterior:

1. Desde el menú de NetBeans presionar:

                   File> New file…

Al hacerlo aparece el cuadro de dialogo para crear un nuevo archivo, ahí se elije como en la figura siguiente:



2. Otra opción para crear la clase HelloCanvas, es dando clic derecho en el proyecto que se creó y eligiendo New y luego la opción MIDP Canvas, tal y como se observa en la figura siguiente:



Cualquiera de las dos opciones anteriores me lleva a la pantalla siguiente para asignar el nombre a la clase:



Simplemente se da clic en el botón de Finish, para que termine la creación de la clase HelloCanvas, al proyecto se le agrega el archivo llamado HelloCanvas.java, al dar doble clic en el nombre, esté se abre en la pantalla del netBeans apareciendo el código de la clase HelloCanvas como lo muestra la figura siguiente:



Vea el código que genera NetBeans para la clase HelloCanvas, vea la definición de la clase, al iniciar el código se puede ver, es así:
Public class HelloCanvas extends Canvas implements CommandListener {


     // Aquí va el código generado por NetBeans


}

Es exactamente lo que mencionamos arriba más “implements CommandListener”. Esa instrucción permite que el celular detecte los exitCommand, o los okCommand, nunca se había visto esto porque, en los ejemplos realizados NetBeans generaba automáticamente esas instrucciones.

No se va a hablar mucho del “implements” nos llevaría un post completo, ahorita no me interesa los detalles, basta con decir que sirve para detectar los comandos en el celular.

Hasta aqui le vamos a dejar hoy, ya casi se acaba la teoria, nos falta analizar el código que generó NetBeans en la clase HelloCanvas y finalmente enlazar el código del MIDlet con el código de la clase HelloCanvas, para crear el primer programa usando las interfaces de bajo nivel, les ruego paciencia.



Clic AQUI para leer más...!

lunes, 19 de octubre de 2009

Ciclo de vida de un MIDlet



Introducción

Todos los 13 ejemplos completos vistos en este blog han sido creados usando, Form, TextField, StringItem, List, etc. objetos usados para crear las interfaces de usuario, en Java ME, las interfaces creadas con esos objetos se les conoce como Interfaces de alto nivel.

Pero aquí hacemos un paréntesis, lo fuerte de Java Micro Edition no son las interfaces de alto nivel, y los programas que se pudieran realizar con ellas, lo fuerte de java es la programación de juegos, es el campo donde Java ME ha tenido el mayor éxito, vea su celular ¿Cuántos juegos tiene? Pues la mayoría de esos juegos son programados en java, para programarlos se requiere tener control completo de prácticamente cualquier punto de la pantalla del celular, esto se le conoce como programación de interfaces de usuario de bajo nivel.


“El blog que te enseña a programar teléfonos celulares” no estaría completo si no enseña la programación de bajo nivel. Justo el post de hoy y los subsiguientes hablaran de este tipo de programación, incluso es más interesante (bueno a mi me parece) este tipo de programación que lo que se ha visto ahora, así que si, los ejemplos anteriores les han parecido interesantes pues ahora los ejemplos que vienen les gustarán más ya lo verán. Pero antes hay que ver algo de teoría :(


Ciclo de vida de un MIDlet

Los 13 ejemplos completos que se han visto en el blog tienen un ciclo de vida, nunca les había mencionado esto, pero todos, absolutamente todos los programas de Java Micro Edition, siguen ese ciclo de vida, nosotros no nos percatamos de ello porque el ciclo de vida del MIDlet, lo maneja el dispositivo donde se está ejecutando, en la mayoría de los casos un teléfono celular.

El ciclo de vida de un MIDlet consta de tres estados

• Pausa
• Activo
• Destrucción

La figura siguiente muestra un diagrama de estos tres estados:



Descripción del ciclo de vida
Debe quedar claro que el ciclo de vida del MIDlet es gestionado por el sistema operativo del teléfono celular. Cuando se carga el archivo JAR al celular el sistema operativo del teléfono detecta que es un MIDlet y pregunta si deseas iniciarlo, al aceptar es cuando inician los estados anteriores.

Primero el MIDlet se coloca en pausa, un instante después el sistema operativo hace que el MIDlet pase al estado activo, justo es cuando se manda llamar un método llamado startAPP(), en este estado, se muestra la interfaz de usuario el Form, los StringItem o los TextField o lo que lleva la aplicación.

El MIDlet en el estado activo se queda haciendo lo que se le programo. Pero puede haber eventos externos que interrumpan al MIDlet, por ejemplo, si se recibe una llamada cuando se está ejecutando el MIDlet este se coloca en pausa llamando al método pauseAPP (por eso en la figura se ve una flecha de regreso al estado de pausa) y pues el usuario puede contestar la llamada y después volver a regresar al MIDlet, finalmente cuando el usuario desea salir del MIDlet es cuando este se destruye de la memoria y es cuando pasa al estado de destrucción y se liberan los recursos ocupados por él.

Vuelvo a repetir, estos estados los gestiona el sistema operativo del celular, yo no tengo nada que ver así que estrictamente hablando el ciclo de vida del MIDlet no me importa  o ¿acaso nos ha importado ya después de haber realizado 13 ejercicios completos desde que inicio el blog? Entonces ¿porque lo vemos?, quizá se estén preguntando, la razón es sencilla si quiero programar las interfaces de bajo nivel, los gráficos y en un futuro los juegos necesito hacer uso de los métodos involucrados en los ciclos de vida del MIDlet.

Estructura más básica de un midlet

Regresemos a la figura anterior, cuando se lanzan cada uno de los estados, se ejecutan también los métodos que ahí se indican y que aquí los vuelvo a escribir:

startAPP()
• pauseAPP()
• destroyAPP()

Esos métodos son parte del código del MIDlet, en todos nuestros ejemplos que se han realizado, estos métodos son generados por el NetBeans cuando se crea el proyecto para un MIDlet nuevo, por eso yo ni me preocupaba por ellos porque el NetBeans los genera automáticamente, si lo deseas puedes ver el código de alguno de los ejemplos que hayas realizado, en algún lado puedes identificar esos métodos.

NetBeans genera mucho código automáticamente para crear un MIDlet, este código generado me permite simplemente arrastrar y soltar elementos o comandos desde la vista de flujo, pero es posible crear un MIDlet con muy poquito código, el listado que a continuación se muestra crea un MIDlet que no hace absolutamente nada, pero contiene los elementos más básicos que debe tener el MIDlet.

import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;


public class Midlet extends MIDlet {


   public void startApp() {


   }
   public void pauseApp() {


   } 


   public void destroyApp(boolean unconditional) {


   }
}


Ahora se procede a analizar el código, por ejemplo las siguientes instrucciones

import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;

Sirven para poder usar la gran cantidad de clases ya diseñadas por los creadores de Java, por ejemplo las clases que ya se han usado en los programas como la clase TextField, StingItem, CohiceGroup etc. están definidas dentro del paquete de clases: javax.microedition.lcdui.*; por eso si yo las voy a utilizar en mi programa debo importar ese paquete de clases, otra vez lo repito en nuestros ejemplos no se hizo la importación por que NetBeans lo realiza por nosotros, cuando creamos el proyecto.

Después de importar las librerías o paquetes, viene la declaración de la clase para crear un MIDlet, el código es así:

public class Midlet extends MIDlet {


}

Recuerde, en java todo absolutamente todo es o proviene de una clase, así que un MIDlet no es la excepción, para su creación se crea una clase, en este caso la clase es llamada Midlet (class Midlet), es de tipo “public”, el echo de que sea public significa que se puede acceder a ella desde otras clases, pero estos conceptos ahorita no nos interesan, en su momento se detallaran más.



Igual pasa con la palabra “extends”, que en java significa herencia (luego se verá con más detalle). La herencia significa que la clase Midlet, hereda todos los atributos y métodos de la clase MIDlet, esto es por regla general, los creadores de Java fueron bien claros, todos absolutamente todos los MIDlets desarrollados por los usuarios tienen que heredar de la clase base, la clase MIDlet. En pocas palabras si yo no defino el MIDlet así no funciona nada, es la regla, así está diseñado el lenguaje y pues nosotros que apenas iniciamos nos apegamos a esas reglas, a esa sintaxis aun cuando todavía no me quede claro la herencia o las clases públicas, más adelante se entenderán.

Después de declarar la clase vienen los métodos, el primero es así:

public void startApp() {


}

Ese es el método que se ejecuta cuando el sistema operativo del celular pase al MIDlet del estado de pausa al estado activo. Por regla general este método se agrega siempre, lleve o no lleve código, bueno y también los otros métodos: pauseAPP y destoyAPP(), si no los agrego al código se tendrá un error de compilación, el porqué tienen que ir a fuerzas, no nos interesa por el momento, nos llevaría un buen rato la explicación y no es el momento, por lo pronto yo me conformo con saber que se tienen que agregar y listo.

Como crear un MIDlet con el código básico desde NetBeans

Desde NetBeans es posible crear un MIDlet con el código base, y esto lo hacemos porque ahora para los ejemplos que siguen nos interesan las interfaces de bajo nivel, así que simplemente necesitamos el código básico para ello, para obtenerlo, basta con seguir los pasos siguientes:

Paso 1 crear un nuevo proyecto

El primer paso es crear un nuevo proyecto desde NetBeans, pero ahora se hace lo que indica la figura:



No se selecciona el HelloMidlet, los 13 ejemplos si lo hacían, recuerde por lo pronto no nos interesa la interfaz de alto nivel, aunque en un futuro vamos a mezclar las dos he¡¡ pero por lo pronto no.

Lo que se muestra en la figura es lo único diferente que se realiza con respecto a los 13 ejemplos anteriores, con eso basta para que NetBeans no genere el código automáticamente

Paso 2 Agregar el MIDlet al proyecto

Con lo anterior se crea el proyecto para NetBeans pero sin código alguno así que podemos seguir dos caminos que nos llevan a la creación del archivo más básico de java:

1. Desde el menú de NetBeans presionar:

File> New file…


Al hacerlo aparece el cuadro de dialogo para crear un nuevo archivo, ahí se elije como en la figura siguiente:



2. Otra opción para crear el archivo más básico es dando clic derecho en el proyecto que se creó y eligiendo New… y luego la opción MIDlet, tal y como se observa en la figura siguiente:





Cualquiera de las dos opciones anteriores me lleva a la pantalla siguiente para asignar el nombre al MIDLet


Por defaul viene el nombre del MIDlet como Midlet si lo deseamos se deja así y simplemente se da clic en el botón de Finish, para que termine la creación, al proyecto se le agrega el archivo llamado Midlet, esté se abre en la pantalla del netBeans pareciendo el código más básico para un MIDlet como lo muestra la figura siguiente:


Eso es todo lo del post de hoy, ya son las 12:46, creo que es hora de dormir, en la siguiente entrada realizaremos el clásico ejemplo del Hola mundo, versión gráfico, o sea usando la interfaz de bajo nivel.



Clic AQUI para leer más...!

miércoles, 14 de octubre de 2009

Estructuras de Repetición: Ciclo While y Ciclo Do-while



Seguimos viendo más sintaxis de java. Hace varias entradas del blog se inicio con las estructuras de repetición, específicamente con el ciclo for, pero existen otras, hoy vamos a ver dos más.

Ciclo While

Una estructura de repetición permite repetir una o varias instrucciones un determinado número de veces. El ciclo “while” repite las instrucciones “mientras” la condición de terminación sea verdadera, si es falsa se termina el ciclo y se pasa a la siguiente instrucción. Su sintaxis se muestra con un ejemplo:

     x = 0; // Inicialización de la variable de control
     while (x <10) {  // condición, repite mientras x sea < 10
         // Aquí van las instrucciones que se repiten
         x++; // Incremento de la variable de control
     }


Este ciclo requiere de una variable de control, esta es la encargada de indicar si se siguen repitiendo las instrucciones o ya no, en el ejemplo se llama “x” pero puede ser cualquier nombre de variable, generalmente es de tipo entero y se inicializa en 0, aunque esto no es obligatorio, puede ser de otro tipo o puede inicializarse con otro valor diferente a cero, depende del ejercicio que haga, pero en este ejemplo se inicializa en 0 con la instrucción:

x = 0;

Después sigue la palabra reservada “while” que significa “mientras” y un paréntesis donde se escribe la condición de terminación del ciclo, después se abre la { que agrupa el total de instrucciones a repetir, en el ejemplo el código del que se habla es este:

        while (x <10) {

        }
En este caso la condición de terminación es:
x < 10

Lo que significa que el ciclo se va a repetir “mientras” x sea menor a 10, cuando x es mayor a 10 se termina el ciclo y se siguen las instrucciones que van después de la }.

Después se ingresan las instrucciones que se van a repetir y antes de terminar el ciclo se debe incrementar la variable de control, esto es:

x++

Sin ese incremento no se terminaría nunca el ciclo, porque entonces la x nunca sería mayor a 10. Bueno eso es todo, lo del ciclo while por supuesto que todo se aclara más con ejemplos, así que iniciemos:

Problema #1

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

Solución

Como se indica arriba, todo inicia con la variable de control, hay que inicializarla en 0, como se van a sumar los números se requiere de otra variable, la llamaremos suma, también se inicia en 0. La inicialización queda entonces así:

        x = 0;
        suma = 0;

Enseguida va la palabra reservada “while” junto con la condición de terminación, en este caso se desea sumar los primeros 50 números positivos, entonces se requiere un ciclo de 0 a 50, la condición de terminación es pues x <= 50, el código seria:

        while (x <= 50) {

        }
 
La variable de control debe incrementarse dentro del ciclo, esta inicia en 0, luego se incrementa a 1, 2, 3, etc., hasta 50, así que basta con una instrucción como esta para acumular la suma cada que x toma un valor:
suma = suma + x;

Despues se debe incrementar la variable de control, usando la instrucción de incremento:
x++

Para mostrar el resultado se usa el método setText del Stringitem. Finalmente el código completo seria:
        x = 0;
        suma = 0;
        while (x <= 50) {
           suma = suma + x;
           x++;
        }
        stringItem.setText(“la suma de los primeros 50 números es : “ + suma);



Ciclo Do-While
Este ciclo es idéntico al anterior, se repiten las instrucciones “mientras” la condición es verdadera, la diferencia es que la condición de terminación se evalúa hasta el final, la sintaxis se muestra con un ejemplo.

       x = 0;  // Inicialización de la variable de control
       do {
           // aquí van las instrucciones que se repiten
           x++;  // Incremento de la variable de control
       } while ( x<10)   ;  // evaluación de la condición de terminación
Igual que el ciclo anterior todo empieza con la inicialización de la variable de control, en 0.
x = 0;

Después se escribe la palabra reservada do con una { que junto con la otra } agrupan las instrucciones que se repiten, justo antes de cerrar con la } se debe incrementar la variable de control con la instrucción ya conocida:

x++

Después de } se agrega el while y la condición que en este caso es x < 10, entonces en este caso el ciclo se estará repitiendo “mientras x sea menor o igual a 10”.

A continuación se muestra el mismo ejercicio que el ciclo anterior.

Problema #1

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

Solución

Como se indica arriba, se inicializan las variables con el código siguiente:

           x = 0;
           suma = 0;

Enseguida se abre el ciclo con la instrucción
do {

En el cuerpo del ciclo van las instrucciones para sumar los números y el incremento de la variable de control:

           suma = suma + x;
           x++

Al final va la palabra while junto con la condición de terminación, así:

} while ( x <= 50);

La sentencia finaliza con ; el código completo es:

                 suma = 0;
                 x = 0;
                 do {
                     suma = suma + x;
                     x++;
                 } while ( x<= 50)   ;
                 stringItem1.setText(" la suma es:" + suma);

Bueno se presenta en esta entrada dos ciclos más, solo se ve un ejemplo pero a lo largo de este blog se presentarán muchos más.

¿Cual ciclo elegir?

Como ya se vio, existen tres tipos diferentes de estructuras de repetición, ¿cual usar?, depende de la aplicación, del problema que se desea resolver, pareciera que el ciclo for es más fácil de usar, y si lo es, por facilidad se recurre a el, pero los otros ciclos tienen sus ventajas sobre el for, una de ellas es que puedo evaluar dos o más condiciones, cosa que con el for resulta imposible, en conclusión la elección del ciclo depende del programa que se desea solucionar, pero esto con la practica, realizando programas y mas programas uno mismo sabrá cual ciclo conviene más. Hasta la próxima.



Clic AQUI para leer más...!

miércoles, 7 de octubre de 2009

Objetos TextBox y lectura de datos desde un objeto TableItem



Las dos entradas anteriores del blog muestran como se envía información hacia objetos TableItem, hoy se aprenderá como editar un valor dentro de la tabla y luego leerlo para finalmente hacer algo con esos valores.

 Por ejemplo si se desea realizar un programa que calcule el promedio de 5 calificaciones, pues para realizar este ejemplo es necesario conocer las calificaciones, para después sumarlas y finalmente obtener el promedio, bueno pues esas calificaciones pueden ser capturadas en una tabla.


Bueno esto que aprenderemos hoy es otra opción para capturar datos aparte de un TextField, yo les dejo el ejemplo, ustedes piensen en sus aplicaciones igual y en alguna pueden usar esta técnica de ingresar datos. El ejemplo es muy didáctico: obtener el promedio de cinco calificaciones, pero pues ojala les sirva en algún programa que hagan.

Antes de analizar el ejemplo veamos de nueva cuenta en la imagen la jerarquía de clases de Java Micro Edition, se ven sombreadas algunas clases con las que ya se ha trabajado. Pero hay otras que no se han visto, hay una clase que se llama TextBox, hoy vamos a usarla también.


Vea la clase TextBox, esta al mismo nivel que la clase List  y que la clase Form.


La clase TextBox

Los objetos de esta clase me permiten capturar información desde el teclado del celular, en otras palabras funciona igualito que un TextField, que ya se ha visto infinidad de veces. Solo que el Textfield muestra un solo cuadrito de texto para capturar y el TextBox es una pantalla del celular completa, donde se pueden capturar múltiples líneas de texto.

El primer paso para trabajar con él, es agregarlo a la pantalla de flujo de NetBeans, la figura siguiente muestra la ubicación exacta de un TextBox y como se agrega a la vista de flujo.


Ya se mencionó, un TextBox está al mismo nivel que un Form, así que es posible agregar comandos en el, para que el TexBox pueda ejecutar código de java. Por ejemplo puedo agregar un Okcommand para que desde el Form se puede mostrar el TextBox, e igual para el TextBox, puedo agregar un OkCommand para que se regrese al Form, la siguiente imagen muestra esta conexión.


Así puedo navegar entre el Form y el TextBox, esto se usará un poco más adelante.

Para enviar datos al TextBox se usa el mismo método que el de un TextField, se usa el método setText, un ejemplo puede ser el siguiente:

textBox.setText(“ Grupo de Sistemas Digitales, ITESI”);

Recuerde, al arrastrar y soltar el TextBox en la pantalla de flujo NetBeans agrega el nombre textBox a la instancia, si hubiera otra NetBeans agrega textBox1 al siguiente objeto.

Por otro lado, para leer el dato que se ha ingresado en el TextBox se usa el método getString(), está es la sentencia completa para capturar todo el texto que haya en el TextBox:

textBox.getString();

Editar datos al TableItem

Antes que podamos aprender a leer los datos de una tabla y procesarlos,  primero la tabla tiene que tener valores, para escribir los valores, se mueve el cursor hasta seleccionar la celda deseada, por ejemplo la figura siguiente muestra la celda 2 (columna = 0, renglón 1) seleccionada.



Claro que la tabla y su modelo (simpleTableModel) son agregados al Form previamente, así como el okCommand. Por cierto, el okCommand que me lleva al TextBox, se le puso la etiqueta “Editar Celda”, puesto que eso es precisamente lo que se hará, editar la celda para colocarle un valor en ella.

Al dar clic en “Editar Celda”, se muestra el TextBox, es justo ahí cuando se captura el valor deseado por el usuario. La figura siguiente muestra una pantalla cuando se introduce el valor de 90 en la celda desde el TextBox.


Vea la figura, El TextBox también tiene un okCommand, al que se le puso la etiqueta de “Guardar Dato”, al dar clic debe guardar el dato en la tabla, para hacerlo se requiere código.

Primero se debe conocer, cual celda estaba seleccionada previamente, esto se hace con los métodos getSelectedCellRow( ) y con getSelectCellColumn( ), el primer método me indica cual renglón se ha seleccionado y el segundo cual columna. Entonces el par de instrucciones que almacenan la columna y el renglón son las siguientes:

          columna = tableItem.getSelectedCellColumn();

renglon  = tableItem.getSelectedCellRow();

Previamente las variables columna y renglón se declaran como enteros.

Después se obtiene el valor del textField y se envía a la tabla con el método setValue():

simpleTableModel.setValue(columna, renglón, textBox.getString());

         simpleTableModel.fireTableModelChanged();

La primera instrucción, coloca el valor del TextBox, en la columna y el renglón especificados por sus respectivas variables, y la segunda instrucción repinta la tabla para mostrar que valores se han almacenado.

Repitiendo el proceso anterior es posible llenar de datos cada una de las celdas así como se observa en la figura siguiente:



Y qué tal si se desea manipular esos datos, por ejemplo como se menciono en la parte de arriba, para obtener su promedio. ¿qué hago?

Como Leer datos de Un TableItem

Primero que nada se le agrega otro okCommand que es el que va a procesar los datos. Para el simple caso de sacar un promedio de 5 datos, pues simplemente se crea un ciclo for como el siguiente:

 

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

 

 

}

 

Al observar la documentación de la clase TableItem, se puede ver un método llamado getValue(column, row), que regresa el valor de la celda especificada por las variables column y row, así la instrucción:

 

valor = simpleTableModel.getValue(0,0);

 

Asigna a la variable “valor” lo que este almacenado en la celda cuya columna es la 0 y cuyo renglón es el 0.

 

Entonces si se está dentro de un ciclo for y en nuestro caso hay una sola columna (la 0) se puede recorrer cada uno de los valores con la sentencia siguiente:

 

valor = simpleTableModel.getValue(0, i);

 

La documentación es muy clara y dice que la variable valor debe ser declarada de tipo Object, y usando un método llamado toString() se puede cambiar el valor capturado a cadena de caracteres, el código completo para sacar los valores de la tabla y calcular su promedio es el siguiente:

               // Declaración de variables

               float prom;                       

                int suma=0, i;

                String val;

                Object valor; 

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

                     valor = simpleTableModel.getValue(0,i); // obtiene el valor de la tabla

                     val = valor.toString();  // se convierte a String

                     suma = suma + Integer.parseInt(val); //se convierte a entero y se acumula la suma

                }

                prom = suma / 5; // aquí se obtiene el promedio

                simpleTableModel.setValue(0,6,"" + prom);        // aquí se envía el resultado a la celda 6 para mostrar el promedio.

                simpleTableModel.fireTableModelChanged();

 

Bueno les dejo el código por si necesitan analizarlo, esta creado para la versión 6.7.1 de NetBeans y comprimido en formato RAR, dar clic aqui para bajarlo.            




Clic AQUI para leer más...!

jueves, 1 de octubre de 2009

Ejemplo #13 Ciclo for y objetos TableItem



Hoy se va realizar un ejercicio completo (con todo y video-tutorial) el ejercicio incluye los temas que se han tratado en las últimas entradas del blog: ciclo for y TableItem. El ejercicio es tomado de un comentario de uno de mis lectores, justo en el post anterior a este.

Ejercicio: Método de Euler

El comentario del lector con el problema, lo reproduzco aquí tal y como él lo escribió:

“Hola estoy intentando crear una aplicación para que me resuelva el método Euler. Es más o menos así:

y1=y0+f(x0,y0)*h

Donde "h es una constante" te lo dan al igual que el valor inicial de "y0"; y "x0" varía dependiendo de h. Ahora el problema es que la función no es la misma y por ende necesito un texdfield donde ingrese la función y me lo lea.

Un ejemplo de este método es el siguiente para mayor comprensión:

f(x,y)=x^2+y donde y(0)=2 ,h=0.2, hallar y(1)

En este caso mi x0=0 siguiendo 5 pasos o iteraciones hasta llegar a 1. O sea x0=0, x1=0.2, x2=0.4, x3=0.6, x4=0.8, x5=1

Los pasos me lo indica h osea seria 1/0.2=5pasos.

si me dieran como dato: y(1)=2 ,h=0.5 hallar y(4) , serian 4/0.5=8 pasos. Donde x0=1,x1=1.5,.....x8=4

Retomando el primer ejemplo de 5 pasos.la secuencia seria lo siguiente:

y1=y0+h*f(x0,yo)
y1=2+0.2*(0^2+2)=2.4
y2=2.4+0.2*(0.2^2+2.4)=2.888
y3=2.888+0.2*(0.4^2+2.888)=3.4976
y4=3.4976+0.2*(0.8^2+3.4976)=4.32512
y5=4.32512+0.2*(1^2+4.32512)=5.390144

Como podrás ver la función cambia y no va hacer la misma en cada ejercicio, o sea necesito ingresar aparte de y0, h, x0, la función y que NetBeans me lea dicha función para que realice los cálculos. Espero tu ayuda…”

Ese es el ejercicio, no se para que sirve el método de Euler y realmente no me interesa saberlo y mucho menos investigarlo, yo simplemente voy a basarme en lo que dice mi lector bien o mal a mi no me importa yo voy a tomar su información y voy a realizar el programa a mí lo que me interesa realmente es que se muestre otro ejercicio con un ciclo for donde se usen las TableItem para mostrar los datos eso es lo que me importa.

Solución

Veamos la solución al ejercicio pero antes se le va a poner una restricción.

Restricción

El lector dice:

“necesito ingresar aparte de y0, h, x0, la función y que NetBeans me lea dicha función”

Lo que pide, es que en un TextField se coloque una función, pero cualquier función si me explico? O sea no es una función fija, es cualquier función que se ingrese, puede ser la que se muestra en el ejemplo: f(x,y)=x^2+y o puede ser otra como: f(x,y)=x^3+y^2 + 1 u otra la que el usuario decida ingresar.

Mmmm que creen, esto que se menciona, créanme, es un tema para uno o dos post completos se requiere el manejo de cadenas (string), hay que recorrer la cadena con un ciclo for para sacar caracter por caracter y analizar cada caracter ver si hay un "^" y cambiarlo a potencia, un montón de cosas que  se deben hacer. Por lo pronto lamento no complacer a mi lector :( , así que como restricción al ejercicio vamos a tomar la función fija solamente y vamos a usar la que él nos da de ejemplo, la función:

f(x,y)=x^2+y

Análisis del problema

Como primer paso se va a crear la interfaz de usuario. Tomando en cuenta que dice el lector:

"h es una constante" te lo dan al igual que el valor inicial de "y0";

Además también hay que agregar a la interfaz de usuario el valor que se desea de y como se ve en el enunciado del problema. Tres instancias de TextField y una de la clase TableItem resuelven el problema, entonces esto es lo que se requiere:

• Un objeto TextField para el valor de inicial y(0).
• Un objeto TextField para el valor de h.
• Un objeto TextField para el valor de y deseado.
• Un objeto TableItem para mostrar los resultados.
• Un objeto okCommand para realizar los cálculos necesarios.

La figura siguiente muestra como se veria parte de la interfaz de usuario para el problema:



el lector nos dice como obtener el número de iteraciones:
“…Los pasos me lo indica h osea seria 1/0.2=5pasos…”

El número de iteraciones es el valor deseado de y dividiéndolo con el valor de h.

El lector dice

"x0" varía dependiendo de h…”

El lector manda estos ejemplos:

“…En este caso mi x0=0 siguiendo 5 pasos o iteraciones hasta llegar a 1. O sea x0=0,x1=0.2,x2=0.4,x3=0.6,x4=0.8,x5=1 “

Ahí se observa que x0 = 0, el otro ejemplo es:

..”si me dieran como dato: y(1)=2 ,h=0.5 hallar y(4) , serian 4/0.5=8 pasos. Donde x0=1,x1=1.5,.....x8=4”

Aquí creo que el lector se equivoca ya que: x0 = 1, x1 = 1.5, x2= 2, X3=2.5,  x4=3, x5=3.5, x6=4… ¿por que dice que x8=4? Para que suceda así  x0 debe ser igual a 0. Conclusión a la que llego x0 debe ser siempre igual a 0.

Código

En cuanto al código se debe como primer punto obtener los valores que se ingresan de los TextField, esto ya se ha realizado muchas veces, se requiere un par de instrucciones como estas:

strH = textField1.getString();
h = Float.parseFloat(strH);

Se declaran dos variables strH de tipo String y h de tipo float, se aplica el método Float.ParseFloat para cambir el String a número float, este par de sentencias se usa también para los otros TextField.

Para obtener el número de iteraciones basta con dividir el valor deseado de y con h como se mencionaba en la parte de arriba, así:

pasosF = y / h;
pasos = (int) pasosF;


se declara pasosF como float, esto debido a que el valor de y además del valor de h son de tipo float, luego en la siguiente instrucciones se obtiene el número de iteraciones, usando el (int) para convertir a entero el valor de tipo float y así poder usarlo en el ciclo for.

El ciclo queda así entonces:


for (int i=0; i<=pasos; i++) {

}
Antes del ciclo se inicializa x0 = 0; Dentro del ciclo se obtienen los nuevos valores de y aplicando la formula: f(x,y)=x^2+y, en java quedaría así:
y = y0 + h * (x0*x0 + y0) ;

Con el valor de y se actualiza para el siguiente cálculo (siguiente iteración) el valor de y0 y x0 de la siguiente forma:

y0 = y;
x0 = x0+h;


Después de van las instrucciones para mostrar los datos en la tabla, la primera es:

simpleTableModel.setValue(0, i, "y"+(i+1));

la cual muestra en la columna 0 de la tabla los valores de: y1, y2, y3, etc..la otra columna nos muestra los resultados de aplicar la formula:

simpleTableModel.setValue(1, i, ""+y);

Si alguien se perdió en la explicación anterior, aquí les dejo el video tutorial con la solución completa, para este ejemplo, ahí se puede ver el código completo.




El programa fue realizado con la versión de NetBeans 6.7.1, vea los resultados se ingresaron las mismas variables que el lector pero las iteraciones y4 además de la y5 dan como resultado diferente a lo que se muestra en el enunciado del problema esto, debido a que, en y4 debió evaluar con una x de 0.6 y puso 0.8.

Por si lo desean dando clic aquí, pueden “bajar” el código de Java Micro Edition, y analizarlo, el archivo esta comprimido en formato RAR, contiene todas las carpetas generadas por Netbeans, el programa fue probado en un teléfono Sony Ericsson w595 con resultados iguales a los del video.




Clic AQUI para leer más...!