Sumadora Pascalina
Resulta que siendo Pascual de 16 años de edad, su padre Etienne Pascal fue nombrado comisionado real de servicios de impuesto en la alta Normandía; radicando en la ciudad de Roven. Esta tarea era tan compleja y voluntaria, que Etienne Pascal requería, constantemente de la ayuda de su hijo Blaise en los extensos cálculos aritméticos que su trabajo requería. Analizando esta situación el joven Blaise Pascal comenzó a cavilar la forma de realizar dichos cálculos en forma mecánica. Su máquina fue el resultado de largos años de estudios y trabajo ya que aunque desde los 19 años Pascal había desarrollado el concepto básico del equipo; no fue sino hasta los de 30 años que toda Europa quedo sorprendida con el modelo perfeccionado de la calculadora ‘La Pascalina’.1
El objetivo de este documento es mostrar el desarrollo de una aplicación movil Pascalina Digital que nos permitirá realizar sumas.
1
Tomado de http://evoluciondelascalculadorasyeimi.blogspot.com/2009_08_01_archive.html
1
Sumadora Pascalina Contenido Introducción ........................................................................................................................................ 3 Tema o idea de proyecto .................................................................................................................... 4 Definición del problema ...................................................................................................................... 4 Justificación ......................................................................................................................................... 4 Objetivos ............................................................................................................................................. 5 Objetivo General ............................................................................................................................. 5 Objetivo especifico .......................................................................................................................... 5 Marco Referencial ............................................................................................................................... 5 Desarrollo del Proyecto ....................................................................................................................... 5 Análisis de Software ........................................................................................................................ 5 Análisis del Sistema Actual .......................................................................................................... 5 Identificación de Necesidades..................................................................................................... 6 Definición de requerimientos funcionales .................................................................................. 6 Definición de requerimientos no funcionales ............................................................................. 7 Diseño de Software ......................................................................................................................... 8 Diagrama de clases UML ............................................................................................................. 8 Diagrama de secuencia UML ..................................................................................................... 10 Diseño de Interfaz de usuario ................................................................................................... 11 Programación ................................................................................................................................ 11
2
Sumadora Pascalina Introducción El siguiente documento tiene por propósito documentar el desarrollo de miniproyecto que será una sumadora a la que llamaremos La Pascalina con la que podremos realizar sumas y restas. El documento tiene un segundo propósito y es plasmar de una manera un poco informal la estructura del documento final del proyecto. Para el desarrollo del proyecto La Pascalina se requiere tener conocimientos básicos en el uso del Entorno Integrado de Desarrollo NETBEANS, conocimiento y experiencia en:
Creación del Proyectos J2ME Creación de MIDlets Escritura de clases java Conocimientos en el uso del Objeto Display en J2ME Conocimientos en Creación Diseño y Visualización de formularios.
Si no tiene estos conocimientos revise el capítulo “Las entrañas de Los Midlets” .
3
Sumadora Pascalina Tema o idea de proyecto El proyecto consiste en el desarrollo de La Pascalina una aplicación J2ME que permitirá llevar las cuentas al señor Etienne Pascal quien es el comisionado real de servicio de impuesto en alta Normandía para que lo ejecute en su dispositivo móvil el cual no cuenta con ningún método de cálculo.
Definición del problema Etienne Pascal trabaja recaudando los impuestos en alta Normandía, pero se demora mucho tiempo calculando el valor que cada aldeano tiene que pagar por todos los impuestos. La demora en los cálculos se debe a que no existe una máquina que le permita realizar las sumas por concepto de cada impuesto por lo que en ocasiones tiene que pedir ayuda a su hijo, pero de igual manera es muy demorado calcular los impuestos manualmente.
Justificación Con el desarrollo del proyecto La Pascalina y la instalación de la aplicación en el celular del señor Etienne Pascal va a poder realizar sus cálculos de impuestos de una manera sistematizada disminuyendo los tiempos de cálculo de impuestos por aldeano y como consecuencia de esto atendiendo más aldeanos por día.
4
Sumadora Pascalina Objetivos Objetivo General Crear una solución móvil J2ME que le permita realizar sumas y restas.
Objetivo especifico
Establecer los requerimientos de la aplicación Diseñar las interfaces de usuario Diseñar los algoritmos de calculo Codificar los algoritmos en una aplicación J2ME Probar si la aplicación cumple con lo requerido
Marco Referencial ….
Desarrollo del Proyecto Análisis de Software Análisis del Sistema Actual
El señor Etienne Pascal realiza sus cálculos sobre los impuestos de un aldeano usando un ábaco, el ábaco es un objeto que sirve para facilitar cálculos sencillos. Normalmente, consiste en cierto número de cuentas engarzadas en varillas, cada una de las cuales indica una cifra del número que se representa.
5
Sumadora Pascalina
La forma de uso del ábaco las puedes http://www.librosmaravillosos.com/swanpan/capitulo01.html
encontrar
aquí:
El señor pascal cuenta usando el Abaco la cantidad de dinero que cada aldeano tiene que pagar por los diferentes impuestos al rey, una vez sabe el total procede a realizar el cobro, cuando ha recaudado los impuesto tiene que sumar nuevamente todo lo recaudado y entregar estos dineros al rey junto con el informe del total recolectado. Identificación de Necesidades
El señor Pascal necesita una aplicación que pueda ser ejecutada en su celular MIDP 2.x que le permita realizar sumas, y reiniciar la cuenta a cero.
Definición de requerimientos funcionales
La siguiente imagen muestra como el usuario de la aplicación podrá usarla:
6
Sumadora Pascalina
A continuación la documentación de los casos de uso: Realizar SUMA Nombre Alexander Montaña Autor 13 de octubre de 2011 Fecha Descripción: Permite calcular la suma de dos numeros Actores: usuario de la aplicación Precondiciones: El usuario debe proporcionar los dos números Flujo Normal: 1.El actor ingresa el primer numero 2.El actor oprime la operación 3. El actor ingresa el segundo numero 4. El actor puede oprimir el botón de resultado 5. Se visualiza el resultado de la operación Flujo Alternativo: 4. El actor puede oprimir el botón de operación(+) , si los datos son correctos se realiza la operación y el resultado de esta se va a almacenar en primer número. Postcondiciones: Se muestra el resultado de la operación
[De esta misma forma se documentan los otros dos casos de uso]
Definición de requerimientos no funcionales
Se necesita que la pantalla de entrada muestre una imagen de un ábaco chino en honor a su herramienta de cálculo usada por mucho tiempo.
7
Sumadora Pascalina Diseño de Software Diagrama de clases UML
A pesar que durante este primer nivel no se profundizará en Notación UML aprovecharé la oportunidad para introducirnos en el tema con un ejemplo tan sencillo como la sumadora Pascalina. De la misma manera como los constructores de casas para hacer una casa necesitan de un plano que proporciona un arquitecto
El plano
El producto
En el desarrollo de software tambien se necesita un plano (Diagrama UML) para hacer un software.
Diagrama UML
El software
Miremos un poco más detalladamente el diagrama de clases UML.
8
Sumadora Pascalina
Para comprender el diagrama voy a empezar a explicar símbolos UML.
qué significa esos
Cuando veas este símbolo (rectángulo con tres secciones) representa una clase, en la primera franja estará el nombre de la clase, la segunda franja corresponde a la definición de variables o atributos de la clase y en la franja inferior los métodos o funciones de la clase. Este símbolo representa un paquete. ¿Pero y qué es un paquete? Es simplemente una carpeta en la cual se pueden alojar clases para organizar el proyecto adecuadamente.
Esto representa la herencia(extends) entre dos clases. Este ejemplo muestra el uso de la herencia que se da entre 2 clases, la superclase figuraGeometrica y la subclase Triangulo, esto se interpreta como que un triángulo es una Figura geométrica. Cuando se realiza una herencia se tiene el efecto que la subclase hereda las propiedades y los métodos de la clase padre. En términos generales dentro del paquete javax.microedition.midlet hay una clase MIDlet(las clases que heredan de esta clase son aplicaciones j2me).
9
Sumadora Pascalina En cuanto al otro paquete javax.microedition.lcdui existe una interfaz CommandListener , las interfaces son una colección de operaciones que se usa para especificar un servicio de una clase o componente, para entenderlo mejor miremos en el ejemplo que la clase Pascalina implementa la interfaz commandListener esto obliga a la clase pascalina a implementar todos los métodos de la interfaz. La clase Sumadora contendrá los algoritmos para realizar los algorimos propios de la calculadora y que para efectos del ejercicio solo hará sumas. Mientras que la Clase Pascalina será nuestra aplicación, por lo que tiene que heredar (extends) de la clase MIDLet y en esta diseñaremos la interfaz de usuario. Diagrama de secuencia UML
10
Sumadora Pascalina Diseño de Interfaz de usuario
1. El componente corresponde a un formulario (Form), que será el contenedor de los componentes de interfaz de usuario que van a permitir ingresar los datos, invocar acciones y ver resultados de la sumatoria. 2. Es un StringItem en el que visualizaremos el histórico de la operación actual. 3. El componente 3 es un TextField que será usado para que el usuario de la aplicación ingrese el valor de los sumandos y además se podrá ver el resultado de la sumatoria. 4. El comando salir tiene como propósito dar por terminada la aplicación cuando se oprima. 5. El comando SUMAR tiene por objetivo que una vez se oprima verifica si hay una operación establecida en el objeto de la clase Sumadora, en el caso en que no lo haya, el valor ingresado en la caja de entrada se almacenará en el sumando 1 y se establece como operación “+” en la sumadora, pero si lo hay se almacena en el valor ingresado en el operando 2, se realiza la operación, se muestra el resultado y finalmente se mantiene en la variable operación “+” y se pone el resultado de la operación en el operando 1.
Programación Para programar la sumadora Pascalina tendremos que desarrollar el siguiente paso a paso:
11
Sumadora Pascalina 1. Crear el proyecto J2ME2
El proyecto lo he llamado Sumadora, usando la configuración CLDC 1.1 Y el perfil MIDP 2.0 Cuando creas el proyecto no olvides desmarcar la opción Create Hello Midlet.
2. Crear la clase Sumadora
Con esto hemos creado un nuevo tipo de dato, Sumadora del cual podemos crear objetos de la siguiente forma Sumadora s = new Sumadora(); Con un objeto de estos podremos darle un valor a cada sumando y especificar una operación y realizarla. Hasta este punto solo podría sumar 2
Puede revisar el documento Las entrañas de Los midlets http://goo.gl/2qlPU
12
Sumadora Pascalina ya que no hemos implementado los métodos para realizar otras operaciones. De esta manera el proyecto quedará así:
Ahora haciendo un poco de analisis de los algoritmos que necesitamos para nuestra sumadora, en el diseño están planteados dos metodos ejecutarOperacion(…) y sumar(…)
13
Sumadora Pascalina Necesitamos que el metodo Sumar sume dos numeros y retorne el resultado de dicha operacion, si lo vieramos como una caja negra seria algo parecido a la siguiente imagen:
Los métodos y las variables deben expresar en su nombre con cierta claridad para qué van a ser usados, por ejemplo crea un método que realiza una suma de dos números y retorna su resultado, lo más conveniente es que el método se llame sumar().
El método sumar lo que hace es definir una variable de tipo float a la que llamaremos resultado y que usaremos para almacenar el resultado de la suma de las dos entradas.
14
Sumadora Pascalina
Puede profundizar en el material del curso.3 Si quisiéramos que nuestra sumadora realizara operaciones adicionales podríamos agregar un método que realizara la operación de la misma manera que para la suma se hizo. Por otro lado hay que implementar un meto que se encargue de la ejecución de la operación que aunque no es estrictamente necesario en el escenario planteado ya que nuestra calculadora solo realiza una operación la Suma, pero lo dejaremos más genérico por si se desea agregar otra operación más adelante, el método es ejecutarOperacion(). ¿Cuándo invocar el método ejecutarOperacion? Inicialmente nuestra única operación es una suma por lo que si tenemos tres variables: Sumando1
Sumando2
Operacion
¿Podríamos ejecutar la operación si no tenemos asignados los valores a estas tres variables? 3
http://virtual.areandina.edu.co/repositorio/tpdsdm/ieefp/Interpretacion_de_entornos_y_est ructuras_fundamentales_de_programacion.pdf
15
Sumadora Pascalina Definitivamente no porque no sabríamos que operación realizar ni con que valores. Analicemos el siguiente caso: Sumando1
Sumando2
Operacion
+ Al responder la anterior pregunta solamente sabemos que la operación a ejecutar es una suma pero no sabemos qué valores sumar y es imperativo saberlos para realizar la operación. Por eso el único caso en el que podríamos realizar la operación es el que sabemos la operación y los dos valores que se van a operar: Sumando1
Sumando2
Operacion
3
7
+
En este momento ya se puede invocar el método ejecutarOperacion() y con toda seguridad se obtendrá un resultado Resultado
?? Como proceder entonces ejecutarOperacion()?
cuando
se
invoca
el
método
de
Lo primero que tiene que hacer el método es verificar si la operación que se debe ejecutar es una suma y si se cumple la condición invocará el método que realiza la suma y se le enviarán los parámetros correspondientes al sumando1 y sumando2. Este método sumar() retorna el resultado de la suma por lo que hay que capturarlo y mostrarlo al usuario.
16
Sumadora Pascalina
Una vez obtengo el resultado lo almacenamos en la variable sumando1 para que no se pierda el valor y podamos asignar otro valor al sumando 2 y volver a ejecutar la operación. Si quisiéramos realizar otra operación podría agregar las condiciones necesarias.
Por otro lado vamos a crear el MIDlet Pascalina, si tienes dudas de cómo crear el midlet ve el tutorial “Las entrañas de los Midlets” en el módulo de Estructuras fundamentales de programación.
17
Sumadora Pascalina
Para poder hacer que herede(extienda) de la clase MIDlet hay que importar la clase lĂnea 2. Ahora haremos que implemente de la interfaz CommandListenner
18
Sumadora Pascalina
Como se puede ver con el método commandAction, implementar una interfaz hace que tengamos que implementar los métodos que especifica la interfaz. Solo a manera de información la siguiente imagen muestra el contenido de la interfaz CommandListenner.
19
Sumadora Pascalina
Volviendo a nuestra clase pascalina vamos a agregar las referencias al display, vamos a crear el formulario con su campo de texto y los comandos de cmdSumar, cmdSalir.
20
Sumadora Pascalina Como se puede ver si queremos crear una variable de una clase que no estĂĄ en nuestro paquete hay que hacer el import correspondiente. Ahora vamos a crear el constructor de la clase y ahĂ le vamos a asignar memoria a estas referencias, es decir vamos a crear los objetos.
Hasta aquĂ tenemos los componentes que forman la interfaz de usuario pero en memoria, si ejecutamos el proyecto no veremos nada. Lo primero que hay que hacer es montar los componentes en el formulario.
21
Sumadora Pascalina
En este punto ya no tenemos los componentes por separados sino ensamblados para que se pueda ver asĂ:
Pero necesitamos hacerla visible en el celular.
AquĂ en la lĂnea 47 le decimos al display que muestre el formulario.
22
Sumadora Pascalina Este sería el resultado de hacer visible el formulario. Al ejecutar la aplicación hasta este punto solo tendríamos una interfaz de usuario que no haría mucho. Necesitamos ajustar el código para que cuando se oprima el botón salir termine la aplicación, esto lo haremos en el método commandAction Cada vez que se oprime un comando se ejecuta este método commandAction por lo que vamos a verificar si se cumple la condición de que el comando ejecutado es el mismo que llamamos cmdSalir, en tal caso invocamos el método destroyApp(true) que debe tener el código que notificará al administrador de la aplicación en el celular que termine la aplicación.
Ahora vamos a mirar que hacer cuando se oprima el comando SUMAR
Antes de entrar a detallar el código vamos a agregar una referencia a un objeto de la clase Sumadora:
23
Sumadora Pascalina
Bien con esto ya podemos hacer sumas debido a que contamos con un objeto de la clase Sumadora.
Este código no lo voy a explicar, seguramente con los conocimientos obtenidos en el módulo de fundamentos de programación no será difícil que lo entiendas. El código del proyecto lo encontraras en http://goo.gl/SvZUG Ing. Alexander Montaña Bello Tutor de la fundación Universitaria del Área Andina
24