[ 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
Área de Desarrollo de Software
Carrera de Ingeniería Informática y de Sistemas
Universidad Nacional Mayor de San Marcos

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

Pag. 1 .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.

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). El lenguaje de pseudocódigo que vamos a especificar contiene las herramientas que permiten especificar el flujo del control de un algoritmo. En cada nivel de abstracción. 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. 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.Definición del Lenguaje de Pseudocódigo ¿Pseudocódigo orientado a objetos? El pseudocódigo se presta para un buen diseño descendente. Pag. En el mundo del desarrollo orientado a objetos. o bien el comportamiento descrito no implica la existencia de nuevos objetos. 2 .

mod. 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. Y +. -B). -. O =. A + B). Las operaciones de igual precedencia se efectúan normalmente de izquierda a derecha. No *. Sintaxis de factor. >= Precedencia Categorías primera (más alta) operadores unarios segunda operadores de multiplicación/división tercera operadores de suma/resta cuarta (última) operadores relacionales Tabla . Una llamada a método activa un método y denota el valor que éste retorna. Un valor constante sin signo tiene la siguiente sintaxis: ConstanteSinSigno --> Constante | ‘CadenaCaracteres’ Ilustración . Lo ampliaremos en la sección de apuntadores. • Un operando entre dos operadores iguales actúa primero con el de la izquierda. Los operadores binarios utilizan la forma algebraica que conocemos (por ejemplo. 3 . Los demás son unarios y necesitan sólo un operando. div.1. >. que se componen de factores. Precedencia de operadores. términos y expresiones simples. <=. el compilador podría reordenar los operandos para optimizar el código.1. Sintaxis de las expresiones Las reglas de precedencia se basan en la sintaxis de las expresiones. es decir utilizan dos operandos. • Las expresiones entre paréntesis se evalúan primero para ser tratadas como un sólo operando. Esto lo veremos en la sección de llamada a métodos. Un factor de dirección calcula la dirección de una variable o método.2. A nivel de pseudocódigo esto es bastante simple. 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 . Los operadores unarios siempre preceden a sus operandos (por ejemplo. pero en un lenguaje de programación. En expresiones más complejas. Operadores @. Sintaxis de valor constante sin signo. La mayoría de operadores son binarios. <. Aquí presentamos algunos ejemplos de factores: Pag. las reglas de precedencia de operadores aclaran el orden en que se realizan las operaciones. /. <>.Expresiones Las expresiones están compuestas por operadores y operandos.

Sintaxis de término.5. Sintaxis de expresión Aquí algunos ejemplos de expresiones: X = 1. 4 . 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 Fin <> Error (I < J) = (J < K) Pag.3.| O Ilustración . Sintaxis de expresión simple.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 --> + | .X @X 15 (X + T + Z) Seno(X/2) No Fin {referencia a una variable} {apuntador a una variable} {constante} {subexpresión} {llamada a un método} {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 .4. Aquí algunos ejemplos de términos: X * Z Z / (1 .

lógicos. 5 . de texto. -. es decir: I mod J = I . Los operadores + y . consideran a estos operadores como lógicos además de sus aplicaciones booleanas.Operadores A nivel de pseudocódigo. Sintaxis de factor de dirección. El operador mod retorna el resto de la división de sus operandos. Este operador retorna la dirección de su operando. Ocurre un error si J es cero. de éstos. apuntadores y relacionales. y O son operadores lógicos/booleanos. El valor de I div J es el cociente de I / J redondeado. Y . es decir construye un apuntador hacia el operando (vea más adelante apuntadores).6. Los operadores numéricos + y . Pag. *. FactorDirección --> @Identificador Ilustración . Ocurre un error en ambos tipos de división si J es cero.también pueden ser operadores unarios. El operador @ se utiliza en un factor de dirección para calcular la dirección de una variable. /. obteniendo como resultado otro valor de dirección. div. Los operadores No. Cabe mencionar que los lenguajes de programación que soportan la manipulación de operandos a nivel de bits. mod).también se aplican a variables o constantes que contienen valores de direcciones. podemos dividir a los operadores en operadores numéricos. Los operadores numéricos son muy conocidos por nosotros (+. el operador + también se usa para concatenar textos (cadenas).(I div J) * J El signo del resultado es el mismo que el de I.

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. Identificador --> Expresión Ilustración . Trataremos este tipo de sentencias en la sección de Mensajes.9. 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.8. Sentencias simples Una sentencia simple es aquella que no puede contener otras sentencias. al momento del paso de mensajes se les conoce como parámetros reales). Pag. Sintaxis de sentencia simple.Sentencias Las sentencias describen las acciones que puede ejecutar el algoritmo. entonces la sentencia de mensaje debe tener una lista concordante de parámetros (en la sección de declaración.7. 6 . Hay dos tipos principales de sentencias: las sentencias simples y las sentencias compuestas. Sentencia --> SentenciaSimple | SentenciaCompuesta Ilustración . Sintaxis de sentencia de asignación. Tenemos los siguientes tipos: sentencias de entrada/salida. si la declaración del método contiene una lista de parámetros formales. a los parámetros se les conoce como parámetros formales. SentenciaSimple --> SentenciaAsignación | SentenciaEntradaSalida | SentenciaRetorno | Mensaje | Retorno Ilustración . Sintaxis de sentencia. sentencias de asignación de valores y sentencias de mensaje.

Si la expresión toma el valor de verdadero la secuencia a continuación de la cláusula Entonces se ejecuta. Nuestro lenguaje cuenta con dos primitvas básicas para dicho fin. 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 . SentenciaCompuesta --> SentenciaCondicional | SentenciaRepetitiva | Excepción Ilustración .Sentencias de entrada/salida Todo lenguaje de pseudocódigo debe permitir mecanismos que comuniquen nuestra solución con el usuario.11. condicionalmente (sentencias condicionales). Sentencias compuestas Las sentencias compuestas son construcciones compuestas por otras sentencias que se ejecutarán en secuencia. SentenciaCondicional --> SentenciaSi | SentenciaCaso Ilustración . La primitiva Escribir nos proporciona un mecanismo para emitir expresiones y resultados para que puedan ser apreciados por nuestro usuario. Si la expresión produce un valor de falso y está presente la parte de Sino. La manera como se escriben es la siguiente: leer ( Identificador ) escribir ( Identificador | Expresión ) Como veremos más adelante. Sentencias de decisión o condicionales Las sentencias de decisión o condicionales seleccionan la ejecución de una secuencia de acciones. La mayoría de aplicaciones necesitan una interacción con el usuario de la misma. Sintaxis de sentencia compuesta. no se ejecuta nada. 7 . si la parte Sino no se encuentra presente. La expresión debe tomar un valor lógico de verdadero o falso. se ejecuta la secuencia de acciones a continuación de Sino. Sintaxis de sentencia Si. o repetidamente (sentencias iterativas). Pag. Sintaxis de sentencia condicional.10. por tanto entran en la categoría de métodos de biblioteca. 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. éstos son métodos de dominio público.12.

Si no hay parte Otro. Sintaxis de sentencia Mientras.15. La sentencia Caso ejecuta la secuencia de acciones precedida por la constante de valor igual al del selector. Mientras ExpresiónBooleana hacer Secuencia de “n” acciones fmientras Ilustración . ya no se ejecuta la secuencia de acciones.. cada una precedida por una constante ó por la palabra Otro. Sintaxis de sentencia repetitiva o iteración.. La expresión que controla la repetición debe tomar un valor de verdadero o falso.Decisión Múltiple (Sentencia Caso) La sentencia Caso está conformada por una expresión (el selector) y una relación de sentencias. Sintaxis de sentencia Caso.. Repetir Secuencia de “n” acciones hasta ExpresiónBooleana frepetir Ilustración .14. 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. la secuencia de acciones que sigue a Otro se ejecuta. La secuencia de acciones se ejecuta en forma repetida en tanto la expresión sea verdadero. Sintaxis de sentencia repetir. Valor } | Valor . al final de la secuencia . Iteraciones SentenciaRepetitivas --> SentenciaRepetir | SentenciaMientras | SentenciaPara Ilustración . Las constantes en Caso deben ser únicas. Esta se evalúa antes que se ejecute la secuencia de acciones contenida. 8 . no se ejecuta nada. Si no existe tal constante y está presente la parte Otro. La sentencia Repetir contiene una expresión que controla la ejecución repetida de una secuencia de acciones dentro de esa sentencia Repetir. caso Expresión vale Alternativa1: Secuencia de “n” acciones Alternativa2 : Secuencia de “m” acciones . Iteración condicional de uno o más ciclos. la expresión toma un valor de verdadero. La secuencia se ejecuta por Pag. Valor Ilustración .16.13. Las secuencia de acciones entre las palabras Repetir y Hasta se ejecutan en secuencia hasta que. La expresión debe producir un resultado de verdadero ó falso. [ otro: Secuencia de “x” acciones ] fcaso Valor { . Si la expresión da falso al inicio.

9 . Sintaxis de sentencia Para. Cuando la sentencia Para usa Desde. esto por cada repetición.lo menos una vez porque la expresión se evalúa después de la ejecución de cada iteración. Pag. la secuencia de acciones no se ejecuta. 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. 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. Si el incremento es negativo y Val_Inic es menor que Val_Fin.17. El identificador de control siempre comienza en el valor Valor_Inic. Para VariableControl desde ValorInicial a ValorFinal [inc {+ | -} ValorIncremento] hacer Secuencia de “n” acciones fpara Ilustración . 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. Si el incremento es positivo y Val_Inic es mayor que Val_Fin entonces no se ejecuta la secuencia de acciones.

pero todos comparten los mismos métodos. Sintaxis de declaración de Clase. entonces C2 es un descendiente de C1 y C1 es un ancestro de C2. Una clase puede heredar componentes de otra clase. el texto y los booleanos. Las clases se declaran de la siguiente manera: Clase IdentificadorClase [viene-de IdentificadorClase { . al igual que los números. Un destructor define las acciones asociadas con la destrucción de un objeto. Una clase es. el identificador Este representa un parámetro implícito que referencia al objeto por el cual fue invocado el método. Cuando se invoca. es decir. 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 {.Clases y Objetos. entonces C3 también hereda de C1. Si C2 hereda de C1. Dentro de la implantación de un método. si C3 hereda de C2 y C2 hereda de C1. Un constructor define las acciones asociadas con la creación de objetos. Los objetos se crean utilizando los constructores y se destruyen utilizando los destructores. La declaración de un atributo en una clase define un elemento de dato que existe en cada instancia u objeto de la clase. Cada objeto tiene su copia de los atributos declarados en la clase. El dominio de una clase está conformado por ella y todos sus descendientes. [ @ ]Identificador Ilustración . el destructor libera los recursos asignados al objeto. La herencia es transitiva. Un método es una rutina que realiza una operación sobre un objeto. Una instancia de una clase es conocida comúnmente como objeto. Una clase puede estar compuesta por atributos y métodos. 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. un tipo especial de datos. Parte de la llamada a un método (mensaje) especifica el objeto sobre el que debe operar el método. Pag. Cuando se invoca éste retorna una referencia a una instancia inicializada de una clase. 10 . En su caso consiste de un número fijo de componentes. Declarar Clases.18. Los constructores y destructores son métodos especiales que controlan la construcción y destrucción de los objetos.

Método IdentificadorClase. Para poder definir objetos en forma clara necesitamos establecer un identificador para el objeto y especificar de qué clase es ejemplar.20. es decir los ejemplares de la clase. Sintaxis de declaración de definición de Método.Una clase descendiente contiene en forma implícita todos los componentes definidos por sus clases ancestro. no puede eliminar la definición de un componente declarado en una clase ancestro. excepto que necesitamos especificar a que clase pertenece este atributo. 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. 11 .19. Sin embargo. Una clase descendiente puede agregar nuevos componentes a los ya heredados. Su estructura es similar a una rutina.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. Dentro de los métodos de una clase. Pag. de los cuales continuaremos hablando más adelante. Sintaxis de declaración de Objeto. El punto (.IdentificadorMétodo [ ( ListaFormalParámetros ) ] [ --> ] secuencia de “n” acciones fmétodo Ilustración . 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. Seleccionar atributos La manera como podemos accesar a los atributos de una clase es similar a lo anteriormente visto con las variables. 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. 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 acceso a sus atributos propios y heredados no necesita la especificación del identificador de clase. Identificador_de_Clase. pero aún no hemos asignado recursos ni inicializado los valores para los atributos propios de su clase. Declaración de Instancias de Clases (Objetos) Las instancias de una clase se conocen como los objetos de la clase. Objeto IdentificadorObjeto ejemplar_de IdentificadorClase Ilustración . Por medio de las clases definimos en nuestro pseudocódigo la estructura y el comportamiento de los objetos que pertenezcan a esa clase.) nos indica una selección de la Clase como entidad global y clarifica la pertenencia del método a dicha Clase. Para esto contamos con los constructores. pues la pertenencia está sobreentendida. Aquí utilizamos la palabra Método seguida del identificador y la interfaz (si existiera).

Los parámetros por valor sólo requieren el identificador del parámetro. la declaración es similar a la de los métodos. ésta queda determinada por el contexto de utilización de las variables. la palabra reservada Heredado se puede utilizar para acceder a identificadores de métodos sobreescritos o extendidos. por lo que cualquier cambio al valor del parámetro formal por referencia se reflejan en el parámetro real.Dibujar heredado Dibujar Color <-.stSólido fmétodo Parámetros (Interfaz) La declaración de un método especifica una lista formal de parámetros o interfaz.Para los constructores y destructores. 12 . Dentro del método. El parámetro real debe coincidir en tipo de valor con el parámetro formal por referencia. El parámetro formal por referencia representa la variable real durante la invocación al método. Pag. Dentro de un bloque de método. la búsqueda se inicia con el ancestro inmediato de la clase que contiene el método. Ilustración . ListaFormalParámetros [ @ ]Identificador } --> [ @ ] Identificador {. excepto que la palabra Constructor o Destructor se utiliza como identificador del método. Por ejemplo. sólo que obtiene su valor inicial de su correspondiente parámetro real al momento de invocarse al método.clTextoVentana Estilo <-. 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.21. Un parámetro formal por referencia se utiliza cuando se debe pasar un valor desde el método a quién lo invocó. A nivel de pseudocódigo. cualquier referencia al parámetro formal por referencia accesa al parámetro real mismo. Un parámetro formal por valor actúa como una variable local a la rutina. Los cambios que se realicen al parámetro formal por valor no afectan el valor del parámetro real. en la implantación del método CEtiquetaConMarco. Sintaxis de Lista formal de Parámetros. podemos utilizar heredado para invocar la implantación heredada del método Dibujar. al momento de asignación de valores y aplicación de operadores. Veamos: Clase CEtiquetaConMarco viene-de CEtiqueta Métodos Dibujar fclase Método CEtiquetaConMarco. podemos distinguir dos tipos de parámetros.Dibujar. Cuando un identificador está precedido por heredado. por valor y por referencia. mientras que los parámetros por referencia necesitan ser precedidos del operador @. 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. 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.

A estos métodos especiales los denominamos métodos de lectura y métodos de escritura. Clase CFigura viene-de CObjeto Atributos Largo Ancho Objeto Lápiz ejemplar-de Clápiz Pag. los constructores y destructores son métodos que controlan la construcción y destrucción de objetos de una clase. 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 decir los que retornan el valor de un atributo. Los destructores se usan para retirar del entorno objetos. éstos se pueden heredar. la inicialización se basa en los valores que se pasan como parámetros al constructor. Cuando se invoca a un destructor. es necesario definir métodos especiales cuya función sean obtener el valor del atributo o alterar éste valor. Continuando con la sana política de establecer convenciones. Los constructores se usan para crear e inicializar nuevos objetos. 13 . QueAncho) Destructor fClase Método CFigura. Típicamente la última acción que realiza un destructor es llamar al destructor heredado para deshacerse de los atributos heredados del objeto.Destructor Lápiz. Por lo general las acciones de un destructor son destruir cualquier objeto contenido en él y liberar cualquier recurso solicitado por el objeto.Constructor(QueLargo. así mismo.Constructores y destructores Como hemos adelantado.QueLargo Largo <-. QueAncho) heredado Constructor Ancho <-. Conforme utilice el enfoque orientado a objetos para realizar sus algoritmos. Ellos se especifican como componentes de la clase como un método estándar.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. se ejecutan las acciones definidas por el usuario para el destructor y luego se libera los recursos asignados al objeto. 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. excepto que la palabra constructor se utiliza como identificador del método. Por lo general. debemos disciplinarnos en el acceso a los atributos definidos en las clases.Constructor Brocha. Clase CFigura viene-de CObjeto Atributos Largo Ancho Objeto Lápiz ejemplar-de Clápiz Objeto Brocha ejemplar-de Cbrocha Métodos Constructor(QueLargo.Destructor Brocha. Al igual que los métodos. Normalmente la primera acción que realiza un constructor es invocar al constructor heredado de su padre.QueAncho Lápiz. a partir de ahora acordaremos que los identificadores de métodos de lectura. estén conformados por la palabra Obtener seguida del nombre del atributo.Constructor fmétodo Método CFigura.

IdentificadorMétodo [( [(ListaRealParámetros) ListaRealParámetros)] Ilustración . 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.Objeto Brocha ejemplar-de Cbrocha Métodos Constructor(QueLargo. IdentificadorClase. quedando sólo el identificador del método y la lista real de parámetros.22. Para declarar propiedades en oLoop se utiliza la siguiente sintaxis.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. IdentificadorObjeto. aquellos métodos que se invocan directamente de la clase. 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. 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. 14 . IdentificadorClase. 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. se utiliza el nombre de la clase seguido del identificador del método y la lista real de parámetros. 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. Declaración de propiedades Las propiedades son una característica presente en muchos lenguajes de programación. Para el caso de los métodos estáticos. Sintaxis de Envío de Mensaje. IdentificadorObjeto. El identificador de objeto expresado arriba debe denotar una referencia a un objeto existente.

obtener fechaÚltimaCompra colocar fechaÚltimaCompra fclase Bibliotecas de clases Las clases en una aplicación pueden organizarse en bibliotecas.aplicacioncompras. En oLoop.entidadesnegocio Usar com. esto implica que un mismo objeto puede tomar diversas formas.cliente Usar com. El mismo nombre nos da una idea clara del concepto de polimorfismo. indicando que la clase a declarar estará formando parte de la biblioteca indicada. Especificación de bibliotecas Para especificar que una clase pertenece a un biblioteca determinada. Pag. puede utilizarse el símbolo de punto para delimitar los niveles de organización en el nombre de la biblioteca.utilidades Clase CComprasAplicacion viene-de CAplicacion … fclase Polimorfismo Una de las características importantes del paradigma orientado a objetos es el polimorfismo.empresa. Biblioteca IdentificadorBiblioteca Esta sentencia se coloca como primera línea de la declaración de clase. oLoop permite la especificación y uso de bibliotecas de clases en el pseudocódigo.empresa. Varias clases pueden pertenecer a la misma biblioteca. basta con utilizar la sentencia Biblioteca.aplicacioncompras. Por ejemplo: Biblioteca com.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.empresa. el polimorfismo se contempla en la instancia de objetos y en la consulta de tipos. 15 . 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. pues poli significa múltiple y morfismo viene de formas. En la nomenclatura de identificadores de biblioteca.empresa.

. (IdentificadorClase) IdentificadorObjeto Esto puede ser de utilidad en las operaciones de asignación. anteponiendo al identificador de objeto el nombre de la clase cuya forma se desea que asuma. ((IdentificadorClase) IdentificadorObjeto). puede aplicarse el polimorfismo.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. La variable Empleado se declara como ejemplar de la clase CEmpleado. 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. … salario ← ((CEmpleadoTiempoCompleto)Empleado). declarando una clase como ejemplar de una clase genérica.IdentificadorMétodo Continuando con el ejemplo expuesto líneas arriba.entonces. oLoop implementa en su sintaxis la especificación de casting de un objeto. En el siguiente ejemplo. Objeto Empleado ejemplar-de CEmpleado … Empleado ← CEmpleadoTiempoCompleto. e invocando al constructor de una clase hija más específica al momento de crear la instancia. método accesor que pertenece a la clase CEmpleadoTiempoCompleto y no a la clase CEmpleado. Por lo general se utiliza en combinación con la sentencia Si. IdentificadorObjeto es-instancia-de IdentificadorClase La combinación de estos elementos constituye una expresión booleana que puede ser verdadera o falsa.obtenerSalario … Pag. se asume la existencia de tres clases. una clase genérica CEmpleado y dos clases descendientes denominadas CEmpleadoTiempoParcial y CEmpleadoTiempoCompleto. encerrada entre paréntesis. se utiliza el método constructor de la clase CEmpleadoTiempoCompleto. Posteriormente. pero al momento de crear la instancia. Consulta de tipo oLoop implementa la consulta de tipo de un objeto por medio de la palabra reservada es-instancia-de. 16 .Durante la creación de instancia de clases. En la siguiente sección daremos un ejemplo de este tipo de instancia. se envía un mensaje al objeto Empleado para que invoque al método obtenerSalario. se consulta en una sentencia Si para saber si el objeto es una instancia del tipo CEmpleadoTiempoCompleto.

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

Basta con crear instancias de sus clases.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. Acorde con esto. de la cual descienden todas las demás clases de nuestra jerarquía. 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. La clase raíz de nuestra jerarquía es CObjeto. Pag. Nosotros no tenemos que consumir tiempo en crear clases que cumplan estas funciones. La clase que desciende ésta es CComponente. dejando sólo los que nos ayuden a definir el comportamiento de nuestro algoritmo. la cual es una clase completamente abstracta y que sólo sirve de punto de partida del árbol. Es con ella que comenzamos nuestra descripción. 18 . Se ha tratado de no incluir los atributos o métodos que están estrechamente relacionados con los aspectos visuales o físicos.

Ejemplo de Etiqueta. Tabla . CControlWindows. dos clases que definen dos niveles de profundidad en la jerarquía. El componente etiqueta nos permite mostrar texto. Atributo Título Función Contiene el texto que muestra la Etiqueta Tabla . Las capacidades de texto se utilizan para obtener información del usuario y retornar resultados al mismo. Cajas de Edición y Cajas de Memo. El texto que muestra este componente está contenido en el atributo Título del componente. Atributos comunes para los componentes en general. Clase CComponente viene-de CObjeto Atributos Activado Visible … Métodos … ObtenerActivado --> ObtenerVisible --> ColocarActivado ColocarVisible fclase Existen. Las clases que describiremos a continuación son descendientes directas de CControlWindows. como veremos más adelante. Para facilitarnos esta labor. 19 . Clase CCEtiqueta viene-de CControlWindows Atributos Pag. El componente Etiqueta (CEtiqueta) Información del Entorno Ilustración .23. Atributos de CEtiqueta. CControl y su hijo. contamos con tres componentes básicos para manejar texto: Etiquetas.3. pero no permite al usuario ingresar información. pero algunos son comunes a todos: Atributo Activado Visible Función Determina si el componente reaccionará ante las acciones del usuario. Determina si el componente se mostrará sobre el formulario durante la ejecución.La clases Componentes Atributos comunes (CComponente) La lista de atributos varía entre componentes. Visualizar y editar texto Posiblemente la tarea más común en un programa es mostrar y editar texto.2.

Puede ingresar Sí o No. Los atributos clave para un componente de este tipo son los siguientes: Atributo Texto Modificado SoloLectura Función Contiene el texto que visualiza la caja de Edición o que ingresa el usuario. no sabemos cómo nos puede responder el usuario. Sin embargo. Esta propiedad puede verificarse para ver si se necesita algún procesamiento para el texto. Atributos de CEdición. debemos tomar en cuenta que la mayoría de herramientas permiten que se ingrese textos de hasta 255 caracteres. El texto de la Caja de Edición está contenido en el atributo Texto del componente. el texto se ingresa digitando. o puede sólo Pag. podríamos colocar una Etiqueta como ¿Es usted casado(a)? y utilizar una Caja de Edición para obtener la respuesta.Título … Métodos … ObtenerTítulo --> ColocarTítulo fclase El componente Caja de Edición (CEdición) Nombre Ilustración . Indica si el texto ha sido modificado por el usuario. 20 . Por ejemplo. si deseamos obtener el estado civil de una persona. Si está en Verdadero. agrego que la Caja de Edición soporta las operaciones estándares de cortar. Tabla . a menudo deseamos restringir lo que el usuario ingrese a unas cuantas alternativas. Aunque al momento de la concepción del algoritmo. Como es de suponerse. copiar y pegar. Un componente relacionado con la Etiqueta es la caja de Edición.24. suponemos la existencia de recursos ilimitados. prohibe al usuario la edición del texto. 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. Este componente le permite visualizar información.4. pero a su vez permite al usuario ingresar información que puede ser utilizada por nuestro programa. Ejemplo de Caja de edición. pero a manera de comentario.

siempre existe la posibilidad de un ingreso erróneo. Ejemplo de Casilla de verificación. que se utiliza para brindar al usuario un conjunto muy limitado de alternativas. 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. Atributos de CCasilla.ingresar S o N. El botón permanecía hundido Pag. Los Botones de Radio son otro medio para presentar al usuario un número limitado de alternativas.26. Y como usted y yo sabemos. tenemos que examinar el atributo Verificada de la Casilla. Ejemplos de Botón de radio.5. La Casilla de Verificación (Ccasilla) Verificar ortografía Activar guiones Autocorrección Ilustración . donde cada Botón de Radio corresponde con una posibilidad. Atributo Título Verificada Función Determina el texto que aparece junto a la casilla. Clase CCasilla viene-de CControlWindows Atributos Título Verificada … Métodos … ObtenerTítulo --> ColocarTítulo ObtenerVerificada --> ColocarVerificada fclase Botones de Radio (CbotónRadio) Impresora local Impresora de red Un Archivo en disco. La Casilla de verificación es muy fácil de configurar. 21 . Para determinar qué respondió el usuario. una marca de verificación () indica una respuesta de Sí o Verdadero. Tabla ..25. Si no hay marca alguna. Si la Casilla está Verificada. Ilustración . El Título debe ser una oración o proposición que tiene una respuesta obvia de Sí o No. Sólo debe asignarse valor al atributo Título para visualizar lo que se desee que aparezca junto a la casilla.. La primera es la Casilla de Verificación que se utiliza para proporcionar al usuario elecciones del tipo Sí o No. Las herramientas de la actualidad nos proporcionan componentes estándares para manejar las alternativas simples. Determina si el usuario activó la casilla de verificación. Cuando el usuario encuentra una Casilla de Verificación. Un uso muy frecuente de las Casillas de Verificación es para establecer las opciones de un programa. la opción está activa. El otro componente es el Botón de Radio. 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. la respuesta será No o Falso.

En la pantalla cada Botón de Radio se presenta como un círculo. Atributos de CBotónAcción. Sólo uno de los “Botones” puede estar presionado en un instante dado. aún si éste no tiene el foco. Este componente proporciona al usuario un medio para iniciar alguna acción en un programa. Tabla . mientras que todos los demás están vacíos. Determina si el usuario eligió esta alternativa. En Verdadero si queremos que la tecla Enter haga que el Botón reaccione.luego de presionarse. 22 . Configurar los Botones de Radio es tan simple com con las Casillas de Verificación. Los Botones de Radio en un programa funcionan de la misma manera. Durante la ejecución examinamos el atributo Verificada de cada Botón para determinar cuál fue seleccionada por el usuario.6. Clase CBotónAcción viene-de CControlWindows Atributos Título Cancelar PorDefecto … Métodos … ObtenerTítulo --> ColocarTítulo ObtenerCancelar --> ColocarCancelar Pag. Basta con establecer el atributo Título para que el usuario conozca la alternativa representada por el Botón. Otro componente ampliamente utilizado es el componente Botón de Acción. Ejemplos de Botón de acción. Tabla . El Botón seleccionado tiene un punto negro en el interior. Atributos de CBotónRadio. Atributo Título Cancelar PorDefecto Función Contiene el texto que muestra el Botón de Acción En Verdadero si se desea que que el Botón reaccione cuando el usuario presione Esc. 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. La elección de un Botón hace que todos los demás se deseleccionen. Atributo Título Verificada Función Determina el texto que aparece junto al Botón de Radio.7. 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 . como grabar un registro o realizar un cálculo. Uno elegía otra estación presionando un botón y el anterior se levantaba.27.

8. Indican cuántas posiciones están disponibles en la barra de desplazamiento. • La Barra de Desplazamiento se utiliza para seleccionar valores en un rango continuo. Atributo VariaciónGrande VariaciónPequeña Mín/Máx Posición Función Determina cuanto se mueve cuando el usuario hace clic sobre la barra a cualquiera de los lados. Informan de cuánto se ha desplazado en la barra. Su valor por defecto es 1. • El Arriba Abajo ayuda a conectar un spinner con una caja de edición.28. 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. Barras de Desplazamiento (CBarraDesp) Ilustración . • La Barra de Dial es útil para dar un mayor efecto de barra de desplazamiento. 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. En la tabla podemos apreciar sus principales atributos. formulario o control. Ejemplo de Barra de desplazamiento. 23 . Tabla . Atributos de CBarraDesp.ObtenerPorDefecto ColocarPorDefecto fclase Controles especializados Los siguientes controles proporcionan alternativas para la captura de datos. que se utiliza para desplazar el contenido de una ventana. Esta es la barra de desplazamiento de Windows.

Uilice Asociar parta conectar el control con una caja de texto. 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 puede escribir un valor directamente en la caja de texto o utilizar los botones para incrementar o decrementar el valor. 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. Este tipo de barra es conveniente cuando se desea establecer o ajustar valores numéricos sobre un rango continuo. distinguimos varias clases predefinidas. Manejo de Listas Estilo: Normal Ilustración . Las Vista en Árbol muestra los elementos en forma jerárquica.30. 24 . Acorde con las herramientas de hoy. Por defecto. Ejemplo de Control Arriba Abajo. Sus propiedades son básicamente similares a los de la barra de desplazamiento. Control Arriba Abajo (CarribaAbajo) Longitud: 33.40 Ilustración . Ejemplo de Barra de dial.29. lo que mueve el indicador directamente a esa posición. Uilice Máx y Mín para establecer los límites sobre los que puede fluctuar el valor del 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. Pag. como el volumen o el brillo. Este atributo se establecer con un valor por defecto. el foco pasa a la caja de texto del control. Si deseamos que el control regrese al valor mínimo cuando llega al máximo. Cuando el usuario hace clic sobre la caja de texto o los botones. La Lista Combinada muestra un lista que se despliega.Ilustración . este control se detiene en su valor máximo. Los controles ArribaAbajo son cajas de texto que aceptan un conjunto limitado y ordenado de valores discretos que varían en forma cíclica.31. coloque Circular en Verdadero. y es útil para ahorrar espacio. El atributo Posición almacena el valor conforme el control va incrementándose o decrementándose. Una Caja de Lista se utiliza para mostrar un lista de textos de las que se puede seleccionar uno o más. Ejemplo de Lista desplegable.

Atributo PáginaActiva Multilínea NúmeroDePáginas Páginas Función Especifica cuál es la ficha seleccionada en ese momento. Se puede permitir a los usuarios seleccionar más de un elemento a la vez estableciendo la propiedad Multielección en verdadero. Nos permite acceso a las fichas. o Shift para seleccionar un rango de elementos. Una lista combinada es un control que combina una caja de texto con una lista. Para incrementar o decrementar dicho valor colóquelo en el atributo CantidadDesplegada. 25 . Fichas (CFicha) Grabar Compilador Ilustración . contamos con el atributo Columnas. Es Verdadero si hay varias líneas de fichas. En la siguiente tabla se muestran sus propiedades. Especifica el número de páginas. Cajas de Lista (CCajaLista) Una caja de lista muestra una relación de la que los usuarios pueden seleccionar uno o más elementos. que almacena el número de columnas que se desee. Por defecto la lista desplegable muestra 8 elementos. Las cajas de lista basan su comportamiento en los valores de los tributos especificados en la sección anterior. con lo que el valor de Texto se actualiza. Los usuarios pueden digitar texto o seleccionar un elemento de la lista. Pag.32. Los usuarios pueden entonces utilizar la tecla Ctrl para seleccionar elementos en posiciones discontinuas.Atributos comunes para los controles de Lista Para agregar columnas adicionales a un control de lista. El atributo Indice de Elemento indica cuál de los elementos en la lista se ha seleccionado.9. El atributo Ordenada determina si la lista se ordenará el orden alfabético. Atributos de Cficha. La propiedad Elementos es en realidad un conjunto de cadenas texto que se llenan con valores. Ejemplo de Ficha. Tabla . Este componente es un conjunto de páginas que se utiliza para crear diálogos de varias páginas. Listas combinadas (CListaCombinada).

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.La clase CFormulario Formulario en Blanco Ilustración . Para mostrar un formulario que no está activo en este momento en nuestra aplicación. El atributo ControlActivo es una apuntador que tiene la dirección del control activo sobre el formulario. 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. hemos incluido estos métodos para que puedan invocarse por programació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. 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). cajas de diálogo o formularios de entrada de datos. esta clase tiene todos los atributos y métodos de los controles de Windows pues es un descendiente de la clase CcontrolWindows. Sobre un formulario colocamos otros elementos. Ejemplo de un Formulario en blanco. Además de estos atributos y métodos. Así mismo los puede extender para que realice otras acciones aparte. La clase componente CFormulario es por lo general el centro de toda aplicación. Pag. ventanas.33. se invoca al método Principal. y los podemos utilizar como simples formularios. 26 . El método Terminar finaliza la ejecución de la aplicación.

Clase CAplicación viene-de CComponente Atributos Arreglo aEntorno nEntorno Apuntador FormularioPrincipal Título Métodos Constructor(aEntorno. Ejemplo. Además de estos atributos y métodos. nEntorno) Principal fclase Método Constructor(aEntorno.Podemos especificar cómo se manejarán las excepciones utilizando los métodos ManejarExcepción. Para especificar qué ocurre cuando la aplicación se activa o inactiva utilizamos los métodos AlActivar y AlDesactivar. Estos son respectivamente un arreglo de cadenas de texto y un número respectivamente. El objetivo de esta aplicación es mostrar un mensaje en la pantalla. pero en ningún momento estamos creando una instancia de CMiAplicación. el componente CAplicación tiene también los atributos y métodos que se aplican a todos los componentes. nEntorno) Título <-. nEntorno) de CMiAplicación Heredado Constructor(aEntorno. Contienen los parámetros que nos envía el entorno del sistema y el número de parámetros que estamos recibiendo.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. El siguiente ejemplo es un uso muy sencillo de esta clase. 27 . Cuando la aplicación entra en estado de espera (conocido como idle) podemos especificar que ocurra algo por medio del método AlEsperar. Estos es debido a que estamos utilizando el concepto de que el sistema es quien ejecuta nuestra aplicación. 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. pues es un descendiente directo de CComponente. y por tanto la creación de la instancia y la llamada a los métodos Constructor Pag. 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. Clase CMiAplicación viene-de CAplicación Métodos Constructor(aEntorno.‘Aplicación de Ejemplo’ FormularioPrincipal <-.

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).y Principal depende del sistema. 28 . Pag.

y mayormente lo escribe el creador de la clase. 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. AlArratrarSoltar FinArrastrar Finaliza la oparción de arrastrar. 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. utilizamos los eventos para que los desarrolladores de aplicaciones personalicen el comportamiento de nuestras clases. ArrastrarSoltar El usuario arrastra el objeto con el ratón. pero precedidos por el prefijo Al. DobleClic El usuario presiona dos veces seguidas el AlDobleClic botón izquierdo del ratón. es decir. Por ejemplo la clase CBotónAcción tiene un método AlClic. AlSoltarRatón Tabla . sean de Windows. Todos los eventos estándar tienen sus correspondientes métodos declarados en la clase CControl. MoverRatón Se desplaza por la pantalla el puntero del AlMoverRatón ratón. AlUndirRatón SoltarRatón Levantar el dedo del botón del ratón. gráficos o personalizados.Tratamiento de Eventos Los eventos son parte importante de las clases. aunque el desarrollador por lo general no necesita mayor esfuerzo con ellos. Eventos estándar comunes a las Clases componentes. heredan estos eventos. las clases predefinidas tiene incorporados métodos que responden a cietros eventos estándares. La siguiente tabla lista los eventos disponibles para todos los controles: Evento Clic Ocurre cuando Método asociado El usuario presiona una vez el botón AlClic izquierdo del ratón. Aquí expresamos de otra manera lo anteriormente dicho: Pag. El lenguaje de pseudocódigo proporciona los mecanismos para la escritura del código que responde a los eventos. Todos los controles. con el mismo nombre que el evento. Como creadores de clases. la cual está fuera del contexto de nuestro lenguaje. Al utilizar los eventos. En nuestro lenguaje de pseudocódigo. Implantar eventos estándar Eventos estándar para todos los controles Los eventos básicos se definen en la clase CControl. AlFinArrastrar suelta el ratón. y esta labor la realiza la capa de administración de eventos. UndirRatón Presionar el botón del ratón. los desarrolladores de aplicaciones pueden personalizar el comportamiento de las clases sin tener que cambiar las clases en sí. 29 . 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. ArratrarSobre El puntero del ratón está pasando sobre un AlArrastrarSobre objeto. pero proporcionamos los mecanismos para definir nuevos eventos y asociarlos con las clases. El bloque de código de respuesta es el gestor del evento. pero es durante la ejecución que se va transfiriendo el control a los métodos correspondientes.10.

Pag. 30 . El usuario hace clic sobre la Casilla de Verificación. Eventos clave para las Clases componentes.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. El usuario hace clic sobre el Botón. los eventos para los controles de Windows (CControlWindows) tiene sus métodos correspondientes. CBotónRadio Clic El usuario hace clic sobre el Botón de radio Tabla . Para este evento. Eventos de las Clases componentes estándar. el método asociado en la clase CEdición sería AlCambiar. 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 .12. el único que no está ya contemplado por las clases es el evento Cambiar. Al igual que los eventos estándar de la sección anterior. De todos estos eventos clave.11. Clase CControlWindows viene-de CControl Métodos AlEntrar AlSoltarTecla AlUndirTecla AlPresionarTecla AlSalir fclase Eventos clave Clase CEdición CBotónAcción CCasilla Evento Cambiar Clic Clic Ocurre cuando El usuario modifica el texto en la Caja.

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. • Las excepciones se manejan con las sentencias Proteger…Excepción. 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. La propagación de la excepción continúa hasta que se encuentra el manejador adecuado. 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. el control se transfiere al manejador más próximo que puede tratar las excepciones de esa clase. y el control se pasa a la sentencia que sigue a la palabra reservada fproteger que finaliza la sentencia Proteger…Excepción. • 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. Cuando se provoca una excepción. facilitando así el mantenimiento y fortaleciendo la solución. Las ventajas principales son: • Las excepciones se pueden agrupar en jerarquías utilizando la herencia. Si esa sentencia Proteger…Excepción no puede tratar la excepción. 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. Pag. • Se pueden introducir nuevas excepciones sin afectar el código existente. Para representar las excepciones optamos por utilizar objetos. Si las sentencias se ejecutan sin que se provoquen excepciones.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. o hasta que no hay más sentencias 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. En el último caso se emite un mensaje de error y el algoritmo finaliza. 31 . el bloque de excepciones se ignora. ésta hace que el control se transfiera del punto actual de ejecución a un gestor de excepciones. se examina la siguiente sentencia Proteger…Excepción a la que se ha ingresado recientemente. Protección de Sentencias Las excepciones se manejan usando la sentencia Proteger…Excepción.

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.Para determinar si el bloque de excepción de una sentencia Proteger…Excepción puede manejar una excepción en especial. el objeto se destruye automáticamente invocando al método Destructor. 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. El primer manejador de excepciones que lista la clase excepción o la clase base de la excepción se considera una coincidencia. 32 . Un bloque de excepciones que contiene sólo una lista de sentencias se considera una coincidencia para cualquier excepción. los manejadores Cuando…fcuando se examinan en orden de aparición. la parte Sino se considera una coincidencia. En el siguiente ejemplo. Por ejemplo Proteger … Excepción Cuando CDivisiónPorCero Hacer ManejarDivisiónPorCero fcuando Cuando CSobreflujo Hacer ManejarSobreflujo fcuando Sino ManejarOtras fproteger Pag. 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. entonces cualquier excepción que no se trata en los manejadores Cuando…fcuando será tratada por la parte Sino. Luego de la ejecución de un manejador de excepciones. Si la sentencia Proteger…fproteger especifica una parte Sino. y así el control se pasa a la sentencia que sigue a la palabra clave fproteger la cual finaliza la sentencia Proteger… fproteger. Así podemos utilizar esta instancia dentro de las sentencias del bloque Cuando…fcuando. el primer Cuando…fcuando maneja la excepción de división por cero y el segundo maneja la excepción de sobreflujo.

que todo objeto de excepción hereda. incluyendo una clase CExcepción que sirve de raíz para todas las clases de excepción. Mensaje y ContextoDeAyuda. Una vez que la excepción se maneja. Generación manual de Excepciones Una excepción se provoca con la sentencia Provocar. Método IngresarNúmero (Número. pero contiene un grupo de sentencias. Clase CExcepción viene-de CObjeto Atributos Mensaje ContextoDeAyuda Métodos Constructor(UnMensaje. UnContextoDeAyuda) ObtenerMensaje --> ObtenerContextoDeAyuda --> fclase La clase CExcepción establece dos propiedades. Provocar identificador-objeto-excepción El argumento de la sentencia Provocar debe ser un objeto. 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).Un bloque de excepción que no contiene manejadores Cuando…fcuando. 33 . 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. 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. 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. la lógica de tratamiento de excepciones toma se apropia del objeto excepción. manejará todas las excepciones. Nosotros no debemos tratar de destruir manualmente el objeto excepción. Mín. el objeto excepción se destruye automáticamente invocando a su destructor. Cuando se provoca una excepción.

Está más orientada a la implantación. CDivisiónPorCero Surge cuando se intenta una división que tiene por divisor un valor de cero. Clases derivadas de CExcepción. Desciende de CErrorMatemático. las excepciones son descendientes directos de Cexcepción. pero su frecuencia amerita incluirla.A continuación se listan las excepciones que contempla el lenguaje de pesudocódigo y las situaciones en que se pueden provocar. Tabla . o si el tamaño de la pila alcanza su límite superior. Desciende de CErrorMatemático. CErrorMatemático La clase padre de todas las excepciones de operaciones matemáticas. Clase de Excepción CSinMemoria Descripción Surge cuando no hay suficiente memoria para una operación en particular. A menos que se especifique otra cosa. Esta excepción presupone un límite en la pila.13. CErrorES Surge cuando una operación de entrada/salida genera un error. 34 . Pag. CSobreflujo Surge cuando una operación produce un sobreflujo (overflow). una restricción física. pero es tan frecuente que cabe su inclusión. CSobreflujoDePila Aparece cuando la pila de nuestra aplicación no puede expandirse.

.aAlumnoB // referencia global a una dimensión aAlumnoA[3. aAlumnoA Dimensión 1…20. .. Noten que estamos colocando el prefijo a en el nombre del arreglo. .Objetos Especiales Arreglos Los arreglos tienen un número fijo de componentes del mismo tipo de valor. 2] <-... nomb_de_arreglo [ Dimensión rango1. Si no incluimos la referencia a un componente en particular. 35 . el identificador del arreglo referencia a la totalidad de éste. rangon ] Ejemplar-de CArreglo Por ejemplo: aMatriz1 Dimensión 1…10. para cada IdentificadorElemento en IdentificadorColección hacer Secuencia de “n” acciones fpara Por ejemplo: objeto arregloPersonas ejemplar-de CArregloPersonas .aAlumnoB // referencia a todo el arreglo aAlumnoA[5] <-. 1…10 Ejemplar-de CArreglo aAlumnoB Dimensión 1…10 Ejemplar-de CArreglo aAlumnoC Dimensión 1…10 Ejemplar-de CArreglo … aAlumnoC <-. Para indicar el rango de valores de uno de los subíndices. Así mismo tenemos que indicar el rango de valores para cada una de las dimensiones del arreglo. El número de elementos del arreglo es el producto de los valores máximos de cada subíndice. 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. simplemente especificamos los límites inferior y superior del rango y colocamos entre ellos puntos suspensivos (…). Pag. nombre_de_arreglo [índice] // Un elemento del arreglo nombre_de_arreglo // Todo el arreglo En el siguiente ejemplo mostramos el uso de ambas posibilidades. Declarar Para declarar un arreglo en el pseudocódigo. La sintaxis es la siguiente. la cual especifica cómo se identificará al elemento actual en cada iteración y a la colección que se recorrerá.. 1…20 Ejemplar-de Carreglo Aquí definimos un arreglo llamado aMatriz1 cuyo número de elementos es 10*20.‘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. necesitamos especificar un nombre o identificador para el arreglo.

36 . Reservar pCuenta pCuenta <-.obtenerNombre) fpara Apuntadores Los apuntadores son variables que almacenan un tipos especial de valor: direcciones 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.nulo // Reserva espacio para el apuntador // apunta a ninguna parte Asignar valor Los apuntadores pueden recibir direcciones como valores válidos.'15307863' Desplazamiento con apuntadores En los casos de apuntadores a arreglos de bloques. se utiliza el operador ↑ delante del nombre del 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. 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 incrementa el valor del apuntador en la cantidad de posiciones que se desea desplazar. En esas direcciones se guardan valores relevantes para nuestro algoritmo. identificador_apuntador <-. se multiplica por la cantidad de bloques requeridos. ↑identificador_apuntador <-. 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. La palabra reservada nulo denota un valor que significa que nuestra variable apunta a ninguna parte.valor Por ejemplo: ↑pCuenta <-.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. para avanzar a un bloque específico del arreglo se utiliza la siguiente sintaxis. identificador_apuntador <-. 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. Cuando se desea reservar un arreglo de bloques contiguos de memoria.@ identificador ó identificador_apuntador <-.para cada persona en arregloPersonas hacer Escribir(persona.identificador_apuntador + n Pag.

Pag.. se utiliza la siguiente sintaxis. informaciónPedido ejemplar-de SInformaciónPedido informaciónPedido.. más que una clase que pueda aceptar creación de instancias. se utiliza la siguiente sintaxis. pero con la diferencia de que no poseen constructor ni son capaces de participar en una jerarquía. oLoop permite la declaración de estructuras... En oLoop se puede declarar tipos para enumeraciones con la siguiente sintaxis.Por ejemplo: pNumeros <-. Son básicamente un tipo de valor compuesto para declaración de variables. valor2. APROBADO. 37 . muy similares a las clases. 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.NúmeroPedido <-. valorN }] Enumeración EEstadoPedido [ PENDIENTE.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#). Enumeración IdentificadorEnumeración [ valor1 {.450 Enumeraciones En muchos lenguajes de programación se implementa el concepto de enumeraciones o tipos enumerados. La sintaxis para declarar estructuras se presenta a continuación. RECHAZADO ] Para declarar una variable de un tipo enumerado. identificador_variable ejemplar-de IdentificadorEstructura Por ejemplo: Estructura SInformaciónPedido Atributos NúmeroPedido FechaPedido festructura ..

Pendiente Interfaces Para declarar interfaces en oLoop se utiliza la siguiente sintaxis.obtenerInstancia retornar facade.obtenerNombre. cliente.obtenerContrasena. 38 .EEstadoPedido. 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.insertarCliente( cliente. cliente.obtenerInstancia -> Objeto cliente ejemplar-de CClienteNegocio cliente.identificador_variable ejemplar-de IdentificadorEnumeración Por ejemplo: pedido ejemplar-de EEstadoPedido pedido <-. cliente.constructor retornar cliente fmétodo Método CClienteNegocio.obtenerUsuario.registrarCliente(cliente) IAccesoDatos facade = InfraestructuraFacade.obtenerCodigo. 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 {. se utiliza la siguiente sintaxis. Pag. [ @ ] Por ejemplo: Interfaz IManejadorCliente Métodos obtenerInstancia -> registrarCliente(cliente) -> fclase Para declarar que una clase implementa una interfaz.

39 . La declaración de la clase CArchivo se especifica a continuación. Clase CArchivo Atributos Nombre Ruta ModoAcceso // // // // // Nombre del archivo Ruta de directorio del archivo 'Lectura' | 'Escritura' | 'Lectura-Escritura' | 'Adición' 'Secuencial' | 'Aleatorio' Tipo Métodos Crear -> Abrir -> Cerrar -> Leer -> Leer(pPosicion) -> Escribir(Objeto) Escribir(Posicion. Para ello cuenta con la clase predefinida CArchivo. Esta clase encapsula la funcionalidad genérica para el manejo de archivos.obtenerFax. Objeto) ObtenerNombre -> ColocarNombre(NuevoNombre) ObtenerRuta -> ColocarRuta(NuevaRuta) ObtenerModoAcceso -> ColocarModoAcceso(NuevoModoAcceso) ObtenerTipo -> ColocarTipo(NuevoTipo) FinDeArchivo -> fclase Pag. cliente.cliente.obtenerCorreo.obtenerPais) fmétodo Archivos oLoop permite el uso de archivos secuenciales o aleatorios. cliente.obtenerTelefono. cliente.

Para definirlo necesitamos sus coordenadas X e Y. NuevoY) fclase Pag. Clase CPunto Atributos X Y Métodos ObtenerX ObtenerY Constructor(NuevoX.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. 40 . que entendemos por un pixel en la pantalla.

NuevoY fmétodo Método CPunto.Constructor(NuevoX. 41 .ObtenerX Retornar X fmétodo Método CPunto. demostramos como declarar las definiciones de los métodos de la clase arriba definida.ObtenerX Retornar Y fmétodo Pag.NuevoX Y <-. NuevoY) X <-.Implantación de Métodos Continuando con nuestro ejemplo del punto. Método CPunto.

ObtenerVisible Retornar Visible fmétodo Método CPunto.NuevoY fmétodo Método CPosición.ObtenerX Retornar X fmétodo Método CPosición. Clase CPosición Atributos X Y Métodos Constructor(NuevoX. QueY) fclase // Métodos de la Clase CPosición Método CPosición. NuevoY) Mostrar Ocultar ObtenerVisible MoverHacia(QueX.Verdadero DibujarPixel(X.QueX // Asigna las nuevas coordenadas Pag. NuevoY) ObtenerX --> ObtenerY --> fclase Clase CPunto viene-de CPosición Atributos Visible Métodos Constructor(NuevoX.MoverHacia(QueX. Y. ObtenerColorPrimerPlano) // Dibuja un pixel en la pantalla (blanco sobre negro) fmétodo Método CPunto. ObtenerColorFondo) // Dibuja un pixel en la pantalla (negro sobre negro) fmétodo Método CPunto.Falso fmétodo Método CPunto. NuevoY) X <-.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.Constructor(NuevoX.ObtenerY Retornar Y fmétodo // Métodos de la Clase CPunto Método CPunto.Constructor(NuevoX.NuevoX Y <-. 42 .Ocultar Visible <-.Mostrar Visible <-. NuevoY) Heredado Constructor(NuevoX. Y. NuevoY) Visible <-. QueY) Ocultar // Oculta el punto X <-.Falso DibujarPixel(X.

ObtenerColorFondo) Dibuja un círculo en la pantalla (negro sobre negro) fmétodo // Método CPunto. Clase CSegmento Atributos Lugar nuSegmento Métodos Constructor(NuevoSegmento. NuevoY. NuevoRadio) Mostrar Ocultar Expandir MoverHacia Contraer fclase Método CCírculo.Expandir(FactorExpansión) Ocultar Radio  Radio + FactorExpansión Mostrar fmétodo Método CCírculo. NuevoLugar) ImprimirEncabezado Acción ImprimirCorte Pag. NuevoY. Radio.Verdadero DibujarCírculo(X.NuevoRadio fmétodo Método CCírculo.Constructor(NuevoX. Y.Falso DibujarCírculo(X. Y.QueY Mostrar fmétodo Método CCírculo.MoverHacia(QueX. NuevoY) Radio <-.Y <-.QueX Y <-.MoverHacia(QueX. QueY) Ocultar X <-. QueY) Ocultar X <-. NuevoRadio) Heredado Constructor(NuevoX. Radio. Clase CCírculo viene-de CPunto Atributos Radio Métodos Constructor(NuevoX.Ocultar Visible <-.Contraer(FactorContracción) Expandir(-FactorContracción) fmétodo Método CCírculo.QueY Mostrar fmétodo // Muestra el punto // La clase CCírculo será un hijo de CPunto. ObtenerColorPrimerPlano) // Dibuja un círculo en la pantalla (blanco sobre negro) fmétodo Método CCírculo.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.Mostrar Visible <-.QueX Y <-. 43 .

NuevoLugar) Lugar <-.Constructor(NuevoNúmero.NuevaLínea fmétodo Método CPersona. NuevaLínea) ColocarLíneaEtiqueta(QueLínea) ObtenerLíneaEtiqueta --> Decir(Línea) fclase Método CPersona.‘Segmento # ‘ + nuSegmento + ‘ ‘ + Lugar Escribir(LíneaTexto) fmétodo Método CSegmento.Constructor(NuevoNúmero.Constructor(nmActor2. ‘’) fmétodo Método CDiálogo.ImprimirCorte Escribir(‘------------------‘) fmétodo Clase CPersona Atributos nmPersona // Nombre de persona LíneaEtiqueta Métodos Constructor(NuevoNombre.NuevoNombre LíneaEtiqueta <-.Acción fmétodo Método CSegmento.Acción Pag. NuevoLugar) PersonaA. NuevaLínea) nmPersona <-. NuevaLínea. nmActor1.NuevoLugar nuSegmento <-.Constructor(nmActor1.NuevoSegmento fmétodo Método CSegmento.Decir(Línea) LíneaTexto <-.ImprimirEncabezado LíneaTexto <-.ColocarLíneaEtiqueta(QueLínea) LíneaEtiqueta <-.Constructor(NuevoNombre.fclase Método CSegmento.QueLínea fmétodo Método CPersona.ObtenerLíneaEtiqueta Retornar LíneaEtiqueta fmétodo Método CPersona. nmActor2) Heredado Constructor(NuevoNúmero. nmActor2) Acción Saludos Conversar Despedirse fclase Método CPersona. nmActor1.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. NuevoLugar. ‘’) PersonaB. 44 .

ObtenerLíneaEtiqueta) fmétodo Método CDiálogo. 45 .Decir(‘Chau’) PersonaB.Decir(‘Hola’) PersonaB.Decir(‘Nos vemos’) fmétodo Pag.Despedirse PersonaA.Agradecimientos Conversar Despedirse fmétodo Método CDiálogo.ObtenerLíneaEtiqueta) PersonaB.ColocarLíneaEtiqueta(‘Si que hace calor’) PersonaB.Saludos PersonaA.Conversar PersonaA.Decir(‘Que tal’) PersonaA.Decir(PersonaB.Decir(PersonaA.ColocarLíneaEtiqueta(‘Y que lo digas’) fmétodo Método CDiálogo.

ISBN 1-56884-795-5. Delphi Programming Problem Solver. Timothy (1994). Keith .. Escuela Académico Profesional de Computación. Object-Oriented Programming: An Introduction.FLAMING.PÉREZ CABREL. Programación Orientada a Objetos: Una Introducción. Programación Orientada a Objetos con Turbo C++. IDG Books Worldwide Inc. Lima. Editorial Limusa S. de C. C++ : Guía para Programadores en C. Universidad Nacional Mayor de San Marcos .V. McGraw Hill. México. México. Estructura de Datos: Un enfoque Algorítmico. Wilmington.Facultad de Ciencias Matemáticas. Delaware. Bryan (1993). Grupo Noriega Editores. ● WEISKAMP. Teodomiro (1995). Manuel . Addison Wesley Iberoamericana. 46 . Neil (1995). ● HEKMATPOUR. Sharam (1992). Loren . Orig. Greg (1994). Introducción a la Programación Orientada a Objetos. ● GALLARDO OTERO. ● RUBENKING. Prentice Hall Inc.HEINY. Pag.Bibliografía ● VOSS. México.A. ● BUDD.

por falta de costumbre o por "rapidez".Sugerencias para la escritura de Pseudocódigo Indentación Para facilitar la comprensión. 47 . contador. Notación de Identificadores Los identificadores son cadenas de texto que permiten hacer referencia a valores determinados.. 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. El nombre de una variable nos puede dar información sobre el significado del valor al que referencia (nombre de una persona.fsi. Aunque los bloques están denotados por palabras subrayadas. acumulador de totales. etc. se creó el concepto de indentación en la escritura de los mismos. etc.). Idioma de Trabajo La nomenclatura de identificadores de variables. acción o función. Otros prefieren el español por comodidad y para lograr una mayor claridad y comprensión por parte del lector. en el cual una letra denota el tipo de valor con que trabaja la variable. no aprovechamos las propiedades informativas de los identificadores. u ObtenerCodigoDeFactura que OBTENERCODIGODEFACTURA. Es mas claro escribir ClaseDeDato que CLASEDEDATO.. (Si. Esta última nos permitirá utilizar el término exacto que ayude a captar el significado del valor. el tipo de valor (numérico. así: Pag. Notación Húngara Un tipo de notación muy conocida en el ambiente informático es el de la notación húngara. acciones. cadena de caracteres. estructuras. Esto produce una sensación de armonía y ayuda a la fácil comprensión del mismo. 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. Muchas veces. Para elegir el idioma de nomenclatura debe tenerse en cuenta la comodidad personal. Esta consiste en el desplazamiento hacia la derecha de un subconjunto de la secuencia de acciones. 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.). etc. Es recomendable desplazar dos o tres posiciones el bloque para facilitar la comprensión del flujo lógico. estructura. lectura y revisión del pseudo-código. debe estar regida por un idioma único para lograr la uniformidad en el pseudo-código. funciones.

Tabla . es decir identificadores asociados a valores que no cambian en el tiempo. Evento de interfaz evRatón. Por ejemplo: Prefijo ec ev cm Descripción Ejemplo Tipo de Estado Civil ecSoltero.14.15. Pag... 48 .. . ecCasado. Ejemplo de uso de Prefijos. La eficiencia de la notación de prefijo depende la habilidad para encontrar siglas que sinteticen el tipo de valor. 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.Prefijo b n a ch c p S m_ Descripción Valor booleano Valor numérico Arreglo o Matriz Carácter Cadena de caracteres Apuntador Estructura Miembro de la Estructura Tabla .. . Ejemplo bEsCasado nEdad aAlumnos chRespuesta cNombre pNodo SPersona m_cNombre Notación de Constantes Para la notación de constantes. . evTeclado. Ejemplos de Prefijos en Constantes. existen la notación de prefijos... cmAbrir. Comando de Aplicación cmSalir.