[ estándares de desarrollo ]

ESTÁNDARES DE
PSEUDOCÓDIGO ORIENTADO A
OBJETOS Y EVENTOS
oLoop
Pag. 1
oLoop 1.2
Lenguaje de Pseudocódigo Orientado a Objetos y a Eventos

Elaborado por
Ángel Augusto Velásquez Núñez

Pag. 2
 Contenido
Introducción.................................................................................................................................. 1
Objetivos.................................................................................................................................. 1
Definición del Lenguaje de Pseudocódigo....................................................................................2
¿Pseudocódigo orientado a objetos?......................................................................................2
Expresiones.................................................................................................................................. 3
Sintaxis de las expresiones..................................................................................................... 3
Expresiones simples................................................................................................................ 4
Operadores................................................................................................................................... 5
Sentencias.................................................................................................................................... 6
Sentencias simples.................................................................................................................. 6
Sentencias de asignación de Valores......................................................................................6
Sentencias de mensaje........................................................................................................... 6
Sentencias de entrada/salida................................................................................................... 7
Sentencias compuestas........................................................................................................... 7
Sentencias de decisión o condicionales..................................................................................7
Iteraciones............................................................................................................................... 8
Clases y Objetos......................................................................................................................... 10
Declarar Clases..................................................................................................................... 10
Declaración de Instancias de Clases (Objetos).....................................................................11
Declaración de definición de Métodos...................................................................................11
Declaración de propiedades.................................................................................................. 14
Bibliotecas de clases............................................................................................................. 15
Polimorfismo.......................................................................................................................... 15
Comentarios............................................................................................................................... 17
Jerarquía de Clases predefinidas............................................................................................... 18
La clases Componentes............................................................................................................. 19
Atributos comunes (CComponente)......................................................................................19
Visualizar y editar texto.......................................................................................................... 19
Permitir que el usuario haga elecciones simples...................................................................20
Controles especializados....................................................................................................... 23
Manejo de Listas................................................................................................................... 24
Fichas (CFicha)..................................................................................................................... 25
La clase CFormulario............................................................................................................. 26
La clase CAplicación............................................................................................................. 26
Tratamiento de Eventos.............................................................................................................. 29
Implantar eventos estándar................................................................................................... 29
Excepciones............................................................................................................................... 31
Protección de Sentencias...................................................................................................... 31
Tratamiento de Excepciones................................................................................................. 31
Generación manual de Excepciones.....................................................................................33
Excepciones predefinidas...................................................................................................... 33
Objetos Especiales..................................................................................................................... 35
Arreglos................................................................................................................................. 35
Apuntadores.......................................................................................................................... 36
Estructuras............................................................................................................................ 37
Enumeraciones...................................................................................................................... 37
Interfaces............................................................................................................................... 38
Archivos................................................................................................................................. 39
Ejemplos de uso de oLoop......................................................................................................... 40
Declaración de Clases y Métodos..........................................................................................40
Implantación de Métodos............................................................................................................ 41
Herencia y Extensión de Clases................................................................................................. 42
Bibliografía.................................................................................................................................. 46
Sugerencias para la escritura de Pseudocódigo.........................................................................47
Indentación ........................................................................................................................... 47
Idioma de Trabajo.................................................................................................................. 47
Notación de Identificadores................................................................................................... 47

Pag. 3
 Índice de Tablas
Tabla .1. Precedencia de operadores.......................................................................................... 3
Tabla .2. Atributos comunes para los componentes en general.................................................19
Tabla .3. Atributos de CEtiqueta................................................................................................. 19
Tabla .4. Atributos de CEdición..................................................................................................20
Tabla .5. Atributos de CCasilla................................................................................................... 21
Tabla .6. Atributos de CBotónRadio............................................................................................22
Tabla .7. Atributos de CBotónAcción..........................................................................................22
Tabla .8. Atributos de CBarraDesp.............................................................................................23
Tabla .9. Atributos de Cficha....................................................................................................... 25
Tabla .10. Eventos estándar comunes a las Clases componentes.............................................29
Tabla .11. Eventos de las Clases componentes estándar..........................................................30
Tabla .12. Eventos clave para las Clases componentes.............................................................30
Tabla .13. Clases derivadas de CExcepción..............................................................................34
Tabla .14. Ejemplo de uso de Prefijos........................................................................................48

Pag. 4
 Índice de Ilustraciones
Ilustración .1. Sintaxis de factor................................................................................................... 3
Ilustración .2. Sintaxis de valor constante sin signo.....................................................................3
Ilustración .3. Sintaxis de término................................................................................................. 4
Ilustración .4. Sintaxis de expresión simple..................................................................................4
Ilustración .5. Sintaxis de expresión.............................................................................................. 4
Ilustración .6. Sintaxis de factor de dirección...............................................................................5
Ilustración .7. Sintaxis de sentencia.............................................................................................. 6
Ilustración .8. Sintaxis de sentencia simple..................................................................................6
Ilustración .9. Sintaxis de sentencia de asignación......................................................................6
Ilustración .10. Sintaxis de sentencia compuesta........................................................................7
Ilustración .11. Sintaxis de sentencia condicional. .......................................................................7
Ilustración .12. Sintaxis de sentencia Si.......................................................................................7
Ilustración .13. Sintaxis de sentencia Caso.................................................................................8
Ilustración .14. Sintaxis de sentencia repetitiva o iteración...........................................................8
Ilustración .15. Sintaxis de sentencia Mientras.............................................................................8
Ilustración .16. Sintaxis de sentencia repetir................................................................................8
Ilustración .17. Sintaxis de sentencia Para..................................................................................9
Ilustración .18. Sintaxis de declaración de Clase.......................................................................10
Ilustración .19. Sintaxis de declaración de Objeto......................................................................11
Ilustración .20. Sintaxis de declaración de definición de Método................................................11
Ilustración .21. Sintaxis de Lista formal de Parámetros..............................................................12
Ilustración .22. Sintaxis de Envío de Mensaje.............................................................................14
Ilustración .23. Ejemplo de Etiqueta............................................................................................ 19
Ilustración .24. Ejemplo de Caja de edición................................................................................20
Ilustración .25. Ejemplo de Casilla de verificación......................................................................21
Ilustración .26. Ejemplos de Botón de radio................................................................................21
Ilustración .27. Ejemplos de Botón de acción.............................................................................22
Ilustración .28. Ejemplo de Barra de desplazamiento.................................................................23
Ilustración .29. Ejemplo de Barra de dial....................................................................................24
Ilustración .30. Ejemplo de Control Arriba Abajo.........................................................................24
Ilustración .31. Ejemplo de Lista desplegable.............................................................................24
Ilustración .32. Ejemplo de Ficha................................................................................................ 25
Ilustración .33. Ejemplo de un Formulario en blanco..................................................................26

Pag. 5
 Introducción
Objetivos
Este documento tiene por finalidad que establecer los estándares de programación
y nomenclatura de objetos de programación en pseudocódigo a utilizar en las
sesiones de clase y los proyectos de desarrollo de software.

Pag. 1
 Definición del Lenguaje de
Pseudocódigo
¿Pseudocódigo orientado a objetos?
El pseudocódigo se presta para un buen diseño descendente. En el mundo del
desarrollo orientado a objetos, diseño descendente significa describir cómo se
comportan los objetos y luego utilizar la descripción para identificarlos más
detalladamente o identificar objetos subordinados. En cada nivel de abstracción, los
objetos se van detallando más hasta que el diseño alcanza los objetos existentes (ya
sea en bibliotecas o predefinidos en el lenguaje mismo), o bien el comportamiento
descrito no implica la existencia de nuevos objetos.

El lenguaje de pseudocódigo que vamos a especificar contiene las herramientas que

permiten especificar el flujo del control de un algoritmo, la creación y modificación de la
información y la relación entre los diferentes objetos que forman el universo de la
solución. Para dar un enfoque más claro optamos por subrayar las palabras reservadas
del lenguaje.

Pag. 2
 Expresiones
Las expresiones están compuestas por operadores y operandos. La mayoría de
operadores son binarios, es decir utilizan dos operandos. Los demás son unarios y
necesitan sólo un operando. Los operadores binarios utilizan la forma algebraica que
conocemos (por ejemplo, A + B). Los operadores unarios siempre preceden a sus
operandos (por ejemplo, -B).

En expresiones más complejas, las reglas de precedencia de operadores aclaran el

orden en que se realizan las operaciones.

Operadores Precedencia Categorías

@, No primera (más alta) operadores unarios
*, /, div, mod, Y segunda operadores de multiplicación/división
+, -, O tercera operadores de suma/resta
=, <>, <, >, <=, >= cuarta (última) operadores relacionales
Tabla .1. Precedencia de operadores.

Para la precedencia hay tres reglas básicas:

 Un operando entre dos operadores de precedencia diferente actúa primero
con el operando de mayor precedencia.
 Un operando entre dos operadores iguales actúa primero con el de la
izquierda.
 Las expresiones entre paréntesis se evalúan primero para ser tratadas como
un sólo operando.

Las operaciones de igual precedencia se efectúan normalmente de izquierda a derecha.

A nivel de pseudocódigo esto es bastante simple, pero en un lenguaje de programación,
el compilador podría reordenar los operandos para optimizar el código.

Sintaxis de las expresiones

Las reglas de precedencia se basan en la sintaxis de las expresiones, que se
componen de factores, términos y expresiones simples.
La sintaxis de un factor es:

Factor --> Identificador | Constante | (Expresión) | no Factor |

LlamadaMétodo | FactorDirección
Identificador --> ReferenciaArreglo |ReferenciaApuntador |
ReferenciaVariable
ReferenciaVariable --> Letra { Letra | Dígito | _ }
Constante --> Dígito { Dígito } | ‘CadenaCaracteres’

Ilustración .1. Sintaxis de factor.

Una llamada a método activa un método y denota el valor que éste retorna. Esto lo
veremos en la sección de llamada a métodos.

Un valor constante sin signo tiene la siguiente sintaxis:

ConstanteSinSigno --> Constante | ‘CadenaCaracteres’

Ilustración .2. Sintaxis de valor constante sin signo.

Un factor de dirección calcula la dirección de una variable o método. Lo ampliaremos en

la sección de apuntadores.
Aquí presentamos algunos ejemplos de factores:

Pag. 3
 X {referencia a una variable}
@X {apuntador a una variable}
15 {constante}
(X + T + Z) {subexpresión}
Seno(X/2) {llamada a un método}
No Fin {negación de un valor lógico o booleano}

Los términos aplican los operadores de multiplicación y división a los factores:

Término --> Factor [ OperadorFactor Factor]

OperadorFactor --> * | / | div | mod | y

Ilustración .3. Sintaxis de término.

Aquí algunos ejemplos de términos:

X * Z
Z / (1 - Z)
(X <= A) Y (X < Z)

Expresiones simples
Las expresiones simples aplican los operadores de suma/resta a los términos:

ExpresiónSimple --> [+ | -] Término [ OperadorTérmino Término]

OperadorTérmino --> + | - | O

Ilustración .4. Sintaxis de expresión simple.

Como ejemplos de expresiones simples podemos mencionar:

X + Z
-X
Valor1 + Valor2
I * J + 1

Una expresión aplica los operadores relacionales a las expresiones simples:

Expresión --> ExpresiónSimple [OperadorRelacional ExpresiónSimple]

OperadorRelacional --> = | <> | < | > | <= | >=

Ilustración .5. Sintaxis de expresión

Aquí algunos ejemplos de expresiones:

X = 1.5
Fin <> Error
(I < J) = (J < K)

Pag. 4
 Operadores
A nivel de pseudocódigo, podemos dividir a los operadores en operadores numéricos,
lógicos, de texto, apuntadores y relacionales.

Los operadores numéricos son muy conocidos por nosotros (+, -, *, /, div, mod); de
éstos, el operador + también se usa para concatenar textos (cadenas). Los operadores
numéricos + y - también pueden ser operadores unarios. Los operadores + y - también
se aplican a variables o constantes que contienen valores de direcciones, obteniendo
como resultado otro valor de dirección.

El valor de I div J es el cociente de I / J redondeado. Ocurre un error en ambos tipos de

división si J es cero.

El operador mod retorna el resto de la división de sus operandos, es decir:

I mod J = I - (I div J) * J

El signo del resultado es el mismo que el de I. Ocurre un error si J es cero.

Los operadores No, Y , y O son operadores lógicos/booleanos. Cabe mencionar que los
lenguajes de programación que soportan la manipulación de operandos a nivel de bits,
consideran a estos operadores como lógicos además de sus aplicaciones booleanas.

El operador @ se utiliza en un factor de dirección para calcular la dirección de una

variable. Este operador retorna la dirección de su operando, es decir construye un
apuntador hacia el operando (vea más adelante apuntadores).

FactorDirección --> @Identificador

Ilustración .6. Sintaxis de factor de dirección.

Pag. 5
 Sentencias
Las sentencias describen las acciones que puede ejecutar el algoritmo. Hay dos tipos
principales de sentencias: las sentencias simples y las sentencias compuestas.

Sentencia --> SentenciaSimple | SentenciaCompuesta

Ilustración .7. Sintaxis de sentencia.

Sentencias simples
Una sentencia simple es aquella que no puede contener otras sentencias. Tenemos los
siguientes tipos: sentencias de entrada/salida, sentencias de asignación de valores y
sentencias de mensaje.

SentenciaSimple --> SentenciaAsignación | SentenciaEntradaSalida |

SentenciaRetorno | Mensaje | Retorno

Ilustración .8. Sintaxis de sentencia simple.

Sentencias de asignación de Valores

La sentencia de asignación reemplaza el valor actual asociado a un identificador con un
nuevo valor especificado por una expresión o especifica una expresión cuyo valor lo
retorna un método.

Identificador --> Expresión

Ilustración .9. Sintaxis de sentencia de asignación.

Algunos ejemplos de sentencias de asignación:

X  Z + U
Fin  (I > J) y (I <= 100)
I  Seno(X) * M

Sentencias de mensaje
Una sentencia de mensaje activa un método especificado por un identificador de
método, si la declaración del método contiene una lista de parámetros formales,
entonces la sentencia de mensaje debe tener una lista concordante de parámetros (en
la sección de declaración, a los parámetros se les conoce como parámetros formales,
al momento del paso de mensajes se les conoce como parámetros reales). Trataremos
este tipo de sentencias en la sección de Mensajes.

Pag. 6
Sentencias de entrada/salida
Todo lenguaje de pseudocódigo debe permitir mecanismos que comuniquen nuestra
solución con el usuario. La mayoría de aplicaciones necesitan una interacción con el
usuario de la misma. Nuestro lenguaje cuenta con dos primitvas básicas para dicho fin.
La primitiva Leer permite recibir un valor del exterior y almacenarlo en la variable con el
nombre que se coloca en la sección de interfaz. La primitiva Escribir nos proporciona un
mecanismo para emitir expresiones y resultados para que puedan ser apreciados por
nuestro usuario. La manera como se escriben es la siguiente:

leer ( Identificador )
escribir ( Identificador | Expresión )

Como veremos más adelante, éstos son métodos de dominio público, por tanto entran
en la categoría de métodos de biblioteca.

Sentencias compuestas
Las sentencias compuestas son construcciones compuestas por otras sentencias que
se ejecutarán en secuencia, condicionalmente (sentencias condicionales), o
repetidamente (sentencias iterativas).

SentenciaCompuesta --> SentenciaCondicional |

SentenciaRepetitiva | Excepción

Ilustración .10. Sintaxis de sentencia compuesta.

Sentencias de decisión o condicionales

Las sentencias de decisión o condicionales seleccionan la ejecución de una secuencia
de acciones.

SentenciaCondicional --> SentenciaSi | SentenciaCaso

Ilustración .11. Sintaxis de sentencia condicional.

Decisión con hasta dos Alternativas (Sentencia Si)

La sintaxis de una sentencia de decisión con hasta dos alternativas es:

si ExpresiónBooleana
entonces
Secuencia de “n” acciones
[ sino
Secuencia de “m” acciones ]
fsi

Ilustración .12. Sintaxis de sentencia Si.

La expresión debe tomar un valor lógico de verdadero o falso. Si la expresión toma el

valor de verdadero la secuencia a continuación de la cláusula Entonces se ejecuta.

Si la expresión produce un valor de falso y está presente la parte de Sino, se ejecuta la

secuencia de acciones a continuación de Sino; si la parte Sino no se encuentra
presente, no se ejecuta nada.

Pag. 7
Decisión Múltiple (Sentencia Caso)
La sentencia Caso está conformada por una expresión (el selector) y una relación de
sentencias, cada una precedida por una constante ó por la palabra Otro. Las constantes
en Caso deben ser únicas.

caso Expresión vale

Alternativa1:
Secuencia de “n” acciones
Alternativa2 :
Secuencia de “m” acciones
...
[ otro:
Secuencia de “x” acciones ]
fcaso
Valor { , Valor } | Valor .. Valor

Ilustración .13. Sintaxis de sentencia Caso.

La sentencia Caso ejecuta la secuencia de acciones precedida por la constante de valor

igual al del selector. Si no existe tal constante y está presente la parte Otro, la
secuencia de acciones que sigue a Otro se ejecuta. Si no hay parte Otro, no se ejecuta
nada.

Iteraciones

SentenciaRepetitivas --> SentenciaRepetir |

SentenciaMientras | SentenciaPara

Ilustración .14. Sintaxis de sentencia repetitiva o iteración.

Iteración condicional de cero o más ciclos

Una sentencia Mientras contiene una expresión que controla la ejecución de una
secuencia de acciones.

Mientras ExpresiónBooleana
hacer
Secuencia de “n” acciones
fmientras

Ilustración .15. Sintaxis de sentencia Mientras.

La expresión que controla la repetición debe tomar un valor de verdadero o falso. Esta
se evalúa antes que se ejecute la secuencia de acciones contenida. La secuencia de
acciones se ejecuta en forma repetida en tanto la expresión sea verdadero. Si la
expresión da falso al inicio, ya no se ejecuta la secuencia de acciones.

Iteración condicional de uno o más ciclos.

La sentencia Repetir contiene una expresión que controla la ejecución repetida de una
secuencia de acciones dentro de esa sentencia Repetir.

Repetir
Secuencia de “n” acciones
hasta ExpresiónBooleana
frepetir

Ilustración .16. Sintaxis de sentencia repetir.

La expresión debe producir un resultado de verdadero ó falso. Las secuencia de

acciones entre las palabras Repetir y Hasta se ejecutan en secuencia hasta que, al final
de la secuencia , la expresión toma un valor de verdadero. La secuencia se ejecuta por

Pag. 8
 lo menos una vez porque la expresión se evalúa después de la ejecución de cada
iteración.

Iteración con número definido de ciclos.

La sentencia Para hace que se ejecute una secuencia de acciones mientras que se
asigna una progresión de valores a un identificador de control.

Para VariableControl desde ValorInicial a ValorFinal

[inc {+ | -} ValorIncremento]
hacer
Secuencia de “n” acciones
fpara

Ilustración .17. Sintaxis de sentencia Para.

La secuencia de acciones contenida en la sentencia Para se ejecuta una vez para cada
valor entre Val_Inic y Val_Fin en incrementos Valor_incremento. El identificador de
control siempre comienza en el valor Valor_Inic. Cuando la sentencia Para usa Desde,
el valor del identificador se incrementa o decrementa (según el signo especificado) en
Valor_incremento si está presente o en su defecto se incrementa en uno, esto por cada
repetición. Si el incremento es positivo y Val_Inic es mayor que Val_Fin entonces no se
ejecuta la secuencia de acciones. Si el incremento es negativo y Val_Inic es menor que
Val_Fin, la secuencia de acciones no se ejecuta.

Pag. 9
 Clases y Objetos.
Una clase es, al igual que los números, el texto y los booleanos, un tipo especial de
datos. En su caso consiste de un número fijo de componentes. Una clase puede estar
compuesta por atributos y métodos.

Una instancia de una clase es conocida comúnmente como objeto. Los objetos se
crean utilizando los constructores y se destruyen utilizando los destructores. Cada
objeto tiene su copia de los atributos declarados en la clase, pero todos comparten los
mismos métodos.

Declarar Clases.
Las clases se declaran de la siguiente manera:

Clase IdentificadorClase
[viene-de IdentificadorClase { , IdentificadorClase }]
Atributos
IdentificadorAtributo { IdentificadorAtributo }
Métodos
secuencia de “m” declaraciones de métodos
fclase

IdentificadorMétodo [ ( ListaFormalParámetros ) ] [ --> ]

[ abstracto | sobreescribir |
sobrecargar | estático | sincronizado ]

Constructor [ ( ListaFormalParámetros ) ]

Destructor
ListaFormalParámetros --> [ @ ] Identificador {, [ @ ]Identificador
}

Ilustración .18. Sintaxis de declaración de Clase.

La declaración de un atributo en una clase define un elemento de dato que existe en

cada instancia u objeto de la clase.

Un método es una rutina que realiza una operación sobre un objeto. Parte de la
llamada a un método (mensaje) especifica el objeto sobre el que debe operar el
método.

La declaración de un método dentro de una clase implica la implantación posterior del

método mediante una declaración de definición.

Dentro de la implantación de un método, el identificador Este representa un parámetro

implícito que referencia al objeto por el cual fue invocado el método.
Los constructores y destructores son métodos especiales que controlan la construcción
y destrucción de los objetos.

Un constructor define las acciones asociadas con la creación de objetos. Cuando se

invoca éste retorna una referencia a una instancia inicializada de una clase.

Un destructor define las acciones asociadas con la destrucción de un objeto. Cuando se

invoca, el destructor libera los recursos asignados al objeto.

Una clase puede heredar componentes de otra clase. Si C2 hereda de C1, entonces C2
es un descendiente de C1 y C1 es un ancestro de C2. La herencia es transitiva; es
decir, si C3 hereda de C2 y C2 hereda de C1, entonces C3 también hereda de C1. El
dominio de una clase está conformado por ella y todos sus descendientes.

Pag. 10
 Una clase descendiente contiene en forma implícita todos los componentes definidos
por sus clases ancestro. Una clase descendiente puede agregar nuevos componentes
a los ya heredados. Sin embargo, no puede eliminar la definición de un componente
declarado en una clase ancestro.

Seleccionar atributos
La manera como podemos accesar a los atributos de una clase es similar a lo
anteriormente visto con las variables, excepto que necesitamos especificar a que clase
pertenece este atributo.

Identificador_de_Clase.Identificador_Atributo

Esta herramienta del lenguaje de pseudocódigo nos es útil para accesar a los atributos
de una clase dentro de la definición de un método amigo de ésta. Llamamos método
amigo al método que recibe como parte de su interfaz un identificador de otra clase del
cual se puede accesar directamente a los valores de los atributos de la clase. El
concepto de amigo se entiende como un grado de confianza entre clases, pues una
clase confía su intimidad (se supone que los atributos deben encapsularse para el
exterior) a otra esperando que la receptora no de un uso indebido a los valores de sus
atributos.

Dentro de los métodos de una clase, el acceso a sus atributos propios y heredados no
necesita la especificación del identificador de clase, pues la pertenencia está
sobreentendida.

Declaración de Instancias de Clases (Objetos)

Las instancias de una clase se conocen como los objetos de la clase. Por medio de las
clases definimos en nuestro pseudocódigo la estructura y el comportamiento de los
objetos que pertenezcan a esa clase, es decir los ejemplares de la clase. Para poder
definir objetos en forma clara necesitamos establecer un identificador para el objeto y
especificar de qué clase es ejemplar.

Objeto IdentificadorObjeto ejemplar_de IdentificadorClase

Ilustración .19. Sintaxis de declaración de Objeto.

Hay que tomar en cuenta que con esta herramienta del lenguaje de pseudocódigo
estamos declarando ante el entorno que el uso de Ident_objeto denota el uso de un
objeto de la clase Ident_Clase, pero aún no hemos asignado recursos ni inicializado los
valores para los atributos propios de su clase. Para esto contamos con los
constructores, de los cuales continuaremos hablando más adelante.

Declaración de definición de Métodos

Esta parte especifica cómo se implanta el propósito para el cual fue creado el método.
Su estructura es similar a una rutina. Aquí utilizamos la palabra Método seguida del
identificador y la interfaz (si existiera). El punto (.) nos indica una selección de la Clase
como entidad global y clarifica la pertenencia del método a dicha Clase.

Método IdentificadorClase.IdentificadorMétodo
[ ( ListaFormalParámetros ) ] [ --> ]
secuencia de “n” acciones
fmétodo

Ilustración .20. Sintaxis de declaración de definición de Método.

Pag. 11
 Para los constructores y destructores, la declaración es similar a la de los métodos,
excepto que la palabra Constructor o Destructor se utiliza como identificador del
método.

Dentro de un bloque de método, la palabra reservada Heredado se puede utilizar para

acceder a identificadores de métodos sobreescritos o extendidos. Por ejemplo, en la
implantación del método CEtiquetaConMarco.Dibujar, podemos utilizar heredado para
invocar la implantación heredada del método Dibujar. Cuando un identificador está
precedido por heredado, la búsqueda se inicia con el ancestro inmediato de la clase
que contiene el método.

Veamos:
Clase CEtiquetaConMarco viene-de CEtiqueta
Métodos
Dibujar
fclase

Método CEtiquetaConMarco.Dibujar
heredado Dibujar
Color <-- clTextoVentana
Estilo <-- stSólido
fmétodo

Parámetros (Interfaz)
La declaración de un método especifica una lista formal de parámetros o interfaz. Cada
parámetro que se declara en una lista formal de parámetros es local al método en que
se declara y se le puede hacer referencia utilizando su identificador en el bloque
asociado con el método.

ListaFormalParámetros --> [ @ ] Identificador {,

[ @ ]Identificador }

Ilustración .21. Sintaxis de Lista formal de Parámetros.

A nivel de pseudocódigo, podemos distinguir dos tipos de parámetros, por valor y por
referencia. Los parámetros por valor sólo requieren el identificador del parámetro,
mientras que los parámetros por referencia necesitan ser precedidos del operador @.

Un parámetro formal por valor actúa como una variable local a la rutina, sólo que
obtiene su valor inicial de su correspondiente parámetro real al momento de invocarse
al método. Los cambios que se realicen al parámetro formal por valor no afectan el
valor del parámetro real.

El correspondiente parámetro real de un parámetro formal por valor en una sentencia

de método debe ser una expresión y su tipo de valor debe concordar con el
determinado por el contexto de utilización del parámetro.

Un parámetro formal por referencia se utiliza cuando se debe pasar un valor desde el
método a quién lo invocó. El parámetro formal por referencia representa la variable real
durante la invocación al método, por lo que cualquier cambio al valor del parámetro
formal por referencia se reflejan en el parámetro real.

Dentro del método, cualquier referencia al parámetro formal por referencia accesa al
parámetro real mismo. El parámetro real debe coincidir en tipo de valor con el
parámetro formal por referencia.

Cabe recalcar que si bien en el lenguaje de pseudocódigo no se está considerando en

forma explícita la existencia de tipos de valores, ésta queda determinada por el contexto
de utilización de las variables, al momento de asignación de valores y aplicación de
operadores.

Pag. 12
Constructores y destructores
Como hemos adelantado, los constructores y destructores son métodos que controlan
la construcción y destrucción de objetos de una clase. Ellos se especifican como
componentes de la clase como un método estándar, excepto que la palabra constructor
se utiliza como identificador del método. Al igual que los métodos, éstos se pueden
heredar.
Los constructores se usan para crear e inicializar nuevos objetos. Por lo general, la
inicialización se basa en los valores que se pasan como parámetros al constructor.
Normalmente la primera acción que realiza un constructor es invocar al constructor
heredado de su padre.

Los destructores se usan para retirar del entorno objetos. Cuando se invoca a un
destructor, se ejecutan las acciones definidas por el usuario para el destructor y luego
se libera los recursos asignados al objeto. Por lo general las acciones de un destructor
son destruir cualquier objeto contenido en él y liberar cualquier recurso solicitado por el
objeto. Típicamente la última acción que realiza un destructor es llamar al destructor
heredado para deshacerse de los atributos heredados del objeto.

Clase CFigura viene-de CObjeto

Atributos
Largo
Ancho
Objeto Lápiz ejemplar-de Clápiz
Objeto Brocha ejemplar-de Cbrocha
Métodos
Constructor(QueLargo, QueAncho)
Destructor
fClase

Método CFigura.Constructor(QueLargo, QueAncho)

heredado Constructor
Ancho <-- QueLargo
Largo <-- QueAncho
Lápiz.Constructor
Brocha.Constructor
fmétodo

Método CFigura.Destructor
Lápiz.Destructor
Brocha.Destructor
heredado Destructor
fmétodo

Acceso a los atributos

Para poder mantener la integridad de la información que maneja nuestra solución
lógica, debemos disciplinarnos en el acceso a los atributos definidos en las clases.
Conforme utilice el enfoque orientado a objetos para realizar sus algoritmos,
coincidiremos en que la manera de evitar que el cliente de un objeto acceda
directamente a los valores de los atributos propios de su clase, es necesario definir
métodos especiales cuya función sean obtener el valor del atributo o alterar éste valor.
A estos métodos especiales los denominamos métodos de lectura y métodos de
escritura.

Continuando con la sana política de establecer convenciones, a partir de ahora

acordaremos que los identificadores de métodos de lectura, es decir los que retornan el
valor de un atributo, estén conformados por la palabra Obtener seguida del nombre del
atributo; así mismo, los métodos de escritura se denotarán por la palabra Colocar
seguida del nombre del atributo y tendrán como parámetro por lo menos el valor con el
que se desea alterar el atributo.

Clase CFigura viene-de CObjeto

Atributos
Largo
Ancho
Objeto Lápiz ejemplar-de Clápiz

Pag. 13
 Objeto Brocha ejemplar-de Cbrocha
Métodos
Constructor(QueLargo, QueAncho)
Destructor
ObtenerLargo -->
ObtenerAncho -->
ColocarLargo(NuevoLargo)
ColocarAncho(NuevoAncho)
fClase

Envío de Mensajes
Un método se activa mediante el envío de un mensaje a un objeto consistente de un
identificador de método seguido por una lista real de parámetros. Este tipo de llamada
se conoce como invocar un método ó enviar un mensaje.

IdentificadorObjeto.
IdentificadorObjeto.IdentificadorMétodo [(
[(ListaRealParámetros)
ListaRealParámetros)]

Ilustración .22. Sintaxis de Envío de Mensaje.

El identificador de objeto expresado arriba debe denotar una referencia a un objeto

existente. La instancia especificada al momento del envío del mensaje se convierte en
forma implícita en un parámetro real para el método; corresponde con un parámetro
real llamado Este, que tiene el conocimiento de la clase a la que corresponde el
método que se está invocando.

Cuando invocamos a métodos de una clase dentro de la declaración de definición de

otro método de la misma clase se omite la referencia al objeto, quedando sólo el
identificador del método y la lista real de parámetros.

Para el caso de los métodos estáticos, aquellos métodos que se invocan directamente
de la clase, se utiliza el nombre de la clase seguido del identificador del método y la lista
real de parámetros.

IdentificadorClase.
IdentificadorClase.IdentificadorMétodo [(
[(ListaRealParámetros)
ListaRealParámetros)]

El identificador de clase especificado debe hacer referencia a una clase existente y

debe separarse por un punto del identificador del método del mensaje.

Declaración de propiedades
Las propiedades son una característica presente en muchos lenguajes de
programación. Para declarar propiedades en oLoop se utiliza la siguiente sintaxis.

Propiedad IdentificadorPropiedad
[ obtener IdentificadorAtributo | IdentificadorMétodo ]
[ colocar IdentificadorAtributo | IdentificadorMétodo ]

Por ejemplo:

Clase CCliente
Atributos
Nombres
Apellidos
fechaÚltimaCompra
Métodos
ObtenerNombres ->
ColocarNombres(pNombres)
ObtenerApellidos ->
ColocarApellidos(pApellidos)
ObtenerNombreCompleto ->
Propiedad NombreCompleto
obtener ObtenerNombreCompleto
Propiedad ÚltimaCompra

Pag. 14
 obtener fechaÚltimaCompra
colocar fechaÚltimaCompra
fclase

Bibliotecas de clases
Las clases en una aplicación pueden organizarse en bibliotecas. oLoop permite la
especificación y uso de bibliotecas de clases en el pseudocódigo.

Especificación de bibliotecas

Para especificar que una clase pertenece a un biblioteca determinada, basta con utilizar
la sentencia Biblioteca.

Biblioteca IdentificadorBiblioteca

Esta sentencia se coloca como primera línea de la declaración de clase, indicando que
la clase a declarar estará formando parte de la biblioteca indicada. Varias clases
pueden pertenecer a la misma biblioteca.

En la nomenclatura de identificadores de biblioteca, puede utilizarse el símbolo de punto

para delimitar los niveles de organización en el nombre de la biblioteca.

Por ejemplo:

Biblioteca com.empresa.aplicacioncompras.entidadesnegocio
…
Clase CCompra viene-de CEntidadNegocio
…
fclase

Uso de bibliotecas

Para indicar que una clase puede hacer uso de las clases públicas en una biblioteca, se
utiliza la sentencias Usar.

Usar IdentificadorBiblioteca

La sentencia Usar se aplica para cada biblioteca cuyas clases e interfaces vaya a
utilizar la clase a declarar. Por ejemplo:

Biblioteca com.empresa.aplicacioncompras.cliente

Usar com.empresa.aplicacioncompras.entidadesnegocio
Usar com.empresa.utilidades

Clase CComprasAplicacion viene-de CAplicacion

…
fclase

Polimorfismo
Una de las características importantes del paradigma orientado a objetos es el
polimorfismo. El mismo nombre nos da una idea clara del concepto de polimorfismo,
pues poli significa múltiple y morfismo viene de formas, esto implica que un mismo
objeto puede tomar diversas formas. En oLoop, el polimorfismo se contempla en la
instancia de objetos y en la consulta de tipos.

Pag. 15
 Durante la creación de instancia de clases, puede aplicarse el polimorfismo, declarando
una clase como ejemplar de una clase genérica, e invocando al constructor de una
clase hija más específica al momento de crear la instancia. En la siguiente sección
daremos un ejemplo de este tipo de instancia.

Consulta de tipo

oLoop implementa la consulta de tipo de un objeto por medio de la palabra reservada

es-instancia-de.

IdentificadorObjeto es-instancia-de IdentificadorClase

La combinación de estos elementos constituye una expresión booleana que puede ser
verdadera o falsa. Por lo general se utiliza en combinación con la sentencia
Si..entonces.

En el siguiente ejemplo, se asume la existencia de tres clases, una clase genérica

CEmpleado y dos clases descendientes denominadas CEmpleadoTiempoParcial y
CEmpleadoTiempoCompleto. La variable Empleado se declara como ejemplar de la
clase CEmpleado, pero al momento de crear la instancia, se utiliza el método
constructor de la clase CEmpleadoTiempoCompleto. Posteriormente, se consulta en
una sentencia Si para saber si el objeto es una instancia del tipo
CEmpleadoTiempoCompleto.

Objeto Empleado ejemplar-de CEmpleado

…
Empleado ← CEmpleadoTiempoCompleto.constructor(cod, salario)
…
Si(Empleado es-instancia-de CEmpleadoTiempoCompleto) entonces
…
fsi
…

Casting de tipo
El término casting proviene de la palabra cast que significa en español molde, por lo
que una traducción literal nos llevaría a algo como hacer un molde. oLoop implementa
en su sintaxis la especificación de casting de un objeto, anteponiendo al identificador de
objeto el nombre de la clase cuya forma se desea que asuma, encerrada entre
paréntesis.

(IdentificadorClase) IdentificadorObjeto

Esto puede ser de utilidad en las operaciones de asignación. En caso se desee invocar
a un método que pertenece a la clase objeto del casting, se encierra la expresión de
casting entre paréntesis y se invoca al método deseado.

((IdentificadorClase) IdentificadorObjeto).IdentificadorMétodo

Continuando con el ejemplo expuesto líneas arriba, se envía un mensaje al objeto

Empleado para que invoque al método obtenerSalario, método accesor que pertenece a
la clase CEmpleadoTiempoCompleto y no a la clase CEmpleado.

…
salario ← ((CEmpleadoTiempoCompleto)Empleado).obtenerSalario
…

Pag. 16
 Comentarios
Los comentarios son construcciones que no forman parte de la descripción de la lógica,
pero son valiosos elementos para explicar y hacer más claro nuestro algoritmo. Para
insertar un comentario, basta con escribir dos símbolos de división seguidos (//) y a
continuación el texto que se desee colocar. Se considera comentario hasta el final de la
línea.

// Este es un ejemplo de un comentario

// que ocupa varias líneas.

Pag. 17
 Jerarquía de Clases predefinidas
La mayoría de herramientas de la actualidad nos proporcionan una jerarquía de clases
predefinidas que podemos tomar como punto de partida para desarrollar nuestra
aplicación y para crear nuestras propias clases. Nosotros no tenemos que consumir
tiempo en crear clases que cumplan estas funciones. Basta con crear instancias de sus
clases. Acorde con esto, nuestro lenguaje de pseudocódigo también pone a disposición
del creador de aplicaciones un conjunto de clases que tienen los atributos y métodos
básicos para concebir nuestra solución. Se ha tratado de no incluir los atributos o
métodos que están estrechamente relacionados con los aspectos visuales o físicos,
dejando sólo los que nos ayuden a definir el comportamiento de nuestro algoritmo.

La clase raíz de nuestra jerarquía es CObjeto, la cual es una clase completamente

abstracta y que sólo sirve de punto de partida del árbol. La clase que desciende ésta es
CComponente, de la cual descienden todas las demás clases de nuestra jerarquía. Es
con ella que comenzamos nuestra descripción.

Pag. 18
 La clases Componentes

Atributos comunes (CComponente)

La lista de atributos varía entre componentes, pero algunos son comunes a todos:

Atributo Función
Activado Determina si el componente reaccionará ante las acciones del usuario.
Visible Determina si el componente se mostrará sobre el formulario durante la
ejecución.
Tabla .2. Atributos comunes para los componentes en general.

Clase CComponente viene-de CObjeto

Atributos
Activado
Visible
…
Métodos
…
ObtenerActivado -->
ObtenerVisible -->
ColocarActivado
ColocarVisible
fclase

Existen, como veremos más adelante, dos clases que definen dos niveles de
profundidad en la jerarquía, CControl y su hijo, CControlWindows. Las clases que
describiremos a continuación son descendientes directas de CControlWindows.

Visualizar y editar texto

Posiblemente la tarea más común en un programa es mostrar y editar texto. Las
capacidades de texto se utilizan para obtener información del usuario y retornar
resultados al mismo. Para facilitarnos esta labor, contamos con tres componentes
básicos para manejar texto: Etiquetas, Cajas de Edición y Cajas de Memo.

El componente Etiqueta (CEtiqueta)

In fo rm a c ió n d e l E n to rn o

Ilustración .23. Ejemplo de Etiqueta.

El componente etiqueta nos permite mostrar texto, pero no permite al usuario ingresar
información. El texto que muestra este componente está contenido en el atributo Título
del componente.

Atributo Función
Título Contiene el texto que muestra la Etiqueta
Tabla .3. Atributos de CEtiqueta.
Clase CCEtiqueta viene-de CControlWindows
Atributos

Pag. 19
 Título
…
Métodos
…
ObtenerTítulo -->
ColocarTítulo
fclase

El componente Caja de Edición (CEdición)

N o m b re

Ilustración .24. Ejemplo de Caja de edición.

Un componente relacionado con la Etiqueta es la caja de Edición. Este componente le

permite visualizar información, pero a su vez permite al usuario ingresar información
que puede ser utilizada por nuestro programa. El texto de la Caja de Edición está
contenido en el atributo Texto del componente. Como es de suponerse, el texto se
ingresa digitando, pero a manera de comentario, agrego que la Caja de Edición soporta
las operaciones estándares de cortar, copiar y pegar. Aunque al momento de la
concepción del algoritmo, suponemos la existencia de recursos ilimitados, debemos
tomar en cuenta que la mayoría de herramientas permiten que se ingrese textos de
hasta 255 caracteres. Los atributos clave para un componente de este tipo son los
siguientes:

Atributo Función
Texto Contiene el texto que visualiza la caja de Edición o que ingresa el
usuario.
Modificado Indica si el texto ha sido modificado por el usuario. Esta propiedad
puede verificarse para ver si se necesita algún procesamiento para
el texto.
SoloLectura Si está en Verdadero, prohibe al usuario la edición del texto.
Tabla .4. Atributos de CEdición.
Clase CCEdición viene-de CControlWindows
Atributos
Texto
Modificado
SóloLectura
…
Métodos
…
ObtenerTexto -->
ColocarTexto
ObtenerModificado -->
ColocarModificado
ObtenerSóloLectura -->
ColocarSóloLectura
fclase

Permitir que el usuario haga elecciones simples

Tan útil como la capacidad de ingresar texto, a menudo deseamos restringir lo que el
usuario ingrese a unas cuantas alternativas. Por ejemplo, si deseamos obtener el
estado civil de una persona, podríamos colocar una Etiqueta como ¿Es usted
casado(a)? y utilizar una Caja de Edición para obtener la respuesta. Sin embargo, no
sabemos cómo nos puede responder el usuario. Puede ingresar Sí o No, o puede sólo

Pag. 20
 ingresar S o N. Y como usted y yo sabemos, siempre existe la posibilidad de un ingreso
erróneo.

Las herramientas de la actualidad nos proporcionan componentes estándares para

manejar las alternativas simples. La primera es la Casilla de Verificación que se utiliza
para proporcionar al usuario elecciones del tipo Sí o No. El otro componente es el Botón
de Radio, que se utiliza para brindar al usuario un conjunto muy limitado de alternativas.

La Casilla de Verificación (Ccasilla)

V e rific a r o rto g ra fía

A c tiv a r g u io n e s
A u to c o rre c c ió n

Ilustración .25. Ejemplo de Casilla de verificación.

La Casilla de verificación es muy fácil de configurar. Sólo debe asignarse valor al

atributo Título para visualizar lo que se desee que aparezca junto a la casilla. El Título
debe ser una oración o proposición que tiene una respuesta obvia de Sí o No. Cuando
el usuario encuentra una Casilla de Verificación, una marca de verificación () indica
una respuesta de Sí o Verdadero. Si no hay marca alguna, la respuesta será No o
Falso. El usuario puede cambiar el estado de la Casilla de Verificación haciendo clic
sobre la Casilla o presionando la barra espaciadora mientras que este componente
tiene el foco. Para determinar qué respondió el usuario, tenemos que examinar el
atributo Verificada de la Casilla. Un uso muy frecuente de las Casillas de Verificación
es para establecer las opciones de un programa. Si la Casilla está Verificada, la opción
está activa.

Atributo Función
Título Determina el texto que aparece junto a la casilla.
Verificada Determina si el usuario activó la casilla de verificación.
Tabla .5. Atributos de CCasilla.
Clase CCasilla viene-de CControlWindows
Atributos
Título
Verificada
…
Métodos
…
ObtenerTítulo -->
ColocarTítulo
ObtenerVerificada -->
ColocarVerificada
fclase

Botones de Radio (CbotónRadio)

Im p re s o ra lo c a l
Im p re s o ra d e re d
U n A rc h iv o e n d is c o ...

Ilustración .26. Ejemplos de Botón de radio.

Los Botones de Radio son otro medio para presentar al usuario un número limitado de
alternativas, donde cada Botón de Radio corresponde con una posibilidad. El término
Botón de Radio tiene su origen en la idea de las radios de los carros que tenían varios
botones que se presionaban para elegir una estación. El botón permanecía hundido

Pag. 21
 luego de presionarse. Uno elegía otra estación presionando un botón y el anterior se
levantaba. Los Botones de Radio en un programa funcionan de la misma manera. Sólo
uno de los “Botones” puede estar presionado en un instante dado. La elección de un
Botón hace que todos los demás se deseleccionen. En la pantalla cada Botón de Radio
se presenta como un círculo. El Botón seleccionado tiene un punto negro en el interior,
mientras que todos los demás están vacíos.

Atributo Función
Título Determina el texto que aparece junto al Botón de Radio.
Verificada Determina si el usuario eligió esta alternativa.
Tabla .6. Atributos de CBotónRadio.

Configurar los Botones de Radio es tan simple com con las Casillas de Verificación.
Basta con establecer el atributo Título para que el usuario conozca la alternativa
representada por el Botón. Durante la ejecución examinamos el atributo Verificada de
cada Botón para determinar cuál fue seleccionada por el usuario.

Clase CBotónRadio viene-de CControlWindows

Atributos
Título
Verificada
…
Métodos
…
ObtenerTítulo -->
ColocarTítulo
ObtenerVerificada -->
ColocarVerificada
fclase

Botones para presionar (CBotónAcción)

< Back Next > OK Cancel

Ilustración .27. Ejemplos de Botón de acción.

Otro componente ampliamente utilizado es el componente Botón de Acción. Este

componente proporciona al usuario un medio para iniciar alguna acción en un
programa, como grabar un registro o realizar un cálculo. El atributo clave para este
componente es Título y es un texto que le dice al usuario qué acción se llevará a cabo
cuando presione el Botón de Acción.

Atributo Función
Título Contiene el texto que muestra el Botón de Acción
Cancelar En Verdadero si se desea que que el Botón reaccione cuando el
usuario presione Esc.
PorDefecto En Verdadero si queremos que la tecla Enter haga que el Botón
reaccione, aún si éste no tiene el foco.
Tabla .7. Atributos de CBotónAcción.
Clase CBotónAcción viene-de CControlWindows
Atributos
Título
Cancelar
PorDefecto
…
Métodos
…
ObtenerTítulo -->
ColocarTítulo
ObtenerCancelar -->
ColocarCancelar

Pag. 22
 ObtenerPorDefecto
ColocarPorDefecto
fclase

Controles especializados
Los siguientes controles proporcionan alternativas para la captura de datos.
 La Barra de Desplazamiento se utiliza para seleccionar valores en un rango
continuo.
 La Barra de Dial es útil para dar un mayor efecto de barra de
desplazamiento.
 El Arriba Abajo ayuda a conectar un spinner con una caja de edición.

Barras de Desplazamiento (CBarraDesp)

Ilustración .28. Ejemplo de Barra de desplazamiento.

Esta es la barra de desplazamiento de Windows, que se utiliza para desplazar el

contenido de una ventana; formulario o control. En la tabla podemos apreciar sus
principales atributos.

Atributo Función
VariaciónGrande Determina cuanto se mueve cuando el usuario hace clic
sobre la barra a cualquiera de los lados.
VariaciónPequeña Determina cuanto se mueve cuando el usuario hace clic
sobre las flechas a los extremos de la barra o utiliza las
flechas de desplazamiento en el teclado. Su valor por
defecto es 1.
Mín/Máx Indican cuántas posiciones están disponibles en la barra de
desplazamiento.
Posición Informan de cuánto se ha desplazado en la barra.
Tabla .8. Atributos de CBarraDesp.
Clase CBarraDesp viene-de CControlWindows
Atributos
VariaciónGrande
VariaciónPequeña
Mín
Máx
Posición
…
Métodos
…
ObtenerVariaciónGrande -->
ColocarVariaciónGrande
ObtenerVariaciónPequeña -->
ColocarVariciónPequeña
ObtenerMín -->
ColocarMín
ObtenerMáx -->
ColocarMáx
ObtenerPosición -->
ColocarPosición
fclase

Barra de Dial (Cdial)

Pag. 23
 Ilustración .29. Ejemplo de Barra de dial.

Este tipo de barra es conveniente cuando se desea establecer o ajustar valores

numéricos sobre un rango continuo, como el volumen o el brillo. Dicho componente
consiste de una barra que define la extensión o rango de ajuste y un indicador que
muestra el valor actual del control y proporciona los medios para modificar el control.

El usuario mueve el indicador arrastrándolo a una ubicación en particular o haciendo

clic sobre una zona específica de la barra, lo que mueve el indicador directamente a
esa posición. Sus propiedades son básicamente similares a los de la barra de
desplazamiento.

Control Arriba Abajo (CarribaAbajo)

L o n g itu d : 3 3 .4 0

Ilustración .30. Ejemplo de Control Arriba Abajo.

Los controles ArribaAbajo son cajas de texto que aceptan un conjunto limitado y
ordenado de valores discretos que varían en forma cíclica.

Cuando el usuario hace clic sobre la caja de texto o los botones, el foco pasa a la caja
de texto del control. El usuario puede escribir un valor directamente en la caja de texto o
utilizar los botones para incrementar o decrementar el valor.

Uilice Asociar parta conectar el control con una caja de texto.

Uilice Máx y Mín para establecer los límites sobre los que puede fluctuar el valor del
control.
El atributo Posición almacena el valor conforme el control va incrementándose o
decrementándose. Este atributo se establecer con un valor por defecto.

Por defecto, este control se detiene en su valor máximo. Si deseamos que el control
regrese al valor mínimo cuando llega al máximo, coloque Circular en Verdadero.

Manejo de Listas

E s tilo : N o rm a l

Ilustración .31. Ejemplo de Lista desplegable.

Las listas se utilizan para presentar al usuario con una colección de elementos de los
que se puede seleccionar uno o más de ellos. Acorde con las herramientas de hoy,
distinguimos varias clases predefinidas.

Una Caja de Lista se utiliza para mostrar un lista de textos de las que se puede
seleccionar uno o más.

La Lista Combinada muestra un lista que se despliega, y es útil para ahorrar espacio.
Las Vista en Árbol muestra los elementos en forma jerárquica.

Pag. 24
Atributos comunes para los controles de Lista
Para agregar columnas adicionales a un control de lista, contamos con el atributo
Columnas, que almacena el número de columnas que se desee.

La propiedad Elementos es en realidad un conjunto de cadenas texto que se llenan con

valores.

El atributo Indice de Elemento indica cuál de los elementos en la lista se ha

seleccionado.

Se puede permitir a los usuarios seleccionar más de un elemento a la vez

estableciendo la propiedad Multielección en verdadero. Los usuarios pueden entonces
utilizar la tecla Ctrl para seleccionar elementos en posiciones discontinuas, o Shift para
seleccionar un rango de elementos.

El atributo Ordenada determina si la lista se ordenará el orden alfabético.

Cajas de Lista (CCajaLista)

Una caja de lista muestra una relación de la que los usuarios pueden seleccionar uno o
más elementos. Las cajas de lista basan su comportamiento en los valores de los
tributos especificados en la sección anterior.

Listas combinadas (CListaCombinada).

Una lista combinada es un control que combina una caja de texto con una lista. Los
usuarios pueden digitar texto o seleccionar un elemento de la lista, con lo que el valor
de Texto se actualiza.

Por defecto la lista desplegable muestra 8 elementos. Para incrementar o decrementar

dicho valor colóquelo en el atributo CantidadDesplegada.

Fichas (CFicha)

G ra b a r C o m p ila d o r

Ilustración .32. Ejemplo de Ficha.

Este componente es un conjunto de páginas que se utiliza para crear diálogos de varias
páginas. En la siguiente tabla se muestran sus propiedades.

Atributo Función
PáginaActiva Especifica cuál es la ficha seleccionada en ese
momento.
Multilínea Es Verdadero si hay varias líneas de fichas.
NúmeroDePáginas Especifica el número de páginas.
Páginas Nos permite acceso a las fichas.
Tabla .9. Atributos de Cficha.

Pag. 25
La clase CFormulario

Formulario en Blanco

Ilustración .33. Ejemplo de un Formulario en blanco.

La clase componente CFormulario es por lo general el centro de toda aplicación. Sobre

un formulario colocamos otros elementos, y los podemos utilizar como simples
formularios, ventanas, cajas de diálogo o formularios de entrada de datos.

Para mostrar un formulario que no está activo en este momento en nuestra aplicación,
utilizamos los métodos Mostrar y MostrarModal (el término modal indica que no se
puede seleccionar otras áreas de la aplicación mientras está activo el formulario). El
atributo ControlActivo es una apuntador que tiene la dirección del control activo sobre el
formulario.

Puede utilizar el método de tratamiento de evento AlCrear para establecer valores

iniciales para los atributos y hacer cualquier proceso que se desee ocurra antes que el
usuario comience a interactuar con el formulario.

Además de estos atributos y métodos, esta clase tiene todos los atributos y métodos de
los controles de Windows pues es un descendiente de la clase CcontrolWindows.

Clase CFormulario viene-de CControlWindows

Atributos
Apuntador ControlActivo
ResultadoModal
Métodos
Constructor
AlCrear
Mostrar
MostrarModal
Destructor
fclase

La clase CAplicación

Todo algoritmo que representa una aplicación utiliza una clase que desciende de
CAplicación. Cuando ejecuta su aplicación, se invoca al método Principal. El método
Terminar finaliza la ejecución de la aplicación. El atributo FormularioPrincipal es una
apuntador que debe tener el valor de la dirección del formulario que aparece como base
de la aplicación.

Dado que los entornos actuales existe la propiedad de minimizar y restaurar la

aplicación, hemos incluido estos métodos para que puedan invocarse por
programación. Así mismo los puede extender para que realice otras acciones aparte.

Pag. 26
Podemos especificar cómo se manejarán las excepciones utilizando los métodos
ManejarExcepción, AlOcurrirExcepción y MostrarExcepción.

CAplicación tiene varios métodos de tratamiento de eventos que permiten especificar

cómo la aplicación procesa la ocurrencia de eventos especiales. Para especificar qué
ocurre cuando la aplicación se activa o inactiva utilizamos los métodos AlActivar y
AlDesactivar. Cuando la aplicación entra en estado de espera (conocido como idle)
podemos especificar que ocurra algo por medio del método AlEsperar.

Además de estos atributos y métodos, el componente CAplicación tiene también los

atributos y métodos que se aplican a todos los componentes, pues es un descendiente
directo de CComponente.
Ejemplo.

Clase CAplicación viene-de CComponente

Atributos
Arreglo aEntorno
nEntorno
Apuntador FormularioPrincipal
Título
Métodos
Constructor(aEntorno, nEntorno)
Principal
Terminar
Minimizar
Restaurar
ManejarExcepción
AlOcurrirExcepción
MostrarExcepción
AlEsperar
AlActivar
AlDesactivar
Destructor
fclase

Observe que el método constructor tiene dos parámetros: aEntorno y nEntorno. Estos
son respectivamente un arreglo de cadenas de texto y un número respectivamente.
Contienen los parámetros que nos envía el entorno del sistema y el número de
parámetros que estamos recibiendo.

El siguiente ejemplo es un uso muy sencillo de esta clase. El objetivo de esta aplicación
es mostrar un mensaje en la pantalla.

Clase CMiAplicación viene-de CAplicación

Métodos
Constructor(aEntorno, nEntorno)
Principal
fclase

Método Constructor(aEntorno, nEntorno) de CMiAplicación

Heredado Constructor(aEntorno, nEntorno)
Título <-- ‘Aplicación de Ejemplo’
FormularioPrincipal <-- Nulo
fmétodo

Método Principal de CMiAplicación

heredado Principal
MostrarMensaje(‘Pertenezco a la clase CMiAplicación’)
fmétodo

Observe que nosotros estamos creando un descendiente de la clase CAplicación, pero

en ningún momento estamos creando una instancia de CMiAplicación. Estos es debido
a que estamos utilizando el concepto de que el sistema es quien ejecuta nuestra
aplicación, y por tanto la creación de la instancia y la llamada a los métodos Constructor

Pag. 27
 y Principal depende del sistema, no del programador. En la implantación no siempre
ocurre lo mismo. Algunas herramientas cuentan con un programa principal que necesita
que creemos la instancia de la aplicación y llamemos a los métodos Constructor y
Principal (o sus equivalentes).

Pag. 28
 Tratamiento de Eventos
Los eventos son parte importante de las clases, aunque el desarrollador por lo general
no necesita mayor esfuerzo con ellos. Un evento es un enlace entre una ocurrencia en
el sistema (como una acción del usuario o un cambio en el foco) a la que una clase
podría necesitar responder y una sección de código que responde a esa ocurrencia. El
bloque de código de respuesta es el gestor del evento, y mayormente lo escribe el
creador de la clase.

Al utilizar los eventos, los desarrolladores de aplicaciones pueden personalizar el

comportamiento de las clases sin tener que cambiar las clases en sí. Como creadores
de clases, utilizamos los eventos para que los desarrolladores de aplicaciones
personalicen el comportamiento de nuestras clases.

Los eventos para la mayoría de las acciones del usuario (como por ejemplo las
acciones del ratón) ya están incorporadas en las clases predefinidas de nuestro
lenguaje, pero proporcionamos los mecanismos para definir nuevos eventos y
asociarlos con las clases.

En nuestro lenguaje de pseudocódigo, las clases predefinidas tiene incorporados

métodos que responden a cietros eventos estándares. Por ejemplo la clase
CBotónAcción tiene un método AlClic. La capa de administración de eventos es el
conjunto de mecanismos que toda herramienta de desarrollo orientada a objetos y
eventos tiene y que debemos suponer como existente. El lenguaje de pseudocódigo
proporciona los mecanismos para la escritura del código que responde a los eventos,
pero es durante la ejecución que se va transfiriendo el control a los métodos
correspondientes, y esta labor la realiza la capa de administración de eventos, la cual
está fuera del contexto de nuestro lenguaje.

Implantar eventos estándar

Eventos estándar para todos los controles

Los eventos básicos se definen en la clase CControl. Todos los controles, sean de
Windows, gráficos o personalizados, heredan estos eventos. La siguiente tabla lista los
eventos disponibles para todos los controles:

Evento Ocurre cuando Método asociado

Clic El usuario presiona una vez el botón AlClic
izquierdo del ratón.
DobleClic El usuario presiona dos veces seguidas el AlDobleClic
botón izquierdo del ratón.
ArrastrarSoltar El usuario arrastra el objeto con el ratón. AlArratrarSoltar
FinArrastrar Finaliza la oparción de arrastrar, es decir, AlFinArrastrar
suelta el ratón.
MoverRatón Se desplaza por la pantalla el puntero del AlMoverRatón
ratón.
ArratrarSobre El puntero del ratón está pasando sobre un AlArrastrarSobre
objeto.
UndirRatón Presionar el botón del ratón. AlUndirRatón
SoltarRatón Levantar el dedo del botón del ratón. AlSoltarRatón
Tabla .10. Eventos estándar comunes a las Clases componentes.

Todos los eventos estándar tienen sus correspondientes métodos declarados en la

clase CControl, con el mismo nombre que el evento, pero precedidos por el prefijo Al.

Aquí expresamos de otra manera lo anteriormente dicho:

Pag. 29
 Clase CControl viene-de CComponente
Métodos
AlClic
AlDobleClic
AlArrastrarSoltar
AlMoverRatón
AlArrastrarSobre
AlUndirRatón
AlSoltarRatón
fclase

Eventos estándar para los controles estándar

Además de los eventos comunes a todas las clases de componentes, los controles
estándar (de Windows) tiene los siguientes eventos:

Evento Ocurre cuando Método asociado

Entrar se pasa el foco al componente AlEntrar
SoltarTecla el usuario deja de presionar una tecla AlSoltarTecla
UndirTecla el usuario realiza presión sobre una tecla AlUndirTecla
PresionarTecla la combinación de las dos anteriores AlPresionarTecla
Salir perder el foco AlSalir
Tabla .11. Eventos de las Clases componentes estándar.

Al igual que los eventos estándar de la sección anterior, los eventos para los controles
de Windows (CControlWindows) tiene sus métodos correspondientes.

Clase CControlWindows viene-de CControl

Métodos
AlEntrar
AlSoltarTecla
AlUndirTecla
AlPresionarTecla
AlSalir
fclase

Eventos clave

Clase Evento Ocurre cuando

CEdición Cambiar El usuario modifica el texto en la Caja.
CBotónAcción Clic El usuario hace clic sobre el Botón.
CCasilla Clic El usuario hace clic sobre la Casilla de
Verificación.
CBotónRadio Clic El usuario hace clic sobre el Botón de radio
Tabla .12. Eventos clave para las Clases componentes.

De todos estos eventos clave, el único que no está ya contemplado por las clases es el
evento Cambiar. Para este evento, el método asociado en la clase CEdición sería
AlCambiar.

Pag. 30
 Excepciones
Una excepción es por lo general una condición de error u otro evento que interrumpe el
flujo normal de ejecución en una aplicación. Cuando se provoca una excepción, ésta
hace que el control se transfiera del punto actual de ejecución a un gestor de
excepciones. El soporte de manejo de excepciones del lenguaje de pseudocódigo
proporciona una manera estructurada de separar la lógica normal del algoritmo de la
lógica de manejo de errores, facilitando así el mantenimiento y fortaleciendo la solución.

Para representar las excepciones optamos por utilizar objetos. Las ventajas principales
son:
 Las excepciones se pueden agrupar en jerarquías utilizando la herencia.
 Se pueden introducir nuevas excepciones sin afectar el código existente.
 Un objeto de excepción puede llevar información (como un mensaje de error
o un código de error) desde el punto donde se provocó hasta el punto donde
se maneja.

Las excepciones se manejan con las sentencias Proteger…Excepción.

Protección de Sentencias
Las excepciones se manejan usando la sentencia Proteger…Excepción.

Proteger
lista de sentencias protegidas
Excepción
Bloque de excepciones
Sino
Bloque a ejecutar cuando no coincide con las listadas
fproteger

Una sentencia Proteger…Excepción ejecuta las sentencias en la lista de sentencias en

orden secuencial. Si las sentencias se ejecutan sin que se provoquen excepciones, el
bloque de excepciones se ignora, y el control se pasa a la sentencia que sigue a la
palabra reservada fproteger que finaliza la sentencia Proteger…Excepción.

Tratamiento de Excepciones
Cuando identificador-clase-excepción
Hacer
Secuencia de acciones para tratar la excepción
fcuando

El bloque de excepciones en la sección Excepción…fproteger define los manejadores

de excepciones para la lista de sentencias protegidas. Un manejador de excepciones
sólo se puede invocar por una sentencia Provocar ejecutada en el la lista de sentencias
protegidas o por un método invocado en la lista de sentencias protegidas.

Cuando se provoca una excepción, el control se transfiere al manejador más próximo

que puede tratar las excepciones de esa clase. La búsqueda de un manejador de
excepción se inicia con la sentencia Proteger…Excepción ingresada más
recientemente y de la que aún no hemos salido. Si esa sentencia Proteger…Excepción
no puede tratar la excepción, se examina la siguiente sentencia Proteger…Excepción a
la que se ha ingresado recientemente. La propagación de la excepción continúa hasta
que se encuentra el manejador adecuado, o hasta que no hay más sentencias
Proteger…Excepción. En el último caso se emite un mensaje de error y el algoritmo
finaliza.

Pag. 31
 Para determinar si el bloque de excepción de una sentencia Proteger…Excepción
puede manejar una excepción en especial, los manejadores Cuando…fcuando se
examinan en orden de aparición. El primer manejador de excepciones que lista la clase
excepción o la clase base de la excepción se considera una coincidencia. Si un bloque
de excepción contiene una parte Sino y si ninguno de los manejadores de excepciones
Cuando…fcuando concuerda con la excepción, la parte Sino se considera una
coincidencia. Un bloque de excepciones que contiene sólo una lista de sentencias se
considera una coincidencia para cualquier excepción.

Luego de la ejecución de un manejador de excepciones, el objeto se destruye

automáticamente invocando al método Destructor, y así el control se pasa a la
sentencia que sigue a la palabra clave fproteger la cual finaliza la sentencia Proteger…
fproteger.

En el siguiente ejemplo, el primer Cuando…fcuando maneja la excepción de división

por cero y el segundo maneja la excepción de sobreflujo.

Proteger
…
Excepción
Cuando CDivisiónPorCero
Hacer
ManejarDivisiónPorCero
fcuando
Cuando CSobreflujo
Hacer
ManejarSobreflujo
fcuando
fproteger

Un manejador Cuando…fcuando puede especificar opcionalmente especificar la

declaración de un objeto excepción en vez de sólo el identificador de la clase. Así
podemos utilizar esta instancia dentro de las sentencias del bloque Cuando…fcuando.
Por ejemplo

Proteger
…
Excepción
Cuando Objeto E ejemplar-de CExcepción
Hacer
MostrarMensaje(ObtenerMensaje de E)
fcuando
fproteger

El ámbito de un identificador de objeto que se declara en un manejador de excepción

son las sentencias que están dentro del Cuando…fcuando.

Si la sentencia Proteger…fproteger especifica una parte Sino, entonces cualquier

excepción que no se trata en los manejadores Cuando…fcuando será tratada por la
parte Sino. Por ejemplo

Proteger
…
Excepción
Cuando CDivisiónPorCero
Hacer
ManejarDivisiónPorCero
fcuando
Cuando CSobreflujo
Hacer
ManejarSobreflujo
fcuando
Sino
ManejarOtras
fproteger

Pag. 32
 Un bloque de excepción que no contiene manejadores Cuando…fcuando, pero contiene
un grupo de sentencias, manejará todas las excepciones.

Proteger
…
Excepción
ManejarExcepción
fproteger

Aquí cualquier excepción que ocurra como resultado de la ejecución de las sentencias
de las sentencias entre Proteger y Excepción serán manejadas por el método
ManejarExcepción.

Generación manual de Excepciones

Una excepción se provoca con la sentencia Provocar.

Provocar identificador-objeto-excepción

El argumento de la sentencia Provocar debe ser un objeto. Cuando se provoca una

excepción, la lógica de tratamiento de excepciones toma se apropia del objeto
excepción. Una vez que la excepción se maneja, el objeto excepción se destruye
automáticamente invocando a su destructor. Nosotros no debemos tratar de destruir
manualmente el objeto excepción.

Método IngresarNúmero (Número, Mín, Máx) de Biblioteca

EErrorRango ejemplar-de CErrorRango
Leer(Número)
Si (Número < Mín) o (Número > Máx)
entonces
Provocar EErrorRango // llama al constructor
fsi
fmétodo

Excepciones predefinidas
Para el lenguaje de pseudocódigo propuesto hemos definido ciertas clases de
excepción, incluyendo una clase CExcepción que sirve de raíz para todas las clases de
excepción. Debemos tomar en cuenta que al tratarse de un lenguaje para especificar
algoritmos, hay ciertas excepciones que no aparecerán a este nivel (por ejemplo las de
acceso a direcciones de memoria inválida).

Clase CExcepción viene-de CObjeto

Atributos
Mensaje
ContextoDeAyuda
Métodos
Constructor(UnMensaje, UnContextoDeAyuda)
ObtenerMensaje -->
ObtenerContextoDeAyuda -->
fclase

La clase CExcepción establece dos propiedades, Mensaje y ContextoDeAyuda, que

todo objeto de excepción hereda. Esto significa que cualquier objeto de excepción
cualquiera puede por lo menos proporcionar un mensaje descriptivo de la condición de
excepción y posiblemente un contexto de ayuda que haga referencia a una ayuda del
tópico.

Pag. 33
 A continuación se listan las excepciones que contempla el lenguaje de pesudocódigo y
las situaciones en que se pueden provocar. A menos que se especifique otra cosa, las
excepciones son descendientes directos de Cexcepción.

Clase de Excepción Descripción

CSinMemoria Surge cuando no hay suficiente memoria para una
operación en particular.
CErrorES Surge cuando una operación de entrada/salida genera un
error.
CErrorMatemático La clase padre de todas las excepciones de operaciones
matemáticas.
CDivisiónPorCero Surge cuando se intenta una división que tiene por divisor
un valor de cero. Desciende de CErrorMatemático.
CSobreflujo Surge cuando una operación produce un sobreflujo
(overflow). Está más orientada a la implantación, pero es
tan frecuente que cabe su inclusión. Desciende de
CErrorMatemático.
CSobreflujoDePila Aparece cuando la pila de nuestra aplicación no puede
expandirse, o si el tamaño de la pila alcanza su límite
superior. Esta excepción presupone un límite en la pila,
una restricción física, pero su frecuencia amerita incluirla.
Tabla .13. Clases derivadas de CExcepción.

Pag. 34
 Objetos Especiales

Arreglos
Los arreglos tienen un número fijo de componentes del mismo tipo de valor.

Declarar
Para declarar un arreglo en el pseudocódigo, necesitamos especificar un nombre o
identificador para el arreglo. Así mismo tenemos que indicar el rango de valores para
cada una de las dimensiones del arreglo. Para indicar el rango de valores de uno de los
subíndices, simplemente especificamos los límites inferior y superior del rango y
colocamos entre ellos puntos suspensivos (). El número de elementos del arreglo es
el producto de los valores máximos de cada subíndice.

nomb_de_arreglo [ Dimensión rango1, ..... , rangon ] Ejemplar-de

CArreglo

Por ejemplo:
aMatriz1 Dimensión 1…10, 1…20 Ejemplar-de Carreglo

Aquí definimos un arreglo llamado aMatriz1 cuyo número de elementos es 10*20. Noten
que estamos colocando el prefijo a en el nombre del arreglo, lo que indica que el
identificador corresponde a un arreglo.

Referencia
Podemos acceder a uno de los componentes proporcionando el identificador del arreglo
con el índice correspondiente encerrado entre corchetes. Si no incluimos la referencia a
un componente en particular, el identificador del arreglo referencia a la totalidad de
éste.

nombre_de_arreglo [índice] // Un elemento del arreglo

nombre_de_arreglo // Todo el arreglo

En el siguiente ejemplo mostramos el uso de ambas posibilidades.

aAlumnoA Dimensión 1…20, 1…10 Ejemplar-de CArreglo
aAlumnoB Dimensión 1…10 Ejemplar-de CArreglo
aAlumnoC Dimensión 1…10 Ejemplar-de CArreglo
…
aAlumnoC <-- aAlumnoB // referencia a todo el arreglo
aAlumnoA[5] <-- aAlumnoB // referencia global a una dimensión
aAlumnoA[3, 2] <-- ‘Arturo López’// referencia a un componente

Iteración sobre colecciones

Para el caso de las colecciones de elementos, se utiliza una variante de la sentencia
para, la cual especifica cómo se identificará al elemento actual en cada iteración y a la
colección que se recorrerá.

La sintaxis es la siguiente.

para cada IdentificadorElemento en IdentificadorColección

hacer
Secuencia de “n” acciones
fpara

Por ejemplo:

objeto arregloPersonas ejemplar-de CArregloPersonas

...

Pag. 35
 para cada persona en arregloPersonas hacer
Escribir(persona.obtenerNombre)
fpara

Apuntadores
Los apuntadores son variables que almacenan un tipos especial de valor: direcciones
de memoria. En esas direcciones se guardan valores relevantes para nuestro algoritmo.

Reservar espacio
La operación de reservar espacio para el apuntador podría compararse con la acción de
declarar al sistema que el identificador especificado se referirá a un apuntador.

Reservar identificador_apuntador |
Reservar identificador_apuntador*Cantidad_Elementos

La sentencia Reservar asigna un bloque de memoria libre para el apuntador y almacena

la dirección de ese bloque en el apuntador. Cuando se desea reservar un arreglo de
bloques contiguos de memoria, se multiplica por la cantidad de bloques requeridos. La
palabra reservada nulo denota un valor que significa que nuestra variable apunta a
ninguna parte.

Reservar pCuenta // Reserva espacio para el apuntador

pCuenta <-- nulo // apunta a ninguna parte

Asignar valor
Los apuntadores pueden recibir direcciones como valores válidos. Para obtener la
dirección de una variable basta con colocar el símbolo @ antes del identificador de la
variable y esto denotará su dirección de memoria. Otra manera de asignar valor es
colocar direcciones específicas ya sea en notación decimal o hexadecimal (ambas muy
conocidas por nosotros), o en su defecto utilizando nulo.

identificador_apuntador <-- @ identificador ó

identificador_apuntador <-- expresión_de_dirección

Liberar espacio
La sentencia Liberar nos permite devolver al sistema el bloque de memoria que fuera
asignado al apuntador con la sentencia Reservar.

Liberar identificador_apuntador

Por ejemplo:

Liberar pCuenta // Libera la memoria asignada a pCuenta

Acceder al valor apuntado
Para poder acceder al bloque de memoria apuntado, se utiliza el operador  delante del
nombre del apuntador.

identificador_apuntador <-- valor

Por ejemplo:

pCuenta <-- '15307863'

Desplazamiento con apuntadores

En los casos de apuntadores a arreglos de bloques, para avanzar a un bloque
específico del arreglo se utiliza la siguiente sintaxis, se incrementa el valor del
apuntador en la cantidad de posiciones que se desea desplazar.

identificador_apuntador <-- identificador_apuntador + n

Pag. 36
 Por ejemplo:

pNumeros <-- pNumeros + 15 // Se desplaza 15 bloques

Estructuras
A fin de cubrir la existencia de tipos estructura existentes en algunos lenguajes (struct
en C++ o C#), oLoop permite la declaración de estructuras, muy similares a las clases,
pero con la diferencia de que no poseen constructor ni son capaces de participar en
una jerarquía. Son básicamente un tipo de valor compuesto para declaración de
variables, más que una clase que pueda aceptar creación de instancias.

La sintaxis para declarar estructuras se presenta a continuación.

Estructura IdentificadorEstructura
Atributos
IdentificadorAtributo { IdentificadorAtributo }
Métodos
secuencia de “m” declaraciones de métodos
festructura

Por ejemplo:

Estructura SFigura
Atributos
Largo
Ancho
Objeto Lápiz ejemplar-de CLápiz
Objeto Brocha ejemplar-de CBrocha
Métodos
ObtenerLargo -->
ObtenerAncho -->
ColocarLargo(NuevoLargo)
ColocarAncho(NuevoAncho)
festructura

Para declarar variables de estructura, se utiliza la siguiente sintaxis.

identificador_variable ejemplar-de IdentificadorEstructura

Por ejemplo:
Estructura SInformaciónPedido
Atributos
NúmeroPedido
FechaPedido
festructura
...
informaciónPedido ejemplar-de SInformaciónPedido
informaciónPedido.NúmeroPedido <-- 450

Enumeraciones
En muchos lenguajes de programación se implementa el concepto de enumeraciones o
tipos enumerados. En oLoop se puede declarar tipos para enumeraciones con la
siguiente sintaxis.

Enumeración IdentificadorEnumeración [ valor1 {, valor2,..,

valorN }]

Enumeración EEstadoPedido [ PENDIENTE, APROBADO, RECHAZADO ]

Para declarar una variable de un tipo enumerado, se utiliza la siguiente sintaxis.

Pag. 37
 identificador_variable ejemplar-de IdentificadorEnumeración

Por ejemplo:
pedido ejemplar-de EEstadoPedido
pedido <-- EEstadoPedido.Pendiente

Interfaces
Para declarar interfaces en oLoop se utiliza la siguiente sintaxis.

Interfaz IdentificadorInterfaz
Atributos
IdentificadorAtributo { IdentificadorAtributo }
Métodos
secuencia de “m” declaraciones de métodos
finterfaz

IdentificadorMétodo [ ( ListaFormalParámetros ) ] [ --> ]

[ virtual | virtual abstracto | sobreescribir |
sobrecargar ]

ListaFormalParámetros --> [ @ ] Identificador {, [ @ ]

Identificador }

Por ejemplo:

Interfaz IManejadorCliente
Métodos
obtenerInstancia ->
registrarCliente(cliente) ->
fclase

Para declarar que una clase implementa una interfaz, se utiliza la siguiente sintaxis.

Clase IdentificadorClase implementa IdentificadorInterfaz

Atributos
IdentificadorAtributo { IdentificadorAtributo }
Métodos
secuencia de “m” declaraciones de métodos
fclase

Por ejemplo:

Clase CClienteNegocio implementa IManejadorCliente

Metodos
obtenerInstancia ->
registrarCliente(cliente) ->
fclase

Método CClienteNegocio.obtenerInstancia ->

Objeto cliente ejemplar-de CClienteNegocio
cliente.constructor
retornar cliente
fmétodo

Método CClienteNegocio.registrarCliente(cliente)
IAccesoDatos facade =
InfraestructuraFacade.obtenerInstancia
retornar facade.insertarCliente(
cliente.obtenerCodigo,
cliente.obtenerNombre,
cliente.obtenerUsuario,
cliente.obtenerContrasena,

Pag. 38
 cliente.obtenerCorreo,
cliente.obtenerTelefono,
cliente.obtenerFax,
cliente.obtenerPais)
fmétodo

Archivos
oLoop permite el uso de archivos secuenciales o aleatorios. Para ello cuenta con la
clase predefinida CArchivo. Esta clase encapsula la funcionalidad genérica para el
manejo de archivos. La declaración de la clase CArchivo se especifica a continuación.

Clase CArchivo
Atributos
Nombre // Nombre del archivo
Ruta // Ruta de directorio del archivo
ModoAcceso // 'Lectura' | 'Escritura' |
// 'Lectura-Escritura' | 'Adición'
Tipo // 'Secuencial' | 'Aleatorio'
Métodos
Crear ->
Abrir ->
Cerrar ->
Leer ->
Leer(pPosicion) ->
Escribir(Objeto)
Escribir(Posicion, Objeto)
ObtenerNombre ->
ColocarNombre(NuevoNombre)
ObtenerRuta ->
ColocarRuta(NuevaRuta)
ObtenerModoAcceso ->
ColocarModoAcceso(NuevoModoAcceso)
ObtenerTipo ->
ColocarTipo(NuevoTipo)
FinDeArchivo ->
fclase

Pag. 39
 Ejemplos de uso de oLoop
Declaración de Clases y Métodos
El siguiente ejemplo ilustra de manera sencilla la declaración de una Clase. Definimos
una clase Punto, que entendemos por un pixel en la pantalla. Para definirlo
necesitamos sus coordenadas X e Y.

Clase CPunto
Atributos
X
Y
Métodos
ObtenerX
ObtenerY
Constructor(NuevoX, NuevoY)
fclase

Pag. 40
 Implantación de Métodos
Continuando con nuestro ejemplo del punto, demostramos como declarar las
definiciones de los métodos de la clase arriba definida.

Método CPunto.Constructor(NuevoX, NuevoY)

X <-- NuevoX
Y <-- NuevoY
fmétodo

Método CPunto.ObtenerX
Retornar X
fmétodo

Método CPunto.ObtenerX
Retornar Y
fmétodo

Pag. 41
 Herencia y Extensión de Clases
En este ejemplo que presentamos a continuación aplicaremos el mecanismo de la
herencia para extender la clase CPosición.

Clase CPosición
Atributos
X
Y
Métodos
Constructor(NuevoX, NuevoY)
ObtenerX -->
ObtenerY -->
fclase

Clase CPunto viene-de CPosición

Atributos
Visible
Métodos
Constructor(NuevoX, NuevoY)
Mostrar
Ocultar
ObtenerVisible
MoverHacia(QueX, QueY)
fclase

// Métodos de la Clase CPosición

Método CPosición.Constructor(NuevoX, NuevoY)

X <-- NuevoX
Y <-- NuevoY
fmétodo

Método CPosición.ObtenerX
Retornar X
fmétodo

Método CPosición.ObtenerY
Retornar Y
fmétodo

// Métodos de la Clase CPunto

Método CPunto.Constructor(NuevoX, NuevoY)
Heredado Constructor(NuevoX, NuevoY)
Visible <-- Falso
fmétodo

Método CPunto.ObtenerVisible
Retornar Visible
fmétodo

Método CPunto.Mostrar
Visible <-- Verdadero
DibujarPixel(X, Y, ObtenerColorPrimerPlano)
// Dibuja un pixel en la pantalla (blanco sobre negro)
fmétodo

Método CPunto.Ocultar
Visible <-- Falso
DibujarPixel(X, Y, ObtenerColorFondo)
// Dibuja un pixel en la pantalla (negro sobre negro)
fmétodo

Método CPunto.MoverHacia(QueX, QueY)

Ocultar // Oculta el punto
X <-- QueX // Asigna las nuevas coordenadas

Pag. 42
 Y <-- QueY
Mostrar // Muestra el punto
fmétodo

// La clase CCírculo será un hijo de CPunto.

Clase CCírculo viene-de CPunto
Atributos
Radio
Métodos
Constructor(NuevoX, NuevoY, NuevoRadio)
Mostrar
Ocultar
Expandir
MoverHacia
Contraer
fclase

Método CCírculo.Constructor(NuevoX, NuevoY, NuevoRadio)

Heredado Constructor(NuevoX, NuevoY)
Radio <-- NuevoRadio
fmétodo

Método CCírculo.Mostrar
Visible <-- Verdadero
DibujarCírculo(X, Y, Radio, ObtenerColorPrimerPlano) //
Dibuja un círculo en la pantalla (blanco sobre negro)
fmétodo

Método CCírculo.Ocultar
Visible <-- Falso
DibujarCírculo(X, Y, Radio, ObtenerColorFondo) //
Dibuja un círculo en la pantalla (negro sobre negro)
fmétodo

Método CPunto.MoverHacia(QueX, QueY)

Ocultar
X <-- QueX
Y <-- QueY
Mostrar
fmétodo

Método CCírculo.Expandir(FactorExpansión)
Ocultar
Radio  Radio + FactorExpansión
Mostrar
fmétodo

Método CCírculo.Contraer(FactorContracción)
Expandir(-FactorContracción)
fmétodo

Método CCírculo.MoverHacia(QueX, QueY)

Ocultar
X <-- QueX
Y <-- QueY
Mostrar
fmétodo

Este sencillo ejemplo nos muestra la simulación de una pequeña (muy pequeña)
conversación entre dos objetos de la Clase CPersona.
Clase CSegmento
Atributos
Lugar
nuSegmento
Métodos
Constructor(NuevoSegmento, NuevoLugar)
ImprimirEncabezado
Acción
ImprimirCorte

Pag. 43
 fclase

Método CSegmento.Constructor(NuevoNúmero, NuevoLugar)

Lugar <-- NuevoLugar
nuSegmento <-- NuevoSegmento
fmétodo

Método CSegmento.ImprimirEncabezado
LíneaTexto <-- ‘Segmento # ‘ + nuSegmento +
‘ ‘ + Lugar
Escribir(LíneaTexto)
fmétodo

Método CSegmento.Acción
fmétodo

Método CSegmento.ImprimirCorte
Escribir(‘------------------‘)
fmétodo

Clase CPersona
Atributos
nmPersona // Nombre de persona
LíneaEtiqueta
Métodos
Constructor(NuevoNombre, NuevaLínea)
ColocarLíneaEtiqueta(QueLínea)
ObtenerLíneaEtiqueta -->
Decir(Línea)
fclase

Método CPersona.Constructor(NuevoNombre, NuevaLínea)

nmPersona <-- NuevoNombre
LíneaEtiqueta <-- NuevaLínea
fmétodo

Método CPersona.ObtenerLíneaEtiqueta
Retornar LíneaEtiqueta
fmétodo

Método CPersona.ColocarLíneaEtiqueta(QueLínea)
LíneaEtiqueta <-- QueLínea
fmétodo

Método CPersona.Decir(Línea)
LíneaTexto <-- nmPersona + ‘: ”’ + Línea + ‘”’
Escribir(LíneaTexto)
fmétodo

Clase CDiálogo viene-de CSegmento

Atributos
Objeto PersonaA ejemplar-de CPersona
Objeto PersonaB ejemplar-de CPersona
Métodos
Constructor(NuevoNúmero, NuevaLínea,
nmActor1, nmActor2)
Acción
Saludos
Conversar
Despedirse
fclase

Método CPersona.Constructor(NuevoNúmero, NuevoLugar, nmActor1,

nmActor2)
Heredado Constructor(NuevoNúmero, NuevoLugar)
PersonaA.Constructor(nmActor1, ‘’)
PersonaB.Constructor(nmActor2, ‘’)
fmétodo

Método CDiálogo.Acción

Pag. 44
 Agradecimientos
Conversar
Despedirse
fmétodo

Método CDiálogo.Saludos
PersonaA.Decir(‘Hola’)
PersonaB.Decir(‘Que tal’)
PersonaA.ColocarLíneaEtiqueta(‘Si que hace calor’)
PersonaB.ColocarLíneaEtiqueta(‘Y que lo digas’)
fmétodo

Método CDiálogo.Conversar
PersonaA.Decir(PersonaA.ObtenerLíneaEtiqueta)
PersonaB.Decir(PersonaB.ObtenerLíneaEtiqueta)
fmétodo

Método CDiálogo.Despedirse
PersonaA.Decir(‘Chau’)
PersonaB.Decir(‘Nos vemos’)
fmétodo

Pag. 45
 Bibliografía
● VOSS, Greg (1994); Programación Orientada a Objetos: Una Introducción., McGraw
Hill, México. Orig. Object-Oriented Programming: An Introduction.

● BUDD, Timothy (1994); Introducción a la Programación Orientada a Objetos. Addison

Wesley Iberoamericana. Wilmington, Delaware.

● GALLARDO OTERO, Manuel - PÉREZ CABREL, Teodomiro (1995); Estructura de

Datos: Un enfoque Algorítmico. Lima. Universidad Nacional Mayor de San
Marcos - Facultad de Ciencias Matemáticas, Escuela Académico Profesional de
Computación.

● HEKMATPOUR, Sharam (1992); C++ : Guía para Programadores en C. México.

Prentice Hall Inc.

● WEISKAMP, Keith - HEINY, Loren - FLAMING, Bryan (1993); Programación Orientada

a Objetos con Turbo C++. México. Editorial Limusa S.A. de C.V. Grupo Noriega
Editores.

● RUBENKING, Neil (1995); Delphi Programming Problem Solver. IDG Books Worldwide
Inc. ISBN 1-56884-795-5.

Pag. 46
 Sugerencias para la escritura de
Pseudocódigo
Indentación
Para facilitar la comprensión, lectura y revisión del pseudo-código, se creó el concepto
de indentación en la escritura de los mismos. Esta consiste en el desplazamiento hacia
la derecha de un subconjunto de la secuencia de acciones. Aunque los bloques están
denotados por palabras subrayadas, ( Si..fsi, etc.). Es recomendable desplazar dos o
tres posiciones el bloque para facilitar la comprensión del flujo lógico.

Idioma de Trabajo
La nomenclatura de identificadores de variables, acciones, funciones, estructuras, etc.,
debe estar regida por un idioma único para lograr la uniformidad en el pseudo-código.
Esto produce una sensación de armonía y ayuda a la fácil comprensión del mismo.
Algunos autores utilizan el idioma inglés porque les brinda mayor versatilidad en la
nomenclatura (una expresión en español puede significar una sola palabra en inglés) o
armonía con el lenguaje de programación en que implementarán el pseudo-código.
Otros prefieren el español por comodidad y para lograr una mayor claridad y
comprensión por parte del lector. Para elegir el idioma de nomenclatura debe tenerse
en cuenta la comodidad personal, el grado de difusión del pseudo-código (en el caso de
trabajo en grupo o para presentarlo a terceros) y la fluidez que poseemos sobre un
idioma. Esta última nos permitirá utilizar el término exacto que ayude a captar el
significado del valor, acción o función.

Notación de Identificadores
Los identificadores son cadenas de texto que permiten hacer referencia a valores
determinados. Muchas veces, por falta de costumbre o por "rapidez", no aprovechamos
las propiedades informativas de los identificadores. El nombre de una variable nos
puede dar información sobre el significado del valor al que referencia (nombre de una
persona, contador, acumulador de totales, etc.), el tipo de valor (numérico, cadena de
caracteres, estructura, etc.) o la categoría de valor (posibles estados civiles por
ejemplo).

Uso de mayúsculas y minúsculas en Identificadores

El uso de mayúsculas y minúsculas nos brinda un mayor rango de posibilidades en la
notación y además incrementa la legibilidad del identificador. Es mas claro escribir
ClaseDeDato que CLASEDEDATO, u ObtenerCodigoDeFactura que
OBTENERCODIGODEFACTURA.

Notación Húngara
Un tipo de notación muy conocida en el ambiente informático es el de la notación
húngara, en el cual una letra denota el tipo de valor con que trabaja la variable, así:

Pag. 47
 Prefijo Descripción Ejemplo
b Valor booleano bEsCasado
n Valor numérico nEdad
a Arreglo o Matriz aAlumnos
ch Carácter chRespuesta
c Cadena de caracteres cNombre
p Apuntador pNodo
S Estructura SPersona
m_ Miembro de la Estructura m_cNombre
Tabla .14. Ejemplo de uso de Prefijos.

Notación de Constantes
Para la notación de constantes, es decir identificadores asociados a valores que no
cambian en el tiempo, existen la notación de prefijos, que consiste en la utilización de
uno o dos caracteres que se anteponen al identificador e indican el tipo de valor (con
respecto al significado) asociado. Por ejemplo:

Prefijo Descripción Ejemplo

ec Tipo de Estado Civil ecSoltero, ecCasado, ...
ev Evento de interfaz evRatón, evTeclado, ...
cm Comando de Aplicación cmSalir, cmAbrir, ...
Tabla .15. Ejemplos de Prefijos en Constantes.

La eficiencia de la notación de prefijo depende la habilidad para encontrar siglas q ue

sinteticen el tipo de valor.

Pag. 48