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...!

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...!

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...!

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...!

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...!

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...!

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...!