Metodologías para la Enseñanza Aprendizaje de la Programación Estructurada y Orientada a Objetos
Leobardo LÓPEZ ROMÁN
Departamento de Ingeniería Industrial y de Sistemas, Universidad de Sonora Hermosillo, Sonora, 83000, México
RESUMEN
El proceso enseñanza aprendizaje de la programación de computadoras siempre ha sido difícil. No importa cuál se esté usando como primer lenguaje en la enseñanza, sea FORTRAN, COBOL, BASIC, PASCAL, C, C++, JAVA, C#, o cualquier otro. El problema es que los estudiantes no desarrollan lógica o desarrollan muy poca lógica, escenario que se ha complicado con la permanente evolución de los paradigmas y la aparición de nuevos lenguajes de programación. Con la idea de coadyuvar en el mejoramiento de esta situación, este autor ha desarrollado y publicado como libro seis metodologías. En este artículo se hace una presentación general de la metodología de cada uno de los seis libros, haciendo énfasis en la evolución que han tenido dichas metodologías.
Palabras Claves: Metodología, Programación Estructurada, Orientada a Objetos.
1. INTRODUCCIÓN
Desde finales de los setentas y hasta la actualidad, he observado empíricamente, que muchos estudiantes de programación de computadoras han estado aprendiendo en forma muy limitada, porque siempre se cae en darle poca importancia al desarrollo de la lógica, y se enfocan más a enseñarles el lenguaje, y aprenden a prueba y error.
La idea de este autor es que lo fundamental al aprender a programar, es desarrollar la lógica necesaria para solucionar problemas en forma algorítmica, independientemente de algún lenguaje; esto es, aprender a diseñar algoritmos o programas usando un seudolenguaje, y no hacerlo directamente con un lenguaje.
Teniendo en mente el propósito de coadyuvar en el mejoramiento de la enseñanza aprendizaje de la programación, entre los años 1981 y 1994, desarrollé una metodología que conduce la enseñanza aprendizaje de la programación estructurada, mediante el uso de un seudolenguaje de diseño de algoritmos o programas estructurados, enfocado a que los estudiantes desarrollen la lógica independientemente de algún lenguaje de programación.
Dicha metodología fue publicada en un libro [1] y ha servido como base para desarrollar otras cinco metodologías, que han sido publicadas en los libros [2], [3], [4], [5] y [6]. Todos publicados en español por la editorial Alfaomega y distribuidos en los países de habla hispana. En este artículo se hace una presentación general de la evolución que han tenido dichas metodologías, como consecuencia de la evolución de los
paradigmas y la aparición de nuevos lenguajes de programación.
2. EVOLUCIÓN DE LA PROGRAMACIÓN El paradigma de programación ha evolucionado, y entre muchos avances que se han producido, destacan tres grandes pasos: el primero es cuando se inventó la programación de computadoras como tal; el segundo paso es cuando se gestó la primera gran evolución, a la que se le nombró Programación Estructurada; y el tercer paso, es cuando se generó otra gran evolución, a la que se le denomina Programación Orientada a Objetos.
2.1 Programación de Computadoras
En la década de los cincuentas se inventó la programación de computadoras como tal, en esos tiempos sólo existían las estructuras lógicas de Secuenciación, If y For, que se conocía como Do en Fortran, y se utilizaban los diagramas de flujo como técnica de diseño de algoritmos o programas. La arquitectura general de un programa consistía de un solo módulo o bloque de instrucciones.
2.2 Programación Estructurada
A finales de la década de los sesentas, surge un movimiento llamado programación estructurada que vino a añadir nuevas estructuras, técnicas y conceptos a la programación: se añadieron las estructuras lógicas DO-UNTIL, DOWHILE y se formalizaron el IF-THEN, IF-THEN-ELSE y CASE. Se inventó el módulo, la función y el concepto de parámetros. Se desarrollaron nuevas técnicas de diseño de algoritmos o programas: seudocódigo, diagramas Warnier, diagramas Chapin, Jackson, Diseño estructurado de Yourdon, Top Down Design (Diseño descendente), entre otras; que vinieron a desplazar a la tradicional técnica de diagramas de flujo. Fueron apareciendo nuevos lenguajes: Pascal, C, Cobol estructurado, Basic estructurado. Se estableció que se debe aprender a programar utilizando un seudolenguaje, es decir, no enseñar directamente con un lenguaje. Y se instituyó que se debe usar un estilo de programación que haga más entendible el algoritmo y el programa. La arquitectura general de un programa cambió, y ahora consistía de un conjunto de funciones o módulos jerarquizados, cada uno formado por un conjunto de instrucciones.
2.3 Programación Orientada a Objetos
Aunque la programación orientada a objetos (POO) aparece muchos años antes, es a mediados de los noventas cuando se generaliza su uso. La POO añade a la programación una nueva estructura: el objeto, con sus conceptos; objetos, clases,
encapsulación, herencia y polimorfismo. Aparecen nuevas técnicas de diseño: Booch, Rumbaugh, Jacobson, Yourdon, UML (Unified Modeling Language), entre otras. Se desarrollan nuevos lenguajes: C++, Java, C#, etcétera. La arquitectura general de un programa cambió, y ahora consiste de un conjunto de objetos, cada uno formado por datos y un conjunto de métodos, equivalentes a módulos o funciones en la programación estructurada, y a su vez, cada método formado por un conjunto de instrucciones.
3. PROBLEMA, CAUSA Y SOLUCIÓN PROPUESTA
3.1 Problema
Desde hace treinta años he investigado empíricamente y he observado que el proceso enseñanza aprendizaje de la programación de computadoras siempre ha sido difícil. No importa cuál se esté usando como primer lenguaje en la enseñanza, sea FORTRAN, COBOL, BASIC, PASCAL, C, C++, JAVA, C# o cualquier otro. El problema es que los estudiantes no desarrollan lógica o desarrollan muy poca lógica, en consecuencia, no aprenden bien a diseñar programas.
3.2 Causa
Aunque se ha escrito mucho, según la experiencia de este autor, la causa es que por un lado, se ha escrito mucho sobre metodologías de modelado, de análisis y de diseño pero van enfocadas en un sentido muy abstracto; y por otro lado, cuándo aparecen nuevos lenguajes, se escriben manuales de cómo usarlos, pero van enfocados en un sentido muy concreto, que es como operar el lenguaje; hasta cierto punto desvinculados, lo que es el diseño de programas con la codificación de los mismos, lo que ha generado un vacío, que provoca que los maestros que enseñan programación, estén desorientados, y en algunos casos enseñan muy poco o nada de lógica (diseño de programas), en otros casos enseñan algo de lógica pero en forma inapropiada e incompleta, y se enfocan más a la enseñanza de cómo usar el lenguaje sin haber desarrollado bases lógicas sólidas. En consecuencia, los estudiantes aprenden a usar lenguajes sin desarrollar la lógica apropiadamente. Es pertinente aclarar que el problema y la causa expuestos son aplicables en muchos casos en el contexto donde este autor se desenvuelve en México y en algunos otros países de habla hispana; sin embargo, es posible que haya casos en que no aplican.
3.3 Solución propuesta
Hay algunos autores que han desarrollado metodologías de la programación que van en el sentido de llenar ese vacío, sin embargo, según mi apreciación, todavía ha quedado algo de vacío, es por ello que he desarrollado seis metodologías de la programación; o una metodología en seis versiones, que conducen el proceso enseñanza aprendizaje enfocado a que el estudiante, primero desarrolle bases lógicas sólidas y después, sobre esas bases, que aprenda el lenguaje de programación. En el siguiente punto de explican.
4. METODOLOGÍAS DESARROLLADAS 4.1 Programación Estructurada un enfoque algorítmico
Publicada en el libro [1], donde se presenta una metodología de la programación estructurada, que conduce el proceso enseñanza aprendizaje enfocado, a que el estudiante desarrolle bases lógicas sólidas usando seudocódigo y Top Down Design, independientemente de un lenguaje de programación.
La idea de usar una metodología en seudocódigo, es que se use nuestro idioma natural que es el español, conjuntamente con los elementos y estructuras de los lenguajes de programación, y en este caso, respetando las palabras reservadas en inglés, de las estructuras lógicas de control.
En esta metodología, los tipos de datos se representan de la siguiente forma: Entero, Real, Alfabético, Carácter, Arreglos, Registros y Archivos.
La definición de variables se hace mediante el formato:
Definir variables
NOMBRE: Alfabético[30]
HRSTRAB: Entero
CUOTAHR, SUELDO: Real
La lectura o entrada de datos se hace con el formato:
Solicitar Nombre, Horas trabajadas y Cuota por hora Leer NOMBRE, HRSTRAB, CUOTAHR
La escritura o salida de datos se realiza con el formato:
Imprimir NOMBRE, SUELDO
Las estructuras lógicas de control, se representan.
La selección simple (IF-THEN) Formato:
IF condición THEN Acción(es) ENDIF
La selección doble (IF-THEN-ELSE) Formato:
IF condición THEN Acción(es) ELSE Acción(es) ENDIF
La selección múltiple (CASE) Formato:
CASE (1,2,3,4) SELECTOR 1: Acción(es)
2: Acción(es) 3: Acción(es) 4: Acción(es) ELSE
Acción(es) ENDCASE
La repetición REPEAT (DO).
Formato:
REPEAT Acción(es) UNTIL Condición La repetición FOR Formato:
FOR CONTADOR=VALORINICIAL,VALORFINAL,INC Acción(es)
ENDFOR
La repetición DOWHILE Formato:
DOWHILE Condición Acción(es) ENDDO
Ejemplo de aplicación:
Algoritmo FACTORIALES 1. Definir variables
N, I, J, FACTOR, NUM: Entero 2. Solicitar Cantidad de números 3. Leer N
4. FOR J = 1, N a. Solicitar Número b. Leer NUM c. IF NUM = 0 THEN 1. FACTOR = 1 d. ELSE
1. FACTOR = 1 2. FOR I = NUM, 1, -1
a. FACTOR = FACTOR * I 3. ENDFOR e. ENDIF
f. Imprimir FACTOR 5. ENDFOR
6. Fin
Luego se integra el uso de Top Down Design para descomponer el problema en una estructura de módulos, y después, cada módulo se diseña en seudocódigo.
Cabe aclarar que esta metodología se desarrolló en los ochentas y principios de los noventas, tiempos en que se usaba el lenguaje Pascal como prototipo para la enseñanza de la programación estructurada, por lo que, la metodología quedó un poco influenciada con el estilo que se usaba con dicho lenguaje, como es el uso de mayúsculas en las estructuras de control y en los identificadores.
4.2 Programación Estructurada en TURBO PASCAL 7 Publicada en el libro [2], donde se presenta el lenguaje TURBO PASCAL 7, explicado tomando como base la metodología del libro anterior. Es un libro que va más allá de ser un manual del lenguaje, en este libro se enseña a programar usando la metodología del libro anterior integrada con el lenguaje TURBO PASCAL 7.
Este libro tiene la misma estructura que el anterior, solo que aquí se toma como base cada algoritmo desarrollado en dicho libro, y se va explicando cómo usar el lenguaje TURBO PASCAL 7, para codificar el programa correspondiente.
Por ejemplo, se tiene el algoritmo en seudocódigo diseñado con la metodología del libro anterior:
Algoritmo FACTORIAL 1. Definir variables
NUM, I, FACTOR: Entero 2. Solicitar Número
3. Leer NUM 4. IF NUM = 0 THEN a. FACTOR = 1 5. ELSE
a. FACTOR = 1 b. FOR I = NUM, 1, -1
1. FACTOR = FACTOR * I c. ENDFOR
6. ENDIF
7. Imprimir FACTOR 8. Fin
En este libro se toma como base ese algoritmo y se explica cómo codificarlo usando el lenguaje TURBO PASCAL 7, y nos queda el programa:
program FACTORIAL;
uses Crt;
var
NUM, I, FACTOR: Longint;
begin Clrscr;
Writeln(„CALCULA EL FACTORIAL DE UN NUMERO‟);
Writeln;
Write(„TECLEE EL NUMERO: „);
Readln(NUM);
if NUM = 0 then FACTOR := 1 else
begin
FACTOR := 1;
for I := NUM downto 1 do FACTOR := FACTOR * I;
end;
Writeln;
Writeln(„FACTORIAL: ‟, FACTOR);
Writeln;
Writeln(„CUALQUIER TECLA PARA CONTINUAR‟);
repeat until KeyPressed;
end.
4.3 Programación Estructurada un enfoque algorítmico Segunda Edición
Publicada en el libro [3], donde se presenta la metodología de la programación estructurada, ahora corregida, aumentada y actualizada para los tiempos en los que se enseñaba C como primer lenguaje.
A continuación se presenta un ejemplo de cómo se usa la metodología: primero se diseña el diagrama general de la solución usando Top Down Design, en la que se definen los módulos que se requieren para solucionar el problema:
Módulo Sumar
Módulo Multiplicar
Módulo Dividir Algoritmo
AYUDA
Módulo Restar
Enseguida se diseña el algoritmo en seudocódigo, es decir, se
diseña la lógica de cada uno de los módulos usando seudocódigo:
Algoritmo AYUDA Declaraciones globales Variables
N1, N2, ResuNi, ResuMaq: Entero Desea: Carácter
Opcion: Entero 1. Módulo Principal a. DO
1. Imprimir el menú de opciones
TE PUEDO AYUDAR A:
1. SUMAR 2. RESTAR 3. MULTIPLICAR 4. DIVIDIR 5. FIN
OPCION:
2. Leer Opcion 3. CASE Opcion 1: Llamar Sumar 2: Llamar Restar 3: Llamar Multiplicar 4: Llamar Dividir 4. ENDCASE b. UNTIL Opcion = 5 c. Fin Módulo Principal 2. Módulo Sumar a. DO
1. Solicitar número uno, número dos y resultado 2. Leer N1, N2, ResuNi
3. Calcular ResuMaq = N1 + N2 4. IF ResuMaq = ResuNi THEN a. Imprimir “La suma está correcta”
5. ELSE
a. Imprimir “La suma está incorrecta”
6. ENDIF
7. Solicitar “Desea sumar de nuevo (S/N)?”
8. Leer Desea b. UNTIL Desea = “N”
c. Fin Módulo Sumar
3. Módulo Restar a. DO
1. Solicitar número uno, número dos y resultado 2. Leer N1, N2, ResuNi
3. Calcular ResuMaq = N1 - N2 4. IF ResuMaq = ResuNi THEN a. Imprimir “La resta está correcta”
5. ELSE
a. Imprimir “La resta está incorrecta”
6. ENDIF
7. Preguntar “¿Desea restar de nuevo (S/N)?”
8. Leer Desea b. UNTIL Desea = “N”
c. Fin Módulo Restar 4. Módulo Multiplicar a. DO
1. Solicitar número uno, número dos y resultado 2. Leer N1, N2, ResuNi
3. Calcular ResuMaq = N1 * N2 4. IF ResuMaq = ResuNi THEN
a. Imprimir “La multiplicación está correcta”
5. ELSE
a. Imprimir “La multiplicación está incorrecta”
6. ENDIF
7. Solicitar “Desea multiplicar de nuevo (S/N)?”
8. Leer Desea b. UNTIL Desea = “N”
c. Fin Módulo Multiplicar 5. Módulo Dividir
a. DO
1. Solicitar número uno, número dos y resultado 2. Leer N1, N2, ResuNi
3. Calcular ResuMaq = N1 / N2 4. IF ResuMaq = ResuNi THEN
a. Imprimir “La división está correcta”
5. ELSE
a. Imprimir “La división está incorrecta”
6. ENDIF
7. Solicitar “Desea dividir de nuevo (S/N)?”
8. Leer Desea b. UNTIL Desea = “N”
c. Fin Módulo Dividir
El estilo de programación en estos tiempos, promovía el uso de minúsculas combinadas con mayúsculas en los identificadores, y la estructura general del algoritmo se adapta para que resulte más natural con la estructura general de un programa en C.
Aunque el lenguaje C promueve el uso de las estructuras lógicas en minúsculas, la metodología las usa todavía en mayúsculas.
4.4 Programación Estructurada en Lenguaje C
Publicada en el libro [4], donde se presenta el lenguaje C, explicado tomando como base la metodología del libro anterior.
Es un libro que va más allá de ser un manual del lenguaje, en el mismo, se enseña a programar usando la metodología del libro anterior integrada con el lenguaje C.
Este libro tiene la misma estructura que el anterior, solo que aquí se toma como base cada algoritmo desarrollado en dicho libro, y se va explicando cómo usar el lenguaje C, para codificar el programa correspondiente.
Por ejemplo, se tiene el algoritmo en seudocódigo diseñado con la metodología del libro anterior:
Primero se diseña el diagrama general utilizando diseño descendente ( Top down design ):
Módulo
Triangulo
Módulo Cuadrado
Algoritmo AREAS
Módulo Circulo Módulo
Rectangulo
Enseguida se diseña la lógica usando seudocódigo:
Algoritmo AREAS 1. Módulo Principal a. Declaraciones Variables Opcion: Entero b. DO
1. Imprimir MENU
AREAS FIGURAS GEOMETRICAS
1. TRIANGULO
2. CUADRADO 3. RECTANGULO 4. CIRCULO 5. FIN
TECLEE OPCION:
2. Leer Opcion 3. CASE Opcion 1: Llamar Triangulo 2: Llamar Cuadrado 3: Llamar Rectangulo 4: Llamar Circulo 4. ENDCASE c. UNTIL Opcion = 5 d. Fin Módulo Principal 2. Módulo Triangulo a. Declaraciones Variables
Base, Altura, AreaTria: Real b. Solicitar Base, Altura
c. Leer Base, Altura
d. AreaTria = (Base * Altura)/2 e. Imprimir AreaTria
f. Fin Módulo Triangulo 3. Módulo Cuadrado a. Declaraciones Variables
Lado, AreaCuad: Real b. Solicitar Lado
c. Leer Lado
d. AreaCuad = Lado^2 e. Imprimir AreaCuad f. Fin Módulo Cuadrado 4. Módulo Rectangulo a. Declaraciones Variables
AreaRec, Largo, Ancho: Real b. Solicitar Largo, Ancho c. Leer Largo, Ancho d. AreaRec = Largo * Ancho e. Imprimir AreaRec f. Fin Módulo Rectangulo 5. Módulo Circulo a. Declaraciones Constantes
PI = 3.1415926536
Variables
AreaCirc, Radio: Real b. Solicitar Radio c. Leer Radio
d. AreaCirc = PI * Radio^2 e. Imprimir AreaCirc f. Fin Módulo Circulo
En este libro se toma como base ese algoritmo y se explica cómo codificarlo usando el lenguaje C, y nos queda el programa:
/* programa AREAS */
/* C909.C */
# include <stdio.h>
# include <math.h>
void main() {
/* Declaraciones */
/* Funciones */
void Triangulo();
void Cuadrado();
void Rectangulo();
void Circulo();
/* Variables */
int Opcion;
/* Instrucciones ejecutables */
do {
printf("\n");
printf("┌────────────────────────┐\n");
printf("│ AREAS FIGURAS GEOMETRICAS │\n");
printf("├────────────────────────┤\n");
printf("│ 1. TRIANGULO │\n");
printf("│ 2. CUADRADO │\n");
printf("│ 3. RECTANGULO │\n");
printf("│ 4. CIRCULO │\n");
printf("│ 5. FIN │\n");
printf("└────────────────────────┘\n");
printf(" TECLEE OPCION: ");
scanf("%d",&Opcion);
switch (Opcion) {
case 1:
Triangulo();
break;
case 2:
Cuadrado();
break;
case 3:
Rectangulo();
break;
case 4:
Circulo();
break;
}
} while (Opcion!=5);
}/* Fin funcion principal */
void Triangulo() {
float Base,Altura,AreaTria;
printf("\nCALCULA E IMPRIME EL AREA DE UN TRIANGULO\n\n");
printf("TECLEE BASE: ");
scanf("%f",&Base);
printf("TECLEE ALTURA: ");
scanf("%f",&Altura);
AreaTria = (Base * Altura) / 2;
printf("\nAREA = %10.2f\n\n",AreaTria);
printf("PRESIONE <Intro> PARA CONTINUAR...");
fflush(stdin);
getchar();
}/* Fin funcion Triangulo */
void Cuadrado() {
float Lado,AreaCuad;
printf("\nCALCULA E IMPRIME EL AREA DE UN CUADRADO\n\n");
printf("TECLEE LADO: ");
scanf("%f",&Lado);
AreaCuad = pow(Lado,2);
printf("\nAREA = %10.2f\n\n",AreaCuad);
printf("PRESIONE <Intro> PARA CONTINUAR...");
fflush(stdin);
getchar();
}/* Fin funcion Cuadrado */
void Rectangulo() {
float AreaRec,Largo,Ancho;
printf("\nCALCULA E IMPRIME EL AREA DE UN RECTANGULO\n\n");
printf("TECLEE LARGO: ");
scanf("%f",&Largo);
printf("TECLEE ANCHO: ");
scanf("%f",&Ancho);
AreaRec = Largo * Ancho;
printf("\nAREA = %10.2f\n\n",AreaRec);
printf("PRESIONE <Intro> PARA CONTINUAR...");
fflush(stdin);
getchar();
}/* Fin funcion Rectangulo */
void Circulo() {
const float PI = 3.1415926536;
float AreaCirc,Radio;
printf("\nCALCULA E IMPRIME EL AREA DE UN CIRCULO\n\n");
printf("TECLEE RADIO: ");
scanf("%f",&Radio);
AreaCirc = PI * pow(Radio,2);
printf("\n");
printf("\nAREA = %10.2f\n\n",AreaCirc);
printf("PRESIONE <Intro> PARA CONTINUAR...");
fflush(stdin);
getchar();
}/* Fin funcion Circulo */
4.5 Metodología de la Programación Orientada a Objetos Publicada en el libro [5], donde se presenta una metodología de la programación orientada a objetos, que conduce el proceso enseñanza aprendizaje, enfocado a que el estudiante desarrolle bases lógicas sólidas usando seudocódigo, el diagrama de clases, los conceptos de objetos, clases, herencia, polimorfismo
y la arquitectura modelo vista controlador independientemente de un lenguaje de programación.
A continuación se presenta un ejemplo de cómo se aplica:
primero, se diseña el diagrama de clases, que contiene la estructura general del programa (algoritmo):
Diagrama de clases
Enseguida se diseña el algoritmo que contiene la lógica que soluciona el problema usando seudocódigo.
Algoritmo CALCULA SUELDOS DE EMPLEADOS Clase Empleado
1. Declaraciones Datos
# nombreEmp: Cadena # deptoEmp: Cadena # puestoEmp: Cadena
2. Método establecerNombreEmp(nom: Cadena) a. nombreEmp = nom
b. Fin Método establecerNombreEmp 3. Método establecerDeptoEmp(dep: Cadena) a. deptoEmp = dep
b. Fin Método establecerDeptoEmp 4. Método establecerPuestoEmp(pue: Cadena) a. puestoEmp = pue
b. Fin Método establecerPuestoEmp 5. Método obtenerNombreEmp(): Cadena a. return nombreEmp
b. Fin Método obtenerNombreEmp 6. Método obtenerDeptoEmp(): Cadena a. return deptoEmp
Empleado
# nombreEmp
# deptoEmp
# puestoEmp
establecerNombreEmp() establecerDeptoEmp() establecerPuestoEmp() obtenerNombreEmp() obtenerDeptoEmp() obtenerPuestoEmp()
EmpAsalariado sueldoMensual sueldoQnaAsal
establecerSueldoMensual() calcularSueldoQnaAsal() obtenerSueldoQnaAsal() EmpPorHoras
horasTrab cuotaHora sueldoQnaHoras establecerHorasTrab() establecerCuotaHora() calcularSueldoQnaHoras() obtenerSueldoQnaHoras()
EjecutaEmpleado
b. Fin Método obtenerDeptoEmp 7. Método obtenerPuestoEmp(): Cadena a. return puestoEmp
b. Fin Método obtenerPuestoEmp Fin Clase Empleado
Clase EmpPorHoras hereda de Empleado 1. Declaraciones
Datos
horasTrab: Entero cuotaHora: Real sueldoQnaHoras: Real
2. Método establecerHorasTrab(horasTr: Entero) a. horasTrab = horasTr
b. Fin Método establecerHorasTrab
3. Método establecerCuotaHora(cuotaHr: Real) a. cuotaHora = cuotaHr
b. Fin Método establecerCuotaHora 4. Método calcularSueldoQnaHoras()
a. sueldoQnaHoras = horasTrab * cuotaHora b. Fin Método calcularSueldoQnaHoras 5. Método obtenerSueldoQnaHoras(): Real a. return sueldoQnaHoras
b. Fin Método obtenerSueldoQnaHoras Fin Clase EmpPorHoras
Clase EmpAsalariado hereda de Empleado 1. Declaraciones
Datos
sueldoMensual: Real sueldoQnaAsal: Real
2. Método establecerSueldoMensual(sdo: Real) a. sueldoMensual = sdo
b. Fin Método establecerSueldoMensual 3. Método calcularSueldoQnaAsal() a. sueldoQnaAsal = sueldoMensual / 2 b. Fin Método calcularSueldoQnaAsal 4. Método obtenerSueldoQnaAsal(): Real a. return sueldoQnaAsal
b. Fin Método obtenerSueldoQnaAsal Fin Clase EmpAsalariado
Clase EjecutaEmpleado 1. Método principal a. Declaraciones Variables
nomEmp, depto, puesto: Cadena hrsTra, tipoEmp: Entero cuoHr, sdoMen: Real desea: Carácter b. DO
1. Imprimir Menu y solicitar tipo de empleado Tipos de empleado
1. Empleado por horas 2. Empleado asalariado Teclee tipo:
2. Leer tipoEmp
3. Solicitar Nombre, departamento y puesto 4. Leer nomEmp, depto, puesto
5. IF tipoEmp = 1 THEN
a. Declarar, crear e iniciar objeto
EmpPorHoras objEmp = new EmpPorHoras() b. Solicitar número de horas trabajadas y cuota por hora
c. Leer hrsTra, cuoHr d. Establecer
objEmp.establecerNombreEmp(nomEmp) objEmp.establecerDeptoEmp(depto) objEmp.establecerPuestoEmp(puesto) objEmp.establecerHorasTrab(hrsTra) objEmp.establecerCuotaHora(cuoHr) e. Calcular
objEmp.calcularSueldoQnaHoras() f. Imprimir objEmp.obtenerNombreEmp() objEmp.obtenerDeptoEmp() objEmp.obtenerPuestoEmp() objEmp.obtenerSueldoQnaHoras() 6. ELSE
a. Declarar, crear e iniciar objeto
EmpAsalariado objEmp = new EmpAsalariado() b. Solicitar sueldo mensual
c. Leer sdoMen d. Establecer
objEmp.establecerNombreEmp(nomEmp) objEmp.establecerDeptoEmp(depto) objEmp.establecerPuestoEmp(puesto) objEmp.establecerSueldoMensual(sdoMen) e. Calcular
objEmp.calcularSueldoQnaAsal() f. Imprimir objEmp.obtenerNombreEmp() objEmp.obtenerDeptoEmp() objEmp.obtenerPuestoEmp() objEmp.obtenerSueldoQnaAsal() 7. ENDIF
8. Preguntar “¿Desea procesar otro empleado(S/N)?”
9. Leer desea c. WHILE desea = “S”
d. Fin Método principal Fin Clase EjecutaEmpleado Fin
4.6 Programación Estructurada y Orientada a Objetos un enfoque algorítmico Tercera Edición Publicada en el libro [6], donde se presenta la tercera edición de la metodología de la programación estructurada, adecuándola a los tiempos actuales, en que el lenguaje C se ha convertido en la base de los lenguajes modernos, y luego tomándola como base, se presenta una evolución hacia la orientada a objetos.
La idea es que al estudiante se le pueda enseñar en un mismo curso la programación estructurada con un enfoque algorítmico, y luego tomando como base lo anterior, que se le enseñen los conceptos básicos que aporta la programación orientada a objetos y que sea capaz de diseñar algoritmos tanto estructurados como orientados a objetos. De esta forma se le preparará para que aprenda cualquier lenguaje estructurado u orientado a objetos.
La metodología se divide en dos partes: en la primera parte, que abarca del capítulo uno al nueve, se presenta la metodología de la programación estructurada usando la técnica Top Down Design y seudocódigo.
A continuación se presenta un ejemplo, para mostrar una idea general de cómo se usa la primera parte de la metodología en la solución de una aplicación.
Primero se diseña el diagrama general de la solución usando Top Down Design:
Enseguida se diseña el algoritmo en seudocódigo:
Algoritmo MEDIA CON FUNCIONES 1. Función principal()
a. Declarar Variables
vector: Arreglo[10] Real promedio: Real b. leerVector(vector)
c. promedio = calcularMedia(vector) d. imprimirVector(vector)
e. Imprimir promedio f. Fin Función principal
2. Función leerVector(Ref vec: Arreglo[10] Real) a. Declarar
Variables n: Entero b. for n=0; n<=9; n++
1. Solicitar elemento vec[n]
2. Leer vec[n]
c. endfor
d. Fin Función leerVector
3. Función calcularMedia(Ref v: Arreglo[10] Real) Real a. Declarar
Variables
sumatoria, prom: Real i: Entero
b. sumatoria = 0 c. for i=0; i<=9; i++
1. sumatoria = sumatoria + v[i]
d. endfor
e. prom = sumatoria / i f. return prom
g. Fin Función calcularMedia
4. Función imprimirVector(Ref vect: Arreglo[10] Real) a. Declarar
Variables x: Entero b. for x=0; x<=9; x++
1. Imprimir vect[x]
c. endfor
d. Fin Función imprimirVector Fin
En la segunda parte de la metodología, que abarca del capítulo diez al trece, es donde se estudian los conceptos de la programación orientada a objetos, integrándolos con el concepto
de diagrama de clases de UML (Unified Modeling Language), con la arquitectura modelo-vista-controlador, con las estructuras estudiadas en los primeros nueve capítulos correspondientes a la programación estructurada y la incorporación de los conceptos de la programación orientada a objetos en la técnica seudocódigo, logrando una metodología de la programación que permite diseñar algoritmos orientados a objetos. Planteando una evolución de la programación estructurada a la programación orientada a objetos, enfatizando que la evolución radica en el diseño arquitectónico del algoritmo o programa, que en la programación estructurada se hace mediante técnicas como Top Down Design, y en la programación orientada a objetos se usan técnicas como el diagrama de clases.
A continuación se presenta un ejemplo, para mostrar una idea general de cómo se usa la segunda parte de la metodología en la solución de una aplicación.
La solución se hace en dos partes: en la primera, se diseña el diagrama de clases, que contiene la estructura general del algoritmo o programa.
Diagrama de clases
Obrero3 nombreObr produccion sueldo
establecerNombreObr() establecerProduccion() calcularSueldo() obtenerNombreObr() obtenerProduccion() obtenerSueldo()
Y después, en la segunda parte, se diseña el algoritmo que contiene la lógica que soluciona el problema usando seudocódigo
Algoritmo CALCULA LA PRODUCCION DE OBREROS Clase Obrero3
1. Declarar Datos
nombreObr: Cadena produccion: Entero sueldo: Real
2. Método establecerNombreObr(nom: Cadena) a. nombreObr = nom
b. Fin Método establecerNombreObr 3. Método establecerProduccion(prod: Entero) a. produccion = prod
b. Fin Método establecerProduccion 4. Método calcularSueldo()
a. if produccion <= 500 then 1. sueldo = producción * 20.00 b. endif
c. if (produccion > 500)AND (produccion <= 800) then 1. sueldo = producción * 25.00
d. endif Función
leerVector()
Función calcularMedia()
Función imprimirVector() Algoritmo
MEDIA CON FUNCIONES Función principal()
EjecutaObrero3
e. if produccion > 800 then 1. sueldo = producción * 30.00 f. endif
g. Fin Método calcularSueldo 5. Método obtenerNombreObr() Cadena a. return nombreObr
b. Fin Método obtenerNombreObr
6. Método obtenerProduccion() Real a. return produccion
b. Fin Método obtenerProduccion 7. Método obtenerSueldo() Real a. return sueldo
b. Fin Método obtenerSueldo Fin Clase Obrero3
Clase EjecutaObrero3 1. Método principal() a. Declarar Variables
nombre, obrMayor, obrMenor: Cadena dia, proDia, totProdObr, totProd,
totObreros, mayorProd, menorProd: Entero totSueldos: Real
desea: Carácter b. Imprimir encabezado c. totObreros = 0 totProd = 0 totSuedos = 0 mayorProd = 0 menorProd = 10000 d. do
1. Declarar, crear e iniciar objeto
Obrero3 objObrero = new Obrero3() 2. Solicitar Nombre
3. Leer nombre 4. totProdObr = 0
5. for dia=1; dia<=6; dia++
a. Solicitar Producción del dia b. Leer proDia
c. totProdObr = totProdObr + proDia 6. endfor
7. Establecer
objObrero.establecerNombreObr(nombre) objObrero.establecerProduccion(totProdObr) 8. Calcular objObrero.calcularSueldo() 9. Imprimir objObrero.obtenerNombreObr() objObrero.obtenerProduccion() objObrero.obtenerSueldo()
10. if objObrero.obtenerProduccion()>mayorProd then a. mayorProd = objObrero.obtenerProduccion() b. obrMayor = objObrero.obtenerNombreObr() 11. endif
12. if objObrero.obtenerProduccion()<menorProd then a. menorProd = objObrero.obtenerProduccion() b. obrMenor = objObrero.obtenerNombreObr() 13. endif
14. totObreros = totObreros + 1
totProd = totProd + objObrero.obtenerProduccion()
totSuedos = totSuedos + objObrero.obtenerSueldo() 15. Preguntar “¿Desea procesar otro obrero (S/N)?”
16. Leer desea
e. while desea == „S‟
f. Imprimir totObreros, totProd, totSueldos,
obrMayor, mayorProd, obrMenor, menorProd g. Fin Método principal
Fin Clase EjecutaObrero3 Fin
5. CONCLUSIONES
En la enseñanza de la programación siempre ha existido la tentación de enseñar el lenguaje lo antes posible, sacrificando el desarrollo de la lógica, y se cae en enseñar a operar lenguajes y no a programar; porque programar implica primero diseñar lógicamente la solución y después, codificar usando un lenguaje. En consecuencia, se están formando muchos programadores buenos para codificar usando lenguajes, pero sin bases lógicas sólidas.
El estudiante primero debe desarrollar las habilidades mentales lógicas necesarias, aprendiendo una metodología de la programación apropiada, porque la programación es lógica y debe ser independiente de algún lenguaje de programación, y después, sobre esas bases aprender el lenguaje.
Desde 1994 puse a disposición de la comunidad académica una metodología de la programación, que ha venido evolucionando, como consecuencia del desarrollo de nuevos lenguajes y el avance de los paradigmas de programación; primero se presentaron cuatro versiones de programación estructurada, luego una versión orientada a objetos, y una última versión, donde se presentan conjuntamente la estructurada y la orientada a objetos. Todas las metodologías enfocadas a que los estudiantes, primero desarrollen bases lógicas sólidas, y después, sobre esas bases, podrán aprender el lenguaje de programación.
6. REFERENCIAS
[1] L. López, Programación Estructurada un enfoque algorítmico, Computec-Alfaomega, México, 1994.
ISBN 970-15-0099-7.
[2] L. López, Programación Estructurada en TURBO PASCAL 7, Alfaomega, México, 1998.
ISBN 970-15-0075-X.
[3] L. López, Programación Estructurada un enfoque algorítmico Segunda Edición, Alfaomega, México, 2003.
ISBN 970-15-0856-4.
[4] L. López, Programación Estructurada en Lenguaje C, Alfaomega, México, 2005. ISBN 970-15-1062-3.
[5] L. López, Metodología de la Programación Orientada a Objetos, Alfaomega, México, 2006.
ISBN 970-15-1173-5.
[6] L. López, Programación Estructurada y Orientada a Objetos un enfoque algorítmico Tercera Edición, Alfaomega, México, 2011. ISBN 978-607-707-211-9.
