Programación Modular usando Java

En esta segunda entrada de la serie sobre programación modular  les mostraré un ejemplo. (Lee aquí la primera parte)

Voy a partir de un programa que se ha escrito sin usar Programación Modular ni Programación Orientada a Objetos.  Se trata de un programa que recibe un número entero, y el usuario puede decidir  evaluar si el número es perfecto, abundante o deficiente. El programa original se muestra en la figura 1.

Figura 1. Programa original del caso de ejemplo

¿Cómo crear un programa modular?

En la figura 2 se muestran los pasos a seguir para convertir un programa no modular en un programa modular.

Figura 2. Pasos para convertir un programa no modular en uno modular.

Paso 1: Dividir  el problema en módulos  lógicos.

Un módulo lógico es un conjunto de líneas de código que se escriben para resolver una parte del problema. Según el lenguaje de programación, un módulo puede llamarse procedimiento, función,  subprograma, subrutina, etc.

En el lenguaje Java,  tenemos los métodos. Un método en sí no fue diseñado para constituir un módulo, sino como parte de una clase.

La estructura del programa original ayuda mucho a encontrar los módulos lógicos, pues se detectan tres subtareas claves:

• La porción de código que detecta si un número es perfecto
• Las líneas de código que detectan si un número es defectivo
• Las líneas de código que detectan si un número es abundante

De esta forma ya hemos detectado los tres métodos que integrarán nuestro programa, esto se aprecia en la figura 3.

Figura 3. Detección de los módulos

Paso 2. Identificar y definir variables globales

• Tipos de variables

Según el paradigma de programación modular, existen dos tipos de variables:

• Variables globales: las cuales son accesibles por todos los módulos dentro del programa para usar y/o modificar su valor.
• Variables locales: las cuales solo son accesibles dentro del módulo donde fueron declaradas. De hecho, este tipo de variables solo se crean cuando el flujo del programa entra al módulo correspondiente, y se destruyen cuando se sale de él.

• Ámbito de las variables globales

Java no tiene explícitamente variables globales como tal, porque sus variables pueden ser: privadas, públicas o protegidas. Aunque el ámbito de acción de una variable pública es incluso mayor que el de una variable global, este tipo de variable nos servirá para definir variables globales para programación modular.

Ok, hablemos del ámbito de una variable: simplemente establece la zona o zonas del programa donde la variable existe y puede ser accedida. De esta forma una variable global tiene un ámbito de acción que incluye todos los métodos del programa. Esta variable es reconocida y puede ser usada por cualquier método, ya sea imprimiendo su valor, usándolo para realizar algún cálculo o para evaluar alguna expresión condicional. Y sobre todo, cualquier método tiene derecho de modificar el valor almacenado en la variable global.

• Ámbito de las variables locales

Las cosas son diferentes cuando se trata de variables locales o variables de método. Para este tipo de variables, sucede lo siguiente:

• Solo son reconocidas por el método que las declaró. Cualquier intento de usarlas en otro método diferente, te generará error de sintaxis, indicando que la variable no ha sido declarada.
• Ocupan un espacio temporal de almacenamiento en la memoria RAM. Cuándo el flujo del programa entra en el método, se crea la casilla de almacenamiento para estas variables. Una vez que el flujo del programa sale del método, estas casillas (y su contenido) son destruidas.
• Si una variable local tiene el mismo nombre que una variable global, la local se antepone a la global. Eso quiere decir que el método NO tendrá acceso a la variable global, porque su local está ocultando a la variable global. ¡Mucho cuidado con esto!

• Encontrando las variables globales

Para elegir qué variables serán locales y cuáles globales, es necesario revisar el código nuevamente y observar en qué porciones del código se utilizan las variables.

Figura 4. Seleccionando  variables globales

Como puedes observar, en la figura 4 he subrayado con rojo las variables que serán globales. ¿Por qué esas? Si te fijas, las variables buffer y entrada las utilizamos para habilitar la entrada desde el flujo del teclado. Podrían declararse locales, pero entonces luego tendría que enviar como parámetro el dato obtenido, lo cual es más eficiente, pero no es el tema de este post. Por otro lado, la variable número, se utiliza en todos las partes del programa que identificamos como nuestros módulos. Entonces, como regla, procuraré que las variables que se definan globales sean aquellas que son utilizadas por todos los módulos del programa.

Las variables globales las declararemos fuera de los métodos, como se observa en la figura 5.  Las establecemos de tipo public o públicas, para que otras clases también puedan usarlas. Y agregamos el modificador static, ya que el método main está definido también de esa forma, y una variable no static no puede ser utilizada por un método static. El modificador static indica que sólo se creará una copia de estas variables en la máquina virtual de Java. Por el momento, no ahondaré en este modificador, pues será más importante entenderlo cuando ya se esté trabajando con el paradigma de Programación Orientada a Objetos.

Figura 5. Declaración de variables globales

Paso 3. Definir los métodos

Por último, definiremos los métodos, pero antes observa la figura 6, en donde te muestro las partes de un método:

Figura 6. Componentes de un método

Como se puede observar, cada método se “encapsula” usando sus propias llaves de apertura y cierre. También tiene su zona de declaración de sus propias variables (locales).

Encabezado del método

Lo que define cómo será usado por otros métodos (incluyendo main), es su encabezado. He colocado en un color diferente cada  una de las partes de este, y a continuación las explico:

• tipoAcceso: Define qué clases  y métodos que podrán hacer uso de éste método. Existen tres tipos de modificadores de acceso: public, private y protected. Por el momento, utilizaremos el tipo public.
• modificador: Este modificador puede ser static o final, que técnicamente definen los atributos de los miembros de una clase. Por el momento establecemos una regla muy simple: si el método que lo llamará es static, entonces este método también debe ser static.
• tipoMétodo: El tipo de método se define por el tipo de valor que regresa un método. Si el éste no regresa un valor, será de tipo void. Si el método regresa un valor, deberá usarse cualquiera de los tipos de datos primitivos de Java: int, float, char, double, float y boolean. También incluso puede usarse una clase como String, BufferedReader, etc.
• nombreMétodo: Obviamente es el nombre que cada programador le dará al método. Se deben seguir las mismas reglas para definir identificadores en Java para crear estos nombres (recuerda: empezar con letra, continuar con letras, números y/o el caracter _, no usar caracteres especiales ni palabras reservadas)
• tipoArg:  si el método lo requiere, en esta sección se definen los argumentos o parámetros del método. Específicamente, tipoArg define el tipo del argumento, el cual puede ser cualquiera de los tipos de datos primitivos de Java así como también cualquier clase definida en la API de Java. Al tipo de dato del parámetro, le sigue el nombre del argumento, que una vez más, deberá seguir las reglas para construir identificadores.
  

Definiciones de los métodos

Ahora observa la figura 7. Aquí te muestro el programa completo, con las definiciones de cada uno de los métodos que se han detectado. Cada método se muestra encerrado en un cuadro rojo.

Figura 7. Programa completo

¡Ahora, a llamar a los métodos!

Una vez que ya tenemos definidos los métodos, lo útimo que falta es hacer que main llame a los métodos para que éstos se ejecuten. Si un método ha sido definido, pero no llamado, no se ejecutará.

La forma de llamar a los métodos depende del tipo de método, y también de si éste recibe o no argumentos. En este caso, se han definido los métodos tipo boolean, lo que quiere decir que regresarán un valor boleano. Por ello, el llamado a los métodos quedó de la forma en la que se muestra en la figura 7, en la que se han subrayado en color verde. Muestro dos formas de llamar a los métodos. En la llamada al método perfecto, en la línea:

     p = perfecto();

La variable p es variable local de main tipo boolean, y en ella se guarda el resultado del método perfecto, el cual es regresado a main a través de la instrucción return. Esta línea es el llamado típico de los métodos, pues sigue la forma general:

  varLocal = metodo();

Ahora, en el llamado al método abundante, se tiene la línea:

if ( abundante() )

En este caso, el método abundante no regresa su valor a una variable específica, sino que es evaluado directamente por la condicional del if. Esto se puede hacer debido a que el método abundante es tipo boolean y como recordamos, las condicionales evaluadas dentro del if son valores booleanos.

Esto es todo por el momento. Si te interesa el tema o tienes alguna duda, déjame un comentario.

¡Hasta la próxima entrada!

Guardar