Ejemplos bajo el paradigma puro orientado a objetos
(Serie de ejemplos que muestran paulatinamente cómo hacer que una clase que hacía todo termine delegando en otra todo para ella erigirse en su coordinadora)
El programa más pequeño
Se muestra la estructura básica de un programa formulado bajo la pureza del paradigma.
/*puro_00.lx*/
clase tarea
{
publicos:
mensajes:
principal
{
muestre "Paradigma orientado a objetos puro"
}
}
Objetos variables y su relación con el exterior
Se usan variables de los tipos (clases) básicos en Lexico, se llenan (entre) con información proveniente del exterior (teclado) y se emite (muestre) nuevamente hacia el exterior (pantalla).
/*puro_01.lx*/
clase tarea
{
publicos:
mensajes:
principal
{
el objeto horas_trabajadas es una cantidad
el objeto nombre son caracteres
entre nombre, horas_trabajadas
muestre nombre, " trabajó ", horas_trabajadas, " horas"
}
}
Contador , acumulador y ciclo mientras
Se calcula el número de horas que en total trabajó una persona para N sesiones.
/*puro_02.lx*/
clase tarea
{
publicos:
mensajes:
principal
{
los objetos horas_trabajadas, vez, N, total_horas son cantidades
el objeto nombre son caracteres
entre nombre, N
copie 0 en total_horas, vez
mientras vez<N haga:
{
entre horas_trabajadas
copie total_horas + horas_trabajadas en total_horas
copie vez + 1 en vez
}
muestre nombre, " trabajó ", total_horas, " horas"
}
}
Clase trabajador y objeto que "sabe" acumular
En este ejemplo se define la clase trabajador con la cual se construye un objeto y el cálculo de las horas acumuladas lo realiza él mismo cada vez que se le envía el mensaje acumule. También se le envía el mensaje deme_horas_acumuladas para obtener lo que él calculó y poder entregar respuesta al usuario final. La clase tiene dos constructores pero se uso la segunda forma que exige argumentos.
/*puro_03.lx*/
clase trabajador
privados:
los objetos identificación, teléfono son caracteres
el objeto horas es una cantidad
publicos:
mensajes:
trabajador
{
copie "NN" en identificación, teléfono
copie 0 en horas
}
trabajador(entra ID, entra TEL)
{
copie ID en identificación
copie TEL en teléfono
copie 0 en horas
}
acumule(entra H) copie horas + H en horas
borre_horas copie 0 en horas
deme_horas_acumuladas(sale horas) nop /*nop ::= No hay OPeraciones explícitas*/
clase tarea
{
publicos:
mensajes:
principal
{
los objetos horas_trabajadas, vez, N, total_horas son cantidades
los objetos nombre, contacto son caracteres
entre nombre, contacto, N
el objeto X es un trabajador(sale nombre, sale contacto)
copie 0 en vez
mientras vez<N haga:
{
entre horas_trabajadas
X.acumule(sale horas_trabajadas)
copie vez + 1 en vez
}
X.deme_horas_acumuladas(entra total_horas)
muestre nombre, " dice que trabajó ", total_horas, " horas"
}
}
El objeto "sabe" más y el programa coordinador se simplifica aún más
En este ejemplo se ha trasladado más acción al interior del objeto y para ello fueron modificadas algunas cosas en la clase o modelo con la cual se construyó. La consecuencia es que al enviar los mensajes al objeto disminuye la cantidad de información que hay que enviarle pues él tiene la información y en el programa-usuario disminuye el número de objetos que hay que definir. El objeto ya sabe acumular de dos formas: una es cuando le envian el valor a acumular como argumento y la otra (usada en éste ejemplo) cuando le dicen simplemente que acumule, caso éste en el cual él ha de pedir el dato al usuario-final por el teclado en vez de la primera forma usada en el ejemplo anterior en el cual el dato es proporcionado por el programador-usuario.
/*puro_04.lx*/
clase trabajador
privados:
los objetos identificación, teléfono son caracteres
el objeto horas es una cantidad
publicos:
mensajes:
trabajador
{
los objetos nom, tel son caracteres
entre nom, tel
copie nom en identificación
copie tel en teléfono
copie 0 en horas
}
trabajador(entra ID, entra TEL)
{
copie ID en identificación
copie TEL en teléfono
copie 0 en horas
}
acumule
{
el objeto h es una cantidad
entre h
copie horas + h en horas
}
acumule(entra H) copie horas + H en horas
borre_horas copie 0 en horas
deme_horas_acumuladas(sale horas) nop /*nop ::= No hay OPeraciones explícitas*/
informe_horas muestre "Yo, ", identificación, ", trabajé ", horas, " horas."
clase tarea
{
publicos:
mensajes:
principal
{
los objetos vez, N son cantidades
entre N
el objeto X es un trabajador
copie 0 en vez
mientras vez<N haga:
{
X.acumule
copie vez + 1 en vez
}
X.informe_horas
}
}
El objeto "sabe" hacer casi todo
En este ejemplo se descongestiona aún más la clase tarea o programa principal cambiando el ciclo mientras por el ciclo variando o para quien cuenta automáticamente y hace que sobren cuatro líneas de código.
/*puro_05.lx*/
clase trabajador
privados:
los objetos identificación, teléfono son caracteres
el objeto horas es una cantidad
publicos:
mensajes:
trabajador
{
el objeto nom, tel son caracteres
entre nom, tel
copie nom en identificación
copie tel en teléfono
copie 0 en horas
}
trabajador(entra ID, entra TEL)
{
copie ID en identificación
copie TEL en teléfono
copie 0 en horas
}
acumule
{
el objeto h es una cantidad
entre h
copie horas + h en horas
}
acumule(entra H) copie horas + H en horas
borre_horas copie 0 en horas
deme_horas_acumuladas(sale horas) nop /*nop ::= No hay OPeraciones explícitas*/
informe_horas muestre "Yo, ", identificación, ", trabajé ", horas, " horas."
clase tarea
{
publicos:
mensajes:
principal
{
los objetos vez, N son cantidades
entre N
el objeto X es un trabajador
variando vez desde 1 hasta N haga:
X.acumule
X.informe_horas
}
}
El objeto "sabe" hacer todo
En este caso el objeto ha asumido todas las acciones desde pedir los datos en su construcción, calcular la suma de lo trabajado en los diversos períodos hasta pedir las horas de cada período e informar directamente al usuario final.
/*puro_06.lx*/
clase trabajador
privados:
los objetos identificación, teléfono son caracteres
el objeto horas es una cantidad
publicos:
mensajes:
trabajador
{
el objeto nom, tel son caracteres
entre nom, tel
copie nom en identificación
copie tel en teléfono
copie 0 en horas
}
trabajador(entra ID, entra TEL)
{
copie ID en identificación
copie TEL en teléfono
copie 0 en horas
}
acumule
{
el objeto h es una cantidad
entre h
copie horas + h en horas
}
acumule(entra H) copie horas + H en horas
acumule_todas
{
los objetos h, i, N son cantidades
entre N
variando i desde 1 hasta N haga:
{
entre h
copie horas + h en horas
}
}
borre_horas copie 0 en horas
deme_horas_acumuladas(sale horas) nop /*nop ::= No hay OPeraciones explícitas*/
informe_horas muestre "Yo, ", identificación, ", trabajé ", horas, " horas."
clase tarea
{
publicos:
mensajes:
principal
{
el objeto X es un trabajador
X.acumule_todas
X.informe_horas
}
}
Como puede observarse, la clase tarea, con la cual el sistema construye (instancia) la aplicación queda reducida a coordinar para que el objeto X trabaje. Qué burócrata, no hace nada, todo lo hace el trabajador !.
Aquí hay más ejemplos de programación con el lenguaje Lexico (Oct.8.2006)
También puede encontrar ejemplos en:
Artículos
Programas de ejemplo
Trabajos de estudiantes
También se presentan ejemplos en los foros
|
