Paradigma de Programacion Con Orientacion A Objetos

Universidad Tecnolgica Nacional
Facultad Regional Crdoba

Dpto de Ingeniera en Sistemas de Informacin
Ctedra de Paradigmas de Programacin
UNIDAD N 4
PARADIGMA DE PROGRAMACIN
CON ORIENTACIN A OBJETOS
EL PRESENTE CAPTULO HA SIDO ELABORADO, CORREGIDO Y COMPAGINADO POR:
ING. COLACIOPPO NICOLS

MGTR. ING. CORSO, CYNTHIA
ESP. ING.GUZMAN, ANALIA
ESP. ING. LIGORRIA, KARINA
ESP. ING. LIGORRIA, LAURA
DR. ING. MARCISZACK, MARCELO
ING. ROMANI, GERMAN
ESP. ING. TYMOSCHUK, JORGE
AGOSTO 2 0 1 6
NDICE
Objetivos de la Unidad ....6
Contenidos Abordados.. 6
1. Historia ......................................................................................................................................................... 6
2. PARADIGMA ORIENTADO A OBJETOS .......................................................................................................... 8
2.1 Conceptos Introductorios................................................................................................................... 8
2.2 Caractersticas de la POO ................................................................................................................... 9
2.3 Objeto ............................................................................................................................................... 12
2.4 Los Objetos en el Paradigma Orientado a Objetos .......................................................................... 14
2.4.1 Abstraccin .................................................................................................................................. 14
2.4.2 Identidad ...................................................................................................................................... 14
2.4.3 Comportamiento.......................................................................................................................... 14
2.4.4 Capacidad de Inspeccin.............................................................................................................. 15
2.5 Colaboraciones: Mensaje y mtodo................................................................................................. 16
2.6 Colaboradores Internos / Estado interno ........................................................................................ 20
2.7 Encapsulamiento .............................................................................................................................. 20
2.8 Interpretacin de las colaboraciones: Colaboradores externos ...................................................... 21
2.9 Polimorfismo .................................................................................................................................... 22
2.10 Mensajes a m mismo self ............................................................................................................. 23
2.11 Destruccin, Creacin y Representacin del conocimiento ............................................................ 24
2.12 Clases ................................................................................................................................................ 27
2.12.1 Definicin de comportamiento comn ................................................................................... 27
2.12.2 Cmo se crean objetos ............................................................................................................ 27
2.12.3 Clases e instancias ................................................................................................................... 28
2.12.4 Forma del cdigo Smalltalk ..................................................................................................... 28
2.13 Relaciones entre clases .................................................................................................................... 29
2.13.1 Asociacin ................................................................................................................................ 29
2.13.2 Agregacin / Composicin....................................................................................................... 30
2.13.3 Generalizacin / Especializacin ............................................................................................. 31
2.14 Reutilizacin ..................................................................................................................................... 32
Unidad N 4: Paradigma de Programacin con Orientacin a Objetos Pgina 2

2.15 Herencia ........................................................................................................................................... 32

2.15.1 Estrategias para implementar herencia .................................................................................. 32
2.15.2 Modelos de implementacin .................................................................................................. 34
2.16 Polimorfismo .................................................................................................................................... 36
2.16.1 Tipos de Polimorfismo ............................................................................................................. 36
2.17 Ambiente .......................................................................................................................................... 38
2.18 Software ........................................................................................................................................... 38
3. Implementacin del POO con Smalltalk .................................................................................................... 40
3.1 Introduccin ..................................................................................................................................... 40
3.2 Aspectos importantes de Smalltalk [Budd 91] ................................................................................. 41
3.2.1 Asignacin dinmica de memoria ................................................................................................ 41
3.2.2 Asignacin de referencias ............................................................................................................ 42
3.2.3 Asignacin dinmica de tipos ...................................................................................................... 42
3.2.4 Objetos polimrficos.................................................................................................................... 42
3.3 Sintaxis y Semntica del Lenguaje Smalltalk .................................................................................... 43
3.3.1 Comentarios ................................................................................................................................. 43
3.3.2 Operador de asignacin (:=)........................................................................................................ 43
3.3.3 Literales y Variables .................................................................................................................... 43
3.3.3.1 Variables Locales o Temporales .............................................................................................. 44
3.3.3.2 Variables Globales. .................................................................................................................. 44
3.3.4 Pseudo-Variables ......................................................................................................................... 45
3.3.4.1 Objeto especial nil ................................................................................................................... 45
3.3.4.2 true .......................................................................................................................................... 46
3.3.4.3 false ......................................................................................................................................... 46
3.3.4.4 self ........................................................................................................................................... 46
3.3.4.5 super ........................................................................................................................................ 46
3.3.4.6 thisContext .............................................................................................................................. 46
3.3.5 Smbolos ....................................................................................................................................... 46
3.4 Implementacin de Conceptos del POO en Smalltalk ..................................................................... 47
3.4.1 Clases ........................................................................................................................................... 47
3.4.1.1 Variables de Instancia .............................................................................................................. 48
3.4.1.2 Variables de Clase .................................................................................................................... 48

3.4.1.3 Variables Contenedoras .......................................................................................................... 49

3.4.2 Instancias de una clase ................................................................................................................ 50
3.4.3 Mtodos ....................................................................................................................................... 50
3.4.3.1 Mtodos de acceso y modificacin ......................................................................................... 52
3.4.3.2 Mtodos de inicializacin ........................................................................................................ 53
3.4.3.2.1 Inicializacin de Variables de Instancia ............................................................................... 53
3.4.3.2.2 Inicializacin de Variables de Clase ..................................................................................... 54
3.4.4 Paso de Mensajes ........................................................................................................................ 54
3.4.4.1 Pasos Implicados en la Ejecucin de un Mensaje ................................................................... 57
3.4.4.2 Envo de ms de un Mensaje a un Objeto ............................................................................... 58
3.4.4.3 Reglas de Prioridad de Mensajes ............................................................................................ 58
3.4.5 Resolucin de un Caso de Estudio ............................................................................................... 59
3.5 Implementacin de Composicin en Smalltalk ................................................................................ 61
3.6 Implementacin de Herencia en Smalltalk ...................................................................................... 64
3.6.1.1 Definir una Subclase ................................................................................................................ 65
3.6.1.2 Uso de super ............................................................................................................................ 66
3.6.1.3 Herencia de variables .............................................................................................................. 66
3.6.1.4 Inicializacin de Atributos en una Clase Hija ........................................................................... 67
3.6.1.5 Herencia de mtodos .............................................................................................................. 67
3.6.1.6 Enlace Dinmico ...................................................................................................................... 68
3.6.1.7 Clases abstractas ..................................................................................................................... 68
3.7 Implementacin de Polimorfismo en Smalltalk ............................................................................... 72
3.8 Biblioteca de Clases de Smalltalk ..................................................................................................... 78
3.8.1 Clase Object ................................................................................................................................. 78
3.8.2 Objeto indefinido ......................................................................................................................... 80
3.8.3 Magnitudes .................................................................................................................................. 80
3.8.3.1 Nmeros .................................................................................................................................. 82
3.8.3.1.1 Enteros ................................................................................................................................ 83
3.8.3.1.2 Fracciones ........................................................................................................................... 83

3.8.3.2 Caracteres ................................................................................................................................ 84

3.8.3.3 Fechas y Horas ......................................................................................................................... 84
3.8.3.3.1 Clase Date............................................................................................................................ 84
3.8.3.3.2 Clase Time ........................................................................................................................... 86
3.8.4 Booleanos .................................................................................................................................... 88
3.8.5 Bloques......................................................................................................................................... 89
3.8.5.1 Estructuras de Control ............................................................................................................. 91
3.8.5.1.1 Estructuras condicionales ................................................................................................... 91
3.8.5.1.2 Estructuras repetitivas determinadas ................................................................................. 92
3.8.5.1.3 Estructuras repetitivas indeterminadas (o condicionales) ................................................. 94
3.8.5.1.4 Resolucin de Caso de Estudio ........................................................................................... 95
3.9 Colecciones en Smalltalk .................................................................................................................. 99
3.9.1 Introduccin ................................................................................................................................. 99
3.9.2 Set .............................................................................................................................................. 102
3.9.3 Bag.............................................................................................................................................. 103
3.9.4 OrderedCollection...................................................................................................................... 103
3.9.5 SortedCollection ........................................................................................................................ 105
3.9.6 Array........................................................................................................................................... 107
3.9.7 De un Tipo a Otro ....................................................................................................................... 108
3.9.8 Operaciones sobre Colecciones ................................................................................................. 110
3.9.8.1 Creacin de Instancias ........................................................................................................... 110
3.9.8.2 Consulta ................................................................................................................................. 111
3.9.8.3 Aadir y Remover Objetos .................................................................................................... 112
3.9.8.4 Recorrido ............................................................................................................................... 114
3.9.9 Dictionary ................................................................................................................................... 115
3.9.9.1 Insersin y Remocin de Elementos ..................................................................................... 117
3.9.9.2 Recuperacin de Elementos .................................................................................................. 119
3.9.9.3 Recorrido ............................................................................................................................... 125
3.9.10 Cmo elegir la Coleccin ms adecuada? ............................................................................. 125
4. Anexo I: Ejemplos..................................................................................................................................... 126
4.1 Ejemplo: La Golondrina .................................................................................................................. 126
5. Bibliografa ............................................................................................................................................... 145

O BJETIVOS DE LA U NIDAD
Que el alumno comprenda acabadamente los mecanismos fundamentales que dan origen a este
paradigma.
Que el alumno utilice para la resolucin de problemas un lenguaje con OO puro en su concepcin y
representacin.
C ONTENIDOS A BORDADOS
Conceptos fundamentales. Abstraccin de datos y ocultamiento de la informacin. Estructura de un

objeto. Mtodos y mensajes. Clasificacin. Clase. Concepto de generalizacin-especializacin.
Herencia, simple y mltiple. Polimorfismo.
Conceptos del modelo de objetos en SmallTalk. Desarrollo de la sintaxis de objetos en Smalltalk.
Expresiones literales. Caracteres, secuencia de caracteres, smbolos y nmeros. Expresiones de
asignacin y variables. Asignacin. Tipos de variables. Variables privadas: de instancia nombradas e
indexadas, argumentos y temporales. Variables compartidas: de clase, globales y pool. Variables
especiales: self y super. Expresiones de mensaje. Sintaxis de un mensaje. Tipos de mensajes:
unario, binario y palabra clave. Orden de precedencia en la evaluacin de expresiones. Expresin
de mensajes en cascada. Expresiones de bloque. Clase Context. Bloques con y sin argumentos.
Evaluacin de bloques. Mtodos y expresiones de retorno. Sintaxis de la definicin de un mtodo.
Significado de la expresin de retorno. Mtodos de clase e instancia.
Lenguaje asociado: Smalltalk. Pharo 3.0. Imagen, ambiente de objetos, definicin y uso de clases y
objetos.
1. HISTORIA
Simula 67 (1967): Precursor de la tecnologa de objetos, tal cual se la conoce actualmente. Fue el
primero de los lenguajes orientado a objetos. Varios aos despus de su desarrollo, casi todos los lenguajes
modernos comenzaron a utilizar sus principios de orientacin a objetos. As fue como se popularizaron
trminos como clases, objetos, instancias, herencia, polimorfismo, etc.
Ao 1969: Alan Kay (personaje fundamental de la informtica) Matemtico, Psiclogo, Computlogo y
Msico Estudi como mejorar el proceso cognitivo utilizando herramientas informticas. Estudi dentro del
MIT como los nios llegaban a conceptualizaciones y abstracciones complejas a travs de juegos con LOGO.
En la dcada del 60 estaban en auge los Mainframes; Alan Kay propuso que computadora se necesitara
para favorecer el proceso cognitivo. Defini conceptualmente a DYNABOOX (Computadora personal tipo
agenda, que tuviera todo lo necesario para comunicarse con otras personas) Esta deba contener todo lo
necesario, sino que siempre disponible, lo que constituyo las bases de los ordenadores porttiles y tablet PC

actuales, considerado por algunos como el arquitecto de los sistemas modernos de ventanas GUI (Interfaz
Grfica de usuario).
Ao 1970: Xerox funda el Centro de Investigacin de Palo Alto (PARC - Palo Alto Research Center). Alan
Kay fue uno de los miembros principales del centro, desarrollando prototipos de estaciones de trabajo en
red, usando el lenguaje de programacin SMALLTALK. Estas invenciones fueron posteriormente
comercializadas por APPLE en el APPLE MACINTOSH.
Alan Kay se dedica a construir su DINABOOK (Hw y Sw). Hardware, pequeo, autnomo, con
almacenamiento y capacidad grfica + mouse, diseando entonces el concepto de interfaz grfica tal cual lo
conocemos en la actualidad. En forma conjunta hubo que generar un proyecto de Software que deba ser
intuitivo, fcil de usar y de entender. Este proceso fue liderado por Adele Goldberg, tomando como idea a
las propuestas de Simula y surge SMALLTAK (1972).
Ao 1976: Se entrega la 1er versin a Empresas, Universidades y Laboratorios. Lo importante es que el
mismo responde e implementa las ideas de Alan Kay. Smalltalk es el nico ambiente de objetos puro que ha
tenido difusin comercial
Ao 1980: Xerox PARC da por finalizado el proyecto. En este punto comienza a haber distintas
corrientes e implementaciones del POO. Adele Goldberg funda una empresa que comercializa a SMALLTALK
como entorno de desarrollo para grandes empresas.
Ao 1984: aparece SMALLTALK-V que fue pensado para utilizarse en una arquitectura de PC-IBM bsica.
Ao 1986 - 1990: Aparece C++ es un diseado a por Bjarne Stroustrup. La intencin de su creacin fue el
extender al exitoso Lenguaje de programacin C, con mecanismos que permitan la manipulacin de
Objetos. En ese sentido, desde el punto de vista de los Lenguajes orientados a Objetos, el C++ es un lenguaje
hbrido. Esta idea no fue considerada como muy brillante, pero este nuevo lenguaje tuvo un xito rotundo.
James Rumbaugh, propone la metodologa OMT (Object Modeling Technique) que es una de las
metodologas de anlisis y diseo orientadas a objetos, ms maduras y eficientes que existen en la
actualidad. La gran virtud que aporta esta metodologa es su carcter de abierta (no propietaria), que le
permite ser de dominio pblico.
Bertrand Meyer: Hace un enfoque diferente de la Orientacin a Objetos el que se soporta desde la
Teora de la Computacin, desarrollando EIFFEL. El cul es ms OO que C++ pero mucho menos que
SMALLTALK, el cul es admitido en sus principios constitutivos pero que aporta e incorpora mocho de
Ingeniera de Software, permitiendo construir software de alta calidad y seguro. No tiene gran aceptacin en
software comercial.
Brad Cox desarrolla Objective-C ( Mas cerca de Samalltalk que C). Es un lenguaje de programacin
orientado a objetos creado como un superconjunto de C para que implementase un modelo de objetos
parecido al de Smalltalk. Originalmente fue creado por Brad Cox y la corporacin StepStone en 1980. En
1988 fue adoptado como lenguaje de programacin de NEXTSTEP
Luego aparecen los metodlogos (Jacobson, Booch, Cood, Jourdon, Palmer, Rebeca Wirsf-Brook) y ms
tarde UML (Jacobson, Rumbaugh, Booch)
Ao 1997: Alan Kay ya en Disney colabor en la creacin del proyecto SQUEAK, el entorno OO, basado
en SMALLTALK para la creacin y experimentacin multimedia. Trabaja en forma conjunta con Ian Ingalls
(Arquitecto de la Mquina virtual SMALLTALK). SQUEAK es una mquina virtual SMALLTALK construida en
SMALLTALK. Como aspecto sobresaliente es que: Es un proyecto abierto y corre en todas las plataformas de
Hardware existente.

En marzo de 2008 comenz el proyecto Pharo, como una bifurcacin de Squeak 3.9. La primera versin
beta 1.0 fue liberada el 31 de Julio de 2009.
Actualidad: Recientemente Alan Kay, comenz a trabajar en el Proyecto Croquet, que busca ofrecer
un entorno 3D en red de cdigo libre para el desarrollo colaborativo.
La programacin orientada a objetos o POO (OOP segn sus siglas en ingls) es un paradigma de
programacin que usa objetos y sus interacciones, para disear aplicaciones y programas informticos. Est
basado en varias tcnicas, incluyendo herencia, abstraccin, polimorfismo y encapsulamiento. Su uso se
populariz a principios de la dcada de los aos 1990. En la actualidad, existe variedad de lenguajes de
programacin que soportan la orientacin a objetos.
2. PARADIGMA ORIENTADO A OBJETOS

En este paradigma, se puede partir de una definicin bsica que caracteriza al Paradigma: Un programa
es un conjunto de Objetos que colaboran entre s envindose mensajes.
PARADIGMA ORIENTADO A OBJETOS OBJETOS + MENSAJE = PROGRAMA
Pensar en programar como una entidad viva en la computadora, en donde los objetos evolucionan,
modificndose a s mismos de acuerdo a ciertos factores.
2.1 CONCEPTOS INTRODUCTORIOS

A continuacin, se describen un conjunto bsico de definiciones, de manera de comprender el enfoque
adoptado para el desarrollo del presente documento.
Programar con Orientacin a Objetos: Para construir un programa usando orientacin a objetos, el primer
concepto con el que voy a trabajar, y lo primero que va a saltar a la vista, es el del trmino de objeto.
Rpidamente, un objeto es una unidad de software de la cual lo que me importa es: qu le puedo preguntar
y/o pedir, y a qu otros objetos conoce. Los objetos responden a los pedidos interactuando con los otros
objetos que conoce, y as se va armando una aplicacin.
O sea, en vez de enfocarse en rutinas, variables, funciones, punteros, etc.; nos introduce a pensar en
objetos: con qu objetos voy a interactuar, sus caractersticas, qu les voy a poder preguntar, con qu otros
objetos tienen que interactuar estos, y otras cosas que surgen a partir de estas.
De hecho, el resultado de la tarea va a ser la descripcin de estos objetos, cmo se conocen entre ellos, y
cmo interactan.
Para resumir, un objeto posee caractersticas y comportamiento:

Caractersticas
Comportamiento
Y se relaciona con otros objetos a travs de mensajes:
Puede tener parmetros (objetos)
Pedido
Invocacin de mtodo
Objeto A Objeto B
(objeto emisor) (objeto receptor)
Respuesta
Ejecucin del mtodo como respuesta
Retorna un resultado (objeto)

Puede ser vacio o no
2.2 CARACTERSTICAS DE LA POO
Existe un acuerdo acerca de qu caractersticas contempla la "orientacin a objetos", las caractersticas

siguientes son las ms importantes:
Abstraccin: denota las caractersticas esenciales de un objeto, donde se capturan sus

comportamientos. Cada objeto en el sistema sirve como modelo de un "agente" abstracto que
puede realizar trabajo, informar y cambiar su estado, y "comunicarse" con otros objetos en el
sistema sin revelar cmo se implementan estas caractersticas. Los procesos, las funciones o los
mtodos pueden tambin ser abstrados y cuando lo estn, una variedad de tcnicas son
requeridas para ampliar una abstraccin. El proceso de abstraccin permite seleccionar las
caractersticas relevantes dentro de un conjunto e identificar comportamientos comunes para

definir nuevos tipos de entidades en el mundo real. La abstraccin es clave en el proceso de anlisis
y diseo orientado a objetos, ya que mediante ella podemos llegar a armar un conjunto de clases
que permitan modelar la realidad o el problema que se quiere atacar.
Por ejemplo grficamente:
Persona Caractersticas generales Caractersticas esenciales

de todas las personas segn el dominio considerado
dni, nombre (identificacin) Persona en la universidad Persona en una agencia

telfono, domicilio, etc. (contacto) dni, nombre de Modelos
altura, peso, etc. (contextura fsica) telfono, domicilio, etc. dni, nombre
Estudios secundario (formacin) Estudios secundario, etc. telfono, domicilio, etc.
altura, peso, etc.
Modularidad: Se denomina Modularidad a la propiedad que permite subdividir una aplicacin en

partes ms pequeas (llamadas mdulos), cada una de las cuales debe ser tan independiente como
sea posible de la aplicacin en s y de las restantes partes. Estos mdulos se pueden compilar por
separado, pero tienen conexiones con otros mdulos. Al igual que la encapsulacin, los lenguajes
soportan la Modularidad de diversas formas.
Encapsulamiento: Significa reunir a todos los elementos que pueden considerarse pertenecientes a
una misma entidad, al mismo nivel de abstraccin. Esto permite aumentar la cohesin de los
componentes del sistema. Es comn que se confunda este concepto con el principio de ocultacin,
principalmente porque se suelen emplear conjuntamente.
Principio de ocultacin: Cada objeto est aislado del exterior, es un mdulo natural, y cada tipo de
objeto expone una interfaz (protocolo) a otros objetos que especfica cmo pueden interactuar con
los objetos de la clase. El aislamiento protege a las propiedades de un objeto contra su
modificacin por quien no tenga derecho a acceder a ellas, solamente los propios mtodos internos
del objeto pueden acceder a su estado. Esto asegura que otros objetos no pueden cambiar el
estado interno de un objeto de maneras inesperadas, eliminando efectos secundarios e
interacciones inesperadas. Algunos lenguajes relajan esto, permitiendo un acceso directo a los
datos internos del objeto de una manera controlada y limitando el grado de abstraccin.

Objeto externo
Miembros
Privados
Interfaz pblica (Protocolo)
Cohesin y acoplamiento: la cohesin mide las responsabilidades asignadas a cada objeto,

mientras que el acoplamiento mide las relaciones entre los objetos. En el Modelado Orientado a
Objetos, lo que se busca es tener ALTA cohesin (cada objeto se responsabilice por una sola cosa) y
BAJO Acoplamiento (Poca o nula interdependencia)
Herencia: las clases no estn aisladas, sino que se relacionan entre s, formando una jerarqua de
clasificacin. Los objetos heredan las propiedades y el comportamiento de todas las clases a las que
pertenecen. La herencia organiza y facilita el polimorfismo y el encapsulamiento permitiendo a los
objetos ser definidos y creados como tipos especializados de objetos preexistentes. Estos pueden
compartir (y extender) su comportamiento sin tener que volver a implementarlo. Esto suele
hacerse habitualmente agrupando los objetos en clases y estas en rboles o enrejados que reflejan
un comportamiento comn. Cuando un objeto hereda de ms de una clase se dice que hay
herencia mltiple.
Polimorfismo: comportamientos diferentes, asociados a objetos distintos, pueden compartir el

mismo nombre, al llamarlos por ese nombre se utilizar el comportamiento correspondiente al
objeto que se est usando. O dicho de otro modo, las referencias y las colecciones de objetos
pueden contener objetos de diferentes tipos, y la invocacin de un comportamiento en una
referencia producir el comportamiento correcto para el tipo real del objeto referenciado. Cuando
esto ocurre en "tiempo de ejecucin", esta ltima caracterstica se llama asignacin tarda o
asignacin dinmica. Algunos lenguajes proporcionan medios ms estticos (en "tiempo de
compilacin") de polimorfismo, tales como las plantillas y la sobrecarga de operadores de C++.
Recoleccin de basura: la recoleccin de basura o garbage collector es la tcnica por la cual el

entorno de objetos se encarga de destruir automticamente, y por tanto desvincular la memoria
asociada, los objetos que hayan quedado sin ninguna referencia a ellos. Esto significa que el
programador no debe preocuparse por la asignacin o liberacin de memoria, ya que el entorno la
asignar al crear un nuevo objeto y la liberar cuando nadie lo est usando. En la mayora de los
lenguajes hbridos que se extendieron para soportar el Paradigma de Programacin Orientada a
Objetos como C++ u Object Pascal, esta caracterstica no existe y la memoria debe desasignarse
manualmente.

2.3 OBJETO
Es una abstraccin que utilizaremos como representacin computacional de una entidad de la realidad
tiene unas propiedades particulares (atributos) y una forma de operar con ellas (mtodos).
Un objeto representa alguna entidad o ente de la vida real. Puede representar:
Lo que est vivo: personas, animales, plantas, clulas, pulmones;
Las organizaciones: un equipo de ftbol, un ministerio, un grupo de investigacin, un club, una

ctedra, una empresa, un ecosistema;
Cosas en lo que se toca es slo un soporte: un libro, una pelcula, un artculo en una revista, un
contrato, una ley;
Cosas bien abstractas: un nmero, un conjunto, un nombre, una letra, una funcin matemtica
OBSERVADOR
Para comprender mejor el concepto de objeto emisor y receptor y porque del envo de mensajes,
introduciremos el concepto de Observador.
Un objeto es cualquier ente o entidad que tiene alguna utilidad/significado/sentido para el que tiene
que trabajar con l, esto quiere decir que nos va a interesar quien va a trabajar/interactuar con el objeto,
ese alguien por ahora lo vamos a llamar observador y vamos a suponer que los observadores son
personas.
Distintos observadores van a ver distintos objetos. Es probable que en la visin de un carpintero que
describe su negocio aparezcan sillas y no aves, mientras que en la de un ornitlogo (bilogo especializado en
aves) lo ms probable es que pase lo contrario.
Un observador tampoco es alguien en abstracto, es alguien haciendo algo/en un rol; los objetos que va
a ver son aquellos con los que necesita interactuar de alguna forma para poder cumplir su rol. Esto se logra,
asumiendo el Rol de analista y produciendo un recorte de la realidad.
Armar modelos y trabajar en base a ellos es la forma que encontramos las personas para poder pensar
acerca del mundo complejo en el que vivimos
Por lo tanto un Objeto ser una representacin esencial de entes de la realidad, el cul adems tendr
definido ciertos comportamientos, que sern requeridos por otros objetos que interacten con l.

REALIDAD
DOMINIO
ENTE
OBSERVADOR
Visin Aristotlica -> El Observador
recorta la realidad para observar el
Dominio como un observador
Contrapartida computacional que representa externo
(Modela esencialmente) un ente del dominio del
Problema -> OBJETO
FIG. 5.1. PROCESO DE ABSTRACCIN EN POO
En resumen, no podemos definir Objeto si no hablamos de un Sujeto. No podemos hablar de un

Observado si no hay un Observador. No se puede definir un trmino sin el otro.
Entonces, siempre que hablamos de un Objeto estamos diciendo tambin que ese objeto existe
porque hay alguien que lo observa, alguien que reflexiona sobre su existencia.
Si recordamos que un programa orientado a objetos es un conjunto de Objetos que colaboran entre
s envindose mensajes, podremos inferir que existirn algunos objetos que sern observados y otros
observadores.
Ahora la figura del observador cambi, ya no es una persona que lo modela, sino un objeto que es
capaz de interactuar con otro, por lo tanto habr que analizar en el conjunto de objetos cuales son los que
interviene.

2.4 LOS OBJETOS EN EL PARADIGMA ORIENTADO A OBJETOS

Un objeto dentro de Paradigma Orientado a Objetos debe poseer:
Abstraccin: Representacin esencial de la Realidad.
Identidad: Todo objeto es igual a s mismo, y solo a s mismo.
Comportamiento: Descripto a travs de un protocolo
Capacidad de inspeccin
2.4.1 ABSTRACCIN
Un Objeto es una abstraccin que utilizamos como una representacin computacional de entes de la
realidad, el cul responde a dos caractersticas:
Esenciales: aquellas que hacen que el ente sea lo que es, que no pueden cambiar, que si falta algo
ya no es lo que era.
Accidentales: Un ente puede poseerlos, pero si no los tuviera o se lo cambiara, no dejara de ser lo
que es. (color, tamao, etc.)
Representacin esencial
Es un proceso de abstraccin, el cual consiste en separar estas dos caractersticas claramente,

describiendo la esencia del ente.
Un Objeto es una abstraccin que utilizamos como representacin computacional de entes de la realidad.
Una abstraccin no simplifica la realidad, sino que modela sus caractersticas esenciales representadas a
travs de su comportamiento
Los objetos en la orientacin a objetos son las representaciones computacionales de los entes con los
que vamos a interactuar.
2.4.2 IDENTIDAD
La identidad es una caracterstica intrnseca de los objetos. Un buen nombre cierra una idea. Identidad
es diferente a igualdad. Para verificar una igualdad se deben comparar dos objetos y con un criterio
definido.
2.4.3 COMPORTAMIENTO
Un objeto tambin queda representado por su comportamiento, el cual estar definido por el conjunto
de mensajes que el objeto pueda responder (para que sirve, como utilizarlo, etc.). Este conjunto de
mensajes que el objeto puede responder se lo denomina Protocolo.

m1
m2
m3
FIG. 5.2. REPRESENTACIN GRFICA DE UN OBJETO
Los mensajes, son el vocabulario que el objeto es capaz de entender, es lo que hay que saber para
poder comunicarse con l.
Protocolo
Conjunto de mensajes que un objeto puede responder. O planteado desde otro punto de vista las reglas
a cumplir para poder comunicarse con un objeto.
A travs del protocolo de un objeto, definimos la utilidad del ente que estamos representando, o sea su
esencia.
extraer: unMontoDeDinero
depositar: unMontoDeDinero
consultarSaldo:
FIG. 5.3 REPRESENTACIN DE UN OBJETO CON SU PROTOCOLO
El vocabulario que entiende el objeto (Su Protocolo) es el LENGUAJE DEL DOMINIO, y por lo tanto no
debe estar expresado en trminos de computacin sino del dominio.
El protocolo es invariante; si he comprendido la realidad y la he modelado como comportamiento de un

ente a travs de mensajes, se constituye en un punto invariante del modelo que representa mi programa.
La especificacin del protocolo de un objeto es una decisin de anlisis, jams de diseo.
2.4.4 CAPACIDAD DE INSPECCIN

Poder ver en todo momento quines son sus colaboradores, y en un determinado instante
eventualmente cambirselo.

2.5 COLABORACIONES: MENSAJE Y MTODO

Qu hace un objeto cuando recibe un mensaje? - Lo nico que puede hacer es enviar un mensaje a
otro objeto, eso se llama colaborar.
La colaboracin se produce cuando los objetos se envan mensajes.
Un mtodo se asocia a un mensaje que el objeto puede responder.
MENSAJE
MTODO
m1
m2
m3
FIG. 5.4. MTODO Y MENSAJE
MTODOS: conjunto de colaboraciones que un objeto tendr con otros.
La idea esencial, es que el mtodo le indica al objeto que hacer para cada mensaje que puede recibir.
Cmo expreso una colaboracin?
5.5. FORMA GRFICA DE EXPRESAR UNA COLABORACIN
Forma grfica de representar colaboracin

Y cmo hace un observador para usar un objeto?
Le enva mensajes. Un mensaje es cada una de las formas posibles de interactuar con un objeto. Para
pedirle algo a un objeto, lo que hago es enviarle un mensaje. Cada objeto entiende un conjunto acotado de
mensajes (Protocolo)

S es posible (y altamente deseable, como veremos mas adelante) que haya muchos objetos capaces de
entender el mismo mensaje, incluso aunque sean bastante distintos entre s. Eso permite ir armando un
vocabulario mediante el cual uno interacta con los objetos.
En cada accin de envo de mensaje:
hay un emisor
hay un receptor
hay un nombre, que identifica el mensaje que estoy enviando entre todos los que entiende el
receptor.
Como estamos hablando de software, un nombre toma la forma de un identificador. En la jerga de

Smalltalk, a este nombre se lo llama selector.
Pasamos en limpio las definiciones prolijas de mensaje y envo de mensaje
mensaje: cada una de las formas posibles de interactuar con un objeto, que se identifica por un nombre y
puede llevar parmetros.
envo de mensaje: cada interaccin con un objeto. Tiene: emisor, receptor, selector, eventualmente
parmetros (que son objetos), y eventualmente un resultado (que es otro objeto).
Objeto A Identificador o selector Objeto B

Puede tener parmetros (objetos)
Pedido
Invocacin de mtodo
Objeto A Objeto B
Respuesta
Ejecucin del mtodo como respuesta
Retorna un resultado (objeto)

Puede ser vacio o no

Por ejemplo, en Smalltalk para enviarle un mensaje a un objeto es:
{objeto destino mensaje.}
Donde objeto destino es el nombre que le di al objeto en el entorno en donde estoy escribiendo el
cdigo. Y mensaje ser el nombre del selector del mensaje propiamente dicho.
Para poder especificar un MTODO debo pedir identificar con mis colaboradores.
Podemos pensar en dos tipos de colaboradores:
Habituales (internos)
Eventuales (externos)
Un colaborador externo se va a definir especialmente para alguno de los mensajes.
Colaboradores internos
m1: c externo
C1 m2
C2 m3
mX
FIG. 5.6. FORMA GRFICA DE EXPRESAR UNA COLABORACIN: EXTERNAS E INTERNAS
Lo que yo conozco de mis colaboradores es su nombre (como yo me refiero a ellos, en general un rol);
El Objeto mX puede colaborar con c1 y c2 (siempre) y con c externo (siempre que responda a m1).
El protocolo del objeto es PBLICO, y la definicin de mtodos y colaboradores es PRIVADA, es interna
al objeto. Esta parte interna es la implementacin del objeto, y est encapsulada. Puede ser cambiada en
cualquier momento mientras se mantenga invariante su protocolo pblico. Esto es lo que se conoce como
ENCAPSULAMIENTO.
Cuando un objeto enva un mensaje a otro, SIEMPRE recibe como respuesta un OBJETO. En SmallTalk
ampliamos el concepto de colaboracin.

Enva mensajes, recibe objetos

Objeto B
Objeto A
mensaje m1: c
Objeto nulo (nil)
Puede ser:
objeto
Objeto no nulo
FIG. 5.7. RESPUESTA A MENSAJES
Aspecto sintctico
{objeto mensaje. } Colaboracin

^ devolver (objetos)
:= asignacin (a un nombre en determinado objeto)
Un objeto conoce a otro cuando puede hacer una asignacin de un nombre a un objeto.
El mtodo es donde se escribe el cdigo que alguien deber programar, donde programar quiere
decir: indicar qu mensajes va a entender el objeto (su protocolo), y para cada uno de estos mensajes
(selectores) existe un Mtodo donde se escribe el cdigo que se va a ejecutar cuando el Objeto reciba este
Mensaje.
O sea: fue un programador el que decidi que el Objeto va a entender un determinado mensaje y
escribi el cdigo asociado a ese mensaje. Ese cdigo es el que se va a ejecutar cuando se invoque el
mensaje.
La seccin de cdigo que se asocia a un mensaje se llama mtodo. Un mtodo tiene un nombre, que es
el del mensaje correspondiente; y un cuerpo, que es el cdigo que se ejecuta.
Un detalle: en la jerga de objetos, se usa mucho el trmino evaluar en vez de ejecutar.
Con todo esto, pasamos la definicin en limpio junto con un corolario
Mtodo: seccin de cdigo que se evala cuando un objeto recibe un mensaje. Se asocia al mensaje
mediante su nombre.
Corolario: casi todo el cdigo que escribamos va a estar en mtodos, que definen qu mensajes
entiende cada objeto, y determina qu hacer cuando los recibe.

La nica forma que tengo de interactuar con un objeto es envindole mensajes. Los nombres de
mensaje con un parmetro terminan con dos puntos, eso indica que atrs viene un parmetro; los dos
puntos forman parte del nombre.
2.6 COLABORADORES INTERNOS / ESTADO INTERNO

El conjunto de variables que va a contener un objeto se llama Colaborador Interno o estado interno.
Una variable es el nombre de un objeto, entonces lo que me estoy guardando en realidad es el objeto
que est nombrando cada variable. Esto va a ir quedando claro a medida que avancemos. Por ahora alcanza
que quede claro que una variable no es un nombre de una seccin de memoria.
En resumen, el estado interno de un objeto: es el conjunto de variables que contiene, y se define al
programar el Objeto.
En la convencin Smalltalk, los selectores que piden informacin tienen el nombre de lo que piden sin
ningn agregado; en principio conviene adherir a las convenciones del lenguaje/entorno que usamos.
Adems, se escribe menos y el cdigo queda ms legible.
Una caracterstica interesante de muchos entornos Smalltalk es que puedo hacer que los objetos que
creo queden vivos en un entorno que a su vez vive dentro del Smalltalk. Puedo crear objetos y despus
interactuar con ellos cuando quiero.
2.7 ENCAPSULAMIENTO
Se puede cambiar la implementacin de un objeto, y el usuario de ese objeto no se enter.
Cmo logramos esto? Porque no cambiamos el protocolo del objeto, o sea el conjunto de mensajes
que entiende; y lo nico que ve el usuario del objeto son los mensajes que entiende, no ve cmo el objeto
lo implementa adentro suyo (mtodos y estado interno).
Trabajando en Smalltalk, el Observador no tiene forma de conocer la forma del estado interno de un
objeto, ni sus valores; y tampoco puede acceder a detalles sobre cul es la implementacin que est detrs
de los mensajes que le enva. Lo nico que conoce es el comportamiento que el objeto exhibe (Protocolo);
siendo lo nico que necesita conocer para poder interactuar con el objeto.
Esta idea de que un observador no ve todos los aspectos de un objeto sino solamente aquellos que le
sirven para interactuar con l se llama encapsulamiento; la idea del nombre es que los aspectos internos del
objeto se encapsulan de forma tal que los observadores no pueden verlos.
La idea de encapsulamiento tambin puede observarse en la relacin que nosotros tenemos con l.
Al encapsular un objeto, estoy al mismo tiempo acotando y explicitando (haciendo explcitas) las formas
posibles de interaccin; slo se puede interactuar con un objeto mediante el comportamiento que exhibe.
Esto nos da varias ventajas que pasamos a comentar.
Como las formas de interaccin son acotadas y las maneja quien programa el objeto, se hace ms
sencillo probar si un objeto se comporta correctamente.
Tambin resulta ms controlable cualquier cambio que haga en la implementacin, siempre que
respete el conjunto de mensajes definidos (protocolo)

A su vez, como es ms sencillo probar si un objeto funciona bien o no, se simplifica darnos cuenta si
con un cambio de implementacin rompemos algo.
Otro efecto es que al explicitar el comportamiento lo estamos documentando, entonces para alguien
que quiera usar el objeto que construimos es fcil saber qu usos le puede dar y cmo usarlo. De alguna
forma el comportamiento que exhibe el objeto forma un manual de uso.
Eso se potencia si seguimos la sabia poltica de poner abajo del nombre de cada mtodo un comentario
que explica qu se puede esperar, como lo hicimos en los ejemplos de cdigo. Es una convencin de
Smalltalk que definitivamente conviene respetar en el cdigo que escribamos nosotros.
En Smalltalk no hay forma de que un usuario del objeto acceda a la variable (Colaborador Interno),
entonces es necesario. Adems, el definir el mensaje permite hacer cambios de implementacin que resulta
lo ms conveniente.
Resumiendo encapsulamiento: quien usa un objeto slo ve lo que necesita para poder interactuar con
l, que el comportamiento que exhibe. Los detalles internos quedan encapsulados en el objeto. Y as quedan
acotadas y explicitadas las formas posibles de interactuar con un objeto.
2.8 INTERPRETACIN DE LAS COLABORACIONES: COLABORADORES EXTERNOS

Volvemos a repasar qu es una colaboracin?
Para que la colaboracin sea posible, el objeto de la

c izquierda debe conocer al objeto de la derecha
m
( )
Esto significa que el de la izquieda pone un nombre y, por ejemplo, asigna la identificacin de algn objeto.
Podemos pensar la colaboracin como un canal por el cual enva colaboradores y recibe un objeto como
resultado. En este momento termina la colaboracin y se cierra el canal (esto es una metfora, los objetos
no viajan de un lado al otro, sino que se manejan referencias, viajan las identidades de los objetos).
Relacin de conocimiento
Si envo un colaborador externo, es porque el destino es quien colabora con l. Si recibo un objeto, es
porque quiero colaborar con l (enviarle mensajes).
El receptor del mensaje no tiene idea de quien le enva el mensaje (no puede dialogar, no es cliente
servidor). Esto es bueno porque est totalmente desacoplado; los objetos estn preparados para responder
a cualquiera que le enve le mensaje.
El emisor, asume que existe un objeto con capacidad de responder al mensaje que envo.

El nico error que podra ocurrir es que un objeto reciba un mensaje que no entiende:
a) Mensaje equivocado al objeto correcto
b) Mensaje correcto al objeto equivocado.
Esto acota y facilita el manejo/descubrimiento de errores.
La colaboracin -> un contrato entre emisor y receptor. El emisor debe escribir bien el mensaje y
enviar un colaborador externo que sepa hacer cosas que requiere el receptor. Por su lado el receptor debe
devolver un objeto que sepa hacer cosas que requiere el emisor.
TIPO, es el conjunto de mensajes que un objeto debe saber responder.

COLABORACIN
(el objeto e debe conformar con el tipo T1)
El tipo es comportamiento esperado. Tipo es en definitiva un protocolo definido en un contexto.
- Programa: aquello que se est ejecutando
Observador que identifica entes de la

Ente real R realidad (aprendizaje)
D
Gap Semntico
Representacin del
FIG. 5.8 MODELADO EN POO
ente de la realidad
2.9 POLIMORFISMO
Dos o ms objetos son polimrficos respecto de un conjunto de mensajes si todos ellos pueden
responder de manera semnticamente equivalente, an si su implementacin es distinta.

Se dice que un objeto es polimrfico con otro cuando un determinado observador no puede
distinguirlos entre si. Como en Smalltalk no se puede observar un objeto ms que envindole mensajes, un
objeto es polimrfico con otro cuando un determinado observador les enva un conjunto de mensajes y
ambos responden de manera indistinguible.
De alguna manera los objetos polimrficos son intercambiables.
Tipo= {m1, m2, ...} conjunto de mensajes con un nombre (es un protocolo, no un tipo tradicional).
: el objeto e conforma con el protocolo T1 (puede responder los mensajes elementos de T1). La
interface de java hace algo parecido.
Para que un Lenguaje, pueda interpretar el Polimorfismo, debe necesariamente poseer binding
dinmico o tardo (Ligadura en tiempo de ejecucin).
Los objetos polimrficos son intercambiables. Disponiendo as de una enorme flexibilidad en el

desarrollo. El acoplamiento entre objetos se hace a travs del protocolo, o sea acoplamiento por mensajes.
2.10 MENSAJES A M MISMO self

Para explicar este concepto, lo haremos a travs de un ejemplo. Tenemos ahora un objeto que
representa a un cliente de un banco tal como lo ve el oficial de crdito.
El cliente entiende dos mensajes montoTopeDescubierto y montoCreditoAutomatico, que

devuelven hasta cunto el cliente puede girar en descubierto, y hasta cunto se le puede dar de crdito sin
necesidad de aprobacin. Los dos mtodos correspondientes obtienen los valores haciendo cuentas
complicadsimas.
Ahora el oficial nos pide a nosotros, que programamos al cliente, que le agreguemos la capacidad
de entender el mensaje montoTotalCredito, que es la suma de los dos anteriores.
Cmo escribo el mtodo, qu tengo que poner? Veamos.
Cuando escribo un mtodo, estoy parado en el objeto que va a recibir el mensaje que estoy
habilitando, en este caso el cliente.
Si soy el cliente y me preguntan mi montoTotalCredito, lo que tengo que devolver es la suma entre
mi montoTopeDescubierto y mi montoCreditoAutomatico.
Estos dos montos cmo los obtengo? Envindome los dos mensajes a m mismo, para no repetir
las cuentas que estn en esos dos mtodos.
Y cmo hago para enviarme mensajes a m mismo? Fcil, usando la palabra clave self que incluye
el Smalltalk. Self es exactamente yo mismo, enviarle un mensaje a self es envirmelo a m, donde

yo soy el objeto que recibi el mensaje por el que se dispar el mtodo.
Entonces queda
montoTotalCredito
"El monto total de credito que me asignaron"
^self montoTopeDescubierto + self montoCreditoAutomatico
La definicin formal:
Self: en un mtodo, referencia al objeto que recibi el mensaje correspondiente, que sirve para enviarme
mensajes a m mismo
2.11 DESTRUCCIN, CREACIN Y REPRESENTACIN DEL CONOCIMIENTO
DESTRUCCION
Objeto: Esta en algn

lugar en la RAM
MIOBJ
Ventana Cualquier
C.A Objeto
Un nmero
4
2 1 3
1 2 3
Analicemos a MIOBJ de la figura anterior - Nadie lo referencia, nadie lo conoce, entonces, nadie lo
puede alcanzar... Ok Quin lo destruye?
Alternativas:

a) que algn otro objeto lo destruye
b) que el mismo se suicide
Tengamos en cuenta que entre 1, 2 y 3 no hay conciencia de que comparten la caracterstica de

tener relacin con MIOBJ.
Entonces no le puedo decir que 1 mate a MIOBJ pues 1 no sabe que existen 2 y 3.
Tengo que tener un objeto que sepa que un MIOBJ se convirti en basura. Entonces aparece la
figura del garbage colector (recolector de basura).
Smalltalk, Java, Python, entre otros, tienen un Garbage Collector que automticamente libera
memoria, el mismo se encarga de destruir los objetos que no estn referenciados, es decir, cuando un
objeto deja de estar referenciado es desalojado y liberada la memoria.
CREACIN
Analizaramos dos diferentes posibilidades:
1) Que lo cree otro objeto
crear
Creador de C.A.
Colaboradores Depositar
internos Extraer
Saldo
Crear: Una Caja de Ahorro
El creador de CA sabe. Tiene el conocimiento de cmo crear CA. Es una fbrica de CA. Y le mando
el simple mensaje CREAR.
El conocimiento interno de un objeto es el conjunto de colaboradores internos que l tiene.
2) Que el Objeto sea Clonado

Suponiendo que tengo una CA le mando el mensaje clone y l hace una copia igual pero con identidad
diferente. En el momento de nacer el nuevo objeto era igual al que estoy clonando, luego ya est en
condiciones y sabe como recibir mensajes y hacer movimientos.
Entonces puedo hacer un clon bsico y luego le agregamos comportamientos para que a partir de
un objeto bsico pase a ser una CA (o lo que sea)
El creador de CA no sabe COMO crear un CA sino que sabe QUE es un CA. O sea que le puedo
preguntar cul es el protocolo de esa CA? y adems le puedo ampliar ese conocimiento y decirle que
ahora las CA puedan informar sus movimientos.
Este objeto creador REPRESENTA al CONOCIMIENTO o el CONCEPTO DE CA.
crear
Caja de Ahorro (c/

mayscula)
Hemos dado un salto de abstraccin. No slo representan entes de la realidad sino conceptos de la
realidad.
crear
Caja de Ahorro
Este sabe del concepto de lo

que es una CA, todas las CA
Una Caja al recibir un mensaje saldo le puede pedir a Caja de Ahorro que me diga cmo responder
al mensaje SALDO. Ergo Caja de Ahorro es un REPOSITORIO de todos los comportamientos de todos los
mtodos de todos los objetos usados a partir del CONCEPTO que posee Caja de Ahorro
Este ltimo, el Clonado o POO basado en prototipos podra tener CA con comportamiento distinto,
en cambio en el claseado todas las CA tienen el mismo comportamiento.
En el clonado puedo conocer un conocimiento inicial y luego voy expresando como aumento mi
conocimiento de manera inductiva. Si aparece alguno nuevo, lo copio y le pongo las diferencias.

En la implementacin por Clases puedo abstraer y definir la clase con las todas las caractersticas
comunes.
REPRESENTACIN DEL CONOCIMIENTO
El conocimiento est en los objetos y el protocolo que sabe responder. Desde ahora y en lo que se
basa la potencialidad del paradigma es que puedo Inspeccionar un objeto, ver sus mtodos y ver sus
colaboradores internos. En este contexto el del POO puro, el concepto de Programar ser INSEPCCIONAR
CLASES (objetos que representan clases.)
2.12 CLASES
Hasta ahora hemos trabajado con objetos que creamos y tienen su propio comportamiento, el cul
es distinto al de todos los dems.
Es hora de hacernos algunas preguntas Qu pasa si quiero tener objetos que se comporten de la
misma manera? Tengo que codificar lo mismo de nuevo cada vez?
Como ya hemos vistos en creacin de objetos, la forma ms habitual (aunque no la nica Existen
dos formas: clases y prototipos) de resolver ese problema es a partir del concepto de clase. En lugar de
definir cada objeto por separado, defino una clase con las caractersticas que sern comunes a los objetos, y
luego voy a crear los objetos a partir de esta clase.
2.12.1 DEFINICIN DE COMPORTAMIENTO COMN

La idea de clase nos permite definir un molde para luego a partir de ah crear muchos objetos que
se comporten de la misma manera. Ahora, qu es lo que compartiran todos los objetos?, y qu es lo que
no queremos que compartan?
Lo primero en que pensamos es que todos los objetos compartan los mismos mtodos.
Por otro lado, cada objeto tendr la necesidad de poder representar un determinado estado, el cual
se reflejar de acuerdo a su estado interno.
.Hasta ac vemos que la clase me estara definiendo dos cosas:
El comportamiento comn (mtodos) a todos los objetos
El conjunto de variables que tiene que tener cada objeto.
2.12.2 CMO SE CREAN OBJETOS

Hasta aqu en ningn momento nos ocupamos del problema de la creacin de los objetos; La
aparicin del concepto de clase nos permite describir con precisin cundo y cmo se crean objetos
El hecho de crear la clase y definir sus variables y mtodos no crea ningn objeto. Una clase ser el
molde a partir del cual se crearn objetos a instancia de la clase.
ObjetoCreado := NombreClase new
Esto me devolver un objeto nuevo, de la clase NombreClase. Decimos que este nuevo objeto es
instancia de la clase, ya que fue creado utilizando a la clase como molde.
2.12.3 CLASES E INSTANCIAS

Volvamos un poco a la palabra instancia. Dijimos que el objeto creado por la sentencia:
NombreClase new
es una instancia de la clase NombreClase, y que en realidad es un objeto. La palabra instancia se usa
cuando queremos remarcar la relacin entre los objetos y las clases,
Terminemos esta seccin bajando las definiciones de clase e instancia.
clase: molde a partir del cual se crean los objetos; y en el que se definen los mtodos y el conjunto de
variables que tendrn los objetos que se creen a partir del molde
Instancia: cada objeto es instancia de la clase que se us como molde para crearlo. Cada objeto es instancia
de exactamente una clase.
Las instancias de una clase entienden, y tienen la capacidad de responder los mensajes para los
cuales hay mtodos definidos en la clase.
2.12.4 FORMA DEL CDIGO SMALLTALK

Con lo que vimos sobre clases e instancias, ahora s podemos escribir cdigo Smalltalk usando las
herramientas standard, e interactuar con los objetos que quedan definidos.
Se definen clases.
Los mtodos se escriben en las clases, y las variables se definen para las clases. O sea, todo
el cdigo est en las clases, excepto el que ponemos en ventanas de interaccin.

Los objetos se crean instancindolos, para lo cual se usa la sentencia: Clase new.
Los objetos no tienen nombre propio.
2.13 RELACIONES ENTRE CLASES

Ya definido el concepto de Clase, es necesario explicar como se pueden interrelacionar dos o ms
clases (cada una con caractersticas y objetivos diferentes).
Segn G. Booch [Booch, 94] existen tres clases bsicas de relaciones:
Asociacin (conexin entre clases)

Agregacin / Composicin (relaciones de pertenencia)
Generalizacin/especializacin (relaciones de herencia)
2.13.1 ASOCIACIN
Es una relacin entre clases. Diremos que dos (o ms) clases tiene una relacin de asociacin cuando
una de ellas tenga que requerir o utilizar alguno de los servicios (es decir, acceder a alguna de las
propiedades o mtodos) de las otras. Se da cuando una clase usa a otra clase para realizar algo.
Las relaciones de asociacin crean enlaces entre objetos. Estos enlaces no tienen por qu ser
permanentes (en la mayora de los casos, no lo son). Los objetos deben tener entidad fuera de la relacin (a
diferencia de las relaciones de composicin).
Esta relacin permite asociar objetos que colaboran entre si. Cabe destacar que no es una relacin
fuerte, es decir, el tiempo de vida de un objeto no depende del otro.
Para validar la asociacin, la frase Usa un, debe tener sentido, por ejemplo:
El ingeniero usa una computadora
El cliente usa tarjeta de crdito.
Un ejemplo grfico:
Relacin de Asociacin (usa)
Usa 1 o mas Cursos

Aplicacion Curso

2.13.2 AGREGACIN / COMPOSICIN
Esta relacin es utilizada cuando una clase se compone de otras clases, es un tipo de asociacin que
indica que una clase es parte de otra clase.
Se presenta entre una clase TODO y una clase PARTE que es componente de TODO. La
implementacin de este tipo de relacin se consigue definiendo como atributo un objeto de la otra clase
que es parte-de.
Los objetos de la clase TODO son objetos contenedores. Un objeto contenedor es aquel que
contiene otros objetos.
Es un tipo de relacin dependiente en dnde un objeto ms complejo es conformado por objetos

ms pequeos. En esta situacin, la frase Tiene un, debe tener sentido:
El auto tiene llantas
La pc tiene un teclado
Un ejemplo grfico:
Relacin de Composicin (Tiene)
Tiene 1 o mas Alumnos

Curso Alumno
Tiene 1 Docente
Docente
Hay dos tipos de especializaciones de esta relacin entre clases.
Agregacin: La agregacin implica una composicin dbil, si una clase se compone de otras y
quitamos alguna de ellas, entonces la primera seguir funcionando normalmente, por ejemplo
un objeto de tipo Agenda tiene una lista de objetos de tipo Contacto, si quitamos algn objeto
de tipo Contacto no afectamos la estructura bsica del objeto de tipo Agenda.

Composicin: La Composicin es una forma fuerte de composicin, donde la vida de la clase

contenida debe coincidir con la vida de la clase contenedor. Los componentes constituyen una
parte del objeto compuesto.
El tiempo de vida de un objeto est condicionado por el tiempo de vida del objeto que lo
incluye, por ejemplo si tenemos una objeto de tipo Silla, que est compuesto de cuatro objetos de
tipo Pata, si eliminamos un objeto de tipo pata, quedar con tres, lo cual rompe la definicin original
que tena el tipo Silla, La silla no puede existir sin sus patas.
2.13.3 GENERALIZACIN / ESPECIALIZACIN
De todas las relaciones posibles entre las distintas clases y objetos, hay que destacar por su
importancia en O.O la relacin de herencia, sta es una relacin entre clases que comparten su estructura y
el comportamiento, la estudiaremos ms en detalle en la seccin 2.15.
Un ejemplo grfico:
Relacin de Herencia (Es un)
Persona
Es una Persona Es una Persona
Alumno Docente

2.14 REUTILIZACIN
Hay dos mecanismos en POO para aplicar reutilizacin, es decir, para construir clases utilizando otras
clases:
Composicin: Una clase posee objetos de otras clases (relacin tiene un). Se puede
reutilizar los atributos y mtodos de otras clases, a travs de la invocacin de los mensajes
correspondientes.
Herencia: Se pueden crear clases nuevas a partir de clases preexistentes (relacin es un).
Se puede reutilizar los atributos y mtodos de otras clases como si fueran propios.
2.15 HERENCIA
La herencia es un mecanismo que permite la definicin de una clase a partir de la definicin de otra ya
existente. Es la caracterstica clave de los sistemas orientados a objeto para propiciar entre otros aspectos
la reusabilidad.
2.15.1 ESTRATEGIAS PARA IMPLEMENTAR HERENCIA
En general el concepto de herencia, se refiere al mecanismo por el cual los objetos comparten
comportamiento. En el mundo de las clases se denomina herencia, mientras que en el de los prototipos
recibe el nombre de delegacin; en esta forma alterna de implementar conocimiento comn, la distincin
entre clases e instancias no es necesaria: cualquier objeto pueden ser un prototipo.
Es por esto que existen dos estrategias bsicas, para implemetar el modelo de herencia: Clases-Herencia
y Prototipos-Delegacin:
2.15.1.1 S ISTEMAS BASADOS EN CLASES

Mediante una clase (molde, plantilla) es posible definir la estructura y el comportamiento de un
conjunto de objetos, en donde se detallan los atributos y mtodos que compartiran todas las instancias de la
misma determinando su estado y comportamiento.
Las clases se organizan jerrquicamente, y una nueva clase puede reutilizar la estructura y
comportamiento de otras previamente definidas.
Lenguajes que lo implementan: Smalltalk, Haskell, C++, Java, entre otros

Jerarqua de Clases
Diseo descendente De General

Persona
(TopDown), por
especializacin
Alumno
Alumno A Particular
Universitario
Sistemas basados en clases
Persona Clase Base
Es una Persona Es una Persona
Alumno Clase Docente Clase

Derivada Derivada
Figura Clase Base
Circulo Rectangulo Triangulo Clases

Derivadas
2.15.1.2 S ISTEMAS BASADOS EN P ROTOTIPOS
Las clases no suponen una necesidad prctica en el desarrollo orientado a objetos, los lenguajes
basados en prototipos prescinden de ellas y sus funciones se llevan a cabo mediante mecanismos
alternativos.
La herencia se obtiene a travs de la clonacin de objetos ya existentes, que sirven de prototipos,

extendiendo sus funcionalidades.

Es un estilo de programacin orientada a objetos en el cual, las "clases" no estn presentes.
Lenguajes que lo implementan: Self, JavaScript, entre otros.
2.15.1.3 C OMPARACIN DE MODELOS
Sistema basado en clases Sistema basado en prototipos
Los objetos pueden ser de dos tipos generales, las Las clases actan como colecciones de
clases y las instancias. Las clases definen la comportamiento (mtodos) y estructuras que son
disposicin y la funcionalidad bsicas de los iguales para todas las instancias, mientras que las
objetos, y las instancias son objetos "utilizables" instancias llevan los datos de los objetos.
basados en los patrones de una clase particular.
Hay una distincin entre la estructura y el Hay una distincin del estado.
comportamiento.
2.15.2 MODELOS DE IMPLEMENTACIN
2.15.2.1 H ERENCIA POR DELEGACIN
El objeto tiene uno o ms atributos parent, de forma que cuando no puede responder a un mensaje, le
reenva ste a su padre.
Existe una cadena de objetos apuntando a sus padres, hasta llegar a un objeto padre de todos.
HERENCIA POR DELEGACIN

2.15.2.2 H ERENCIA POR CONCATENACIN
El objeto est compuesto por las partes que define cada una de las clases de las que hereda.
Todos los atributos y mtodos heredados estn disponibles en el mismo objeto (si bien se necesita la cla
se para poder interpretarlos).
HERENCIA POR CONCATENACIN
2.15.2.3 C OMPARACIN DE MODELOS

Para representar en mquina, caractersticas y comportamientos compartidos por elementos de un
conjunto, denominados objetos, se propone: el tratamiento tradicional de definir objetos clase que empa-
quetan el conocimiento necesario para fabricar objetos instancia a partir de ellas, y la definicin de objetos
prototpicos que puedan clonarse para crear otros nuevos.
Los dos modelos difieren bsicamente en a quin se le atribuye el comportamiento y el momento en
que se fijan los patrones de comunicacin entre objetos.
Sobre la herencia implementada por delegacin o por concatenacin, se puede decir que con respecto a
la forma de aplicar el comportamiento compartido, y a la forma de implementarlo, resulta ms flexible y
por lo tanto otorga caractersticas dinmicas, lo que facilita la exploracin de dominios en conjunto con una
metodologa apoyada en los prototipos. Mientras que la herencia por concatenacin es ms rgida en su
definicin pero ms uniforme en su aplicacin y por ende es posible, establecer una jerarqua de herencia y
de tipos correspondientes lo que facilita la construccin de herramientas que soporten este mecanismo. Por
lo tanto se puede afirmar que concatenacin y delegacin pueden ser implementadas en ambos ambientes
ya sean de clases o prototipos y el mecanismo de implementar la herencia estar en funcin del propsito y
funcionalidad que se persiga en la construccin del sistema.
Tener en cuenta que la herencia por concatenacin es ms eficiente porque hereda solo lo que es
diferente, no duplica.
Lenguajes: Self y Eiffel.

2.16 POLIMORFISMO
La palabra polimorfismo proviene del griego y significa que posee varias formas diferentes. Este es uno
de los conceptos esenciales de una programacin orientada a objetos. As como la herencia est relacionada
con las clases y su jerarqua, el polimorfismo se relaciona con los mtodos.
Esta propiedad, como su mismo nombre sugiere mltiples formas, se refiere a la posibilidad de acceder
a un variado rango de funciones distintas a travs de la misma interfaz. O sea, que, en la prctica, un mismo
identificador puede tener distintas formas (distintos cuerpos de funcin, distintos comportamientos)
dependiendo, en general, del contexto en el que se halle inserto.
Otra definicin:
Comportamientos diferentes, asociados a objetos distintos, pueden compartir el mismo nombre, al
llamarlos por ese nombre se utilizar el comportamiento correspondiente al objeto que se est usando. O
dicho de otro modo, las referencias y las colecciones de objetos pueden contener objetos de diferentes
tipos, y la invocacin de un comportamiento en una referencia producir el comportamiento correcto para
el tipo real del objeto referenciado. Cuando esto ocurre en tiempo de ejecucin, esta ltima caracterstica
se llama asignacin tarda o asignacin dinmica. Algunos lenguajes proporcionan medios ms
estticos (en tiempo de compilacin) de polimorfismo, tales como las plantillas y la sobrecarga de
operadores de C++.
2.16.1 TIPOS DE POLIMORFISMO
En general, hay tres tipos de polimorfismo:

Polimorfismo de sobrecarga
Polimorfismo paramtrico (tambin llamado polimorfismo de plantillas)
Polimorfismo de inclusin (tambin llamado redefinicin o subtipado)
2.16.1.1 P OLIMORFISMO DE SOBRECARGA
El polimorfismo de sobrecarga ocurre cuando las funciones del mismo nombre existen, con
funcionalidad similar, en clases que son completamente independientes una de otra (stas no tienen que ser
clases secundarias de la clase objeto). Por ejemplo, la clase complex, la clase image y la clase link pueden
todas tener la funcin "display". Esto significa que no necesitamos preocuparnos sobre el tipo de objeto con
el que estamos trabajando si todo lo que deseamos es verlo en la pantalla.
Por lo tanto, el polimorfismo de sobrecarga nos permite definir operadores cuyos comportamientos
varan de acuerdo a los parmetros que se les aplican.
Ejemplos:
En Java y Python es posible, agregar el operador + y hacer que se comporte de manera distinta
cuando est haciendo referencia a una operacin entre dos nmeros enteros (suma) o bien cuando
se encuentra entre dos cadenas de caracteres (concatenacin).

Sentencias Resultados
Java int a = 2, b = 3; 5
int c = a + b;
String nom= Juan; ape= Perez; Juan,Perez
nomCompleto = nom+ , +ape;
Python a = 2 5
b = 3
c = a + b
nom= 'Juan' Juan,Perez

ape= 'Perez'
nomCompleto = nom+ ', +ape
En Haskell las clases de tipos proporcionan un modo estructurado de controlar el polimorfismo de

sobrecarga.
Ejemplos:
Los literales 1, 2, etc. son usados para representar tanto valores enteros de precisin
arbitraria, como enteros de precisin limitada.
Los operadores numricos, como +, suelen estar definidos para distintos tipos numricos.
El operador de igualdad (== en Haskell) suele estar definido para bastantes tipos de datos
(como los numricos y caracteres) aunque no para todos.
2.16.1.2 P OLIMORFISMO PARAMTRICO
El polimorfismo paramtrico es la capacidad para definir varias funciones utilizando el mismo nombre,
pero usando distintas combinaciones de parmetros(nmero y/o tipo). El polimorfismo paramtrico
selecciona automticamente el mtodo correcto a aplicar en funcin del tipo de datos pasados en el
parmetro.
Por lo tanto, podemos por ejemplo, definir varios mtodos homnimos de addition() efectuando una
suma de valores.
int addition(int,int) devolvera la suma de dos nmeros enteros.
float addition(float, float) devolvera la suma de dos flotantes.
char addition(char, char) dara por resultado la suma de dos caracteres definidos por el
autor.
Una signature es el nombre y tipo (esttico) que se da a los argumentos de una funcin. Por esto, una
firma de mtodo determina qu elemento se va a llamar.

2.16.1.3 P OLIMORFISMO DE SUBTIPADO
La habilidad para redefinir un mtodo en clases que se hereda de una clase base se llama
especializacin. Por lo tanto, se puede llamar un mtodo de objeto sin tener que conocer su tipo intrnseco:
esto es polimorfismo de subtipado. Permite no tomar en cuenta detalles de las clases especializadas de una
familia de objetos, enmascarndolos con una interfaz comn (siendo esta la clase bsica).
Imagine un juego de ajedrez con los objetos rey, reina, alfil, caballo, torre y pen, cada uno heredando
el objeto pieza.
El mtodo movimiento podra, usando polimorfismo de subtipado, hacer el movimiento
correspondiente de acuerdo a la clase objeto que se llama. Esto permite al programa realizar el
movimiento.de_pieza sin tener que verse conectado con cada tipo de pieza en particular.
2.17 AMBIENTE
.Para que haya objetos que interacten, se enven mensajes y se conozcan entre s; tienen que estar
en algn lugar, tiene que haber algo que los contenga. A ese lugar lo llamamos ambiente de objetos.
Cualquier versin de Smalltalk, es un ambiente de objetos, en el cual viven los objetos con los que
trabajamos y modelamos. Cuando creamos un objeto, se agrega al ambiente.
Ahora, para que un ambiente no crezca indefinidamente, tiene que haber alguna forma de sacar
objetos. Cmo hago para sacar un objeto del ambiente?. La respuesta para la mayora de los lenguajes que
soportan la orientacin a objetos, incluido Smalltalk, es el ambiente se arregla. Dicho en forma sencilla, se
da cuenta cuando un objeto no tiene referencias, y lo saca. Esta caracterstica es la que se conoce como
garbage collector.
Hay una relacin fuerte entre un ambiente de objetos y la memoria de la PC donde corre, no
conviene pensar en el ambiente como el formato que una aplicacin con objetos le da a la memoria.
Algunos ambientes Smalltalk swappean a disco, existen ambientes distribuidos, hay tcnicas para
deshidratar objetos de un ambiente en una base de datos relacional y despus volver a hidratarlos
cuando hacen falta.
2.18 SOFTWARE
El software segn el paradigma de objetos: Objetos que viven en un ambiente y que interactan
entre s envindose mensajes.
A partir de esta definicin queda ms claro que programar consiste en definir qu objetos necesito,
definir los mensajes que va a entender y que van a formar su comportamiento, y escribir el cdigo que
soporta cada objeto definido, en donde se incluye enganchar mediante las variables de cada objeto las
referencias necesarias para que cada objeto conozca a quienes debe enviarle mensajes.
Hacer software en gran escala hay mucho ms de lo que me tengo que ocupar: manejo de
memoria, base de datos, performance, etc. Hay proyectos de software nada pequeos que se desarrollaron

o se desarrollan usando los conceptos del paradigma en una forma bastante razonable, y que se comportan
bastante bien tanto en performance como en uso de recursos10. Cuando hubo problemas, ms bien se
debieron al uso imcompleto o inadecuado de estos conceptos, y no al revs.
Hay muchsimo para decir sobre esto, por ahora destacamos dos factores:
los conceptos de objetos, estos bsicos que aparecieron hasta ahora: objeto, mensaje,
polimorfismo, interaccin, referencias; bien usados, permiten manejar modelos bastante
complejos sin que se te vayan de las manos. Esto permite que haya menos necesidad de
hacer chequeos redundantes, repetir cosas, etc., lo que en escala provoca que el soft
construido con objetos se hace ms eficiente, y no menos.
en un software bien construido con objetos los problemas de performance y uso de

memoria terminan quedando bastante focalizados en lugares bien especficos; al trabajar
sobre estos puntos, se logran con relativamente poco trabajo ganancias dramticas (que
un programa corra 10 veces ms rpido despus de un trabajo de performance no es algo
raro).

3. IMPLEMENTACIN DEL POO CON SMALLTALK
El objetivo de la presente seccin es introducirnos en:
la sintaxis y semntica del lenguaje Smalltalk,

la biblioteca Smalltalk: clases fundamentales de Smalltalk, tales como: cadenas, nmeros,
caracteres, colecciones y otras,
el ambiente de programacin de Smalltalk (workspaces, inspect it, transcript y browsers) para
crear nuevas aplicaciones Smalltalk,
los conceptos fundamentales del lenguaje: manejo de clases y objetos, mensajes, clases y herencia.
Para ello tomamos como libro cabecera el del autor Wilf Lalonde, Descubra Smalltalk97. Este autor
es uno de los pioneros en el uso productivo de Smalltalk y centra la atencin de su libro en el dialecto de
Smalltalk/V desarrollado para Microsoft Windows. En el desarrollo de la Asignatura y ejercitacin prctica se
utilizar el ambiente de Smalltalk - Pharo 3.0.
3.1 INTRODUCCIN
Smalltalk es un lenguaje fuertemente adherido al paradigma orientado a objetos. Ha servido tanto

como modelo de extensin de los lenguajes procedimentales tradicionales como de base para una nueva
generacin de lenguajes que admiten herencia. [LaLonde 97].
Smalltalk es un lenguaje orientado a objetos puro, todas las entidades que maneja son objetos. La
programacin en Smalltalk consiste en: [GIPSI 96].
Crear clases.
Crear instancias.
Especificar la secuencia de mensajes entre objetos.
Toda la programacin en Smalltalk se realiza mediante el envo de un mensaje a un objeto para
invocar uno de sus mtodos.

Smalltalk no es un lenguaje de investigacin, existen distintos ejemplos de su uso en aplicaciones

crticas, abarcando diversos dominios, tales como el proceso de transacciones con tarjetas de crdito y la
supervisin de mercados internacionales de valores [Booch 97].
Smalltalk es un ambiente completo de desarrollo de programas. ste integra de una manera

consistente caractersticas tales como un editor, un compilador, un debugger, utilitarios de impresin, un
sistema de ventanas y un manejador de cdigo fuente. [GIPSI 96].
Smalltalk es un lenguaje altamente interactivo y se implementa como intrprete. Esto permite a los
usuarios trabajar en muchas cosas diferentes a la vez dado que pueden suspender su actividad en una
ventana y continuar otra actividad distinta en otra ventana simplemente moviendo el apuntador de una a
otra ventana. Las ventanas pueden tambin moverse alrededor de la pantalla usando el ratn. [Cceres
Gonzlez 04].
Las ventanas que utilizaremos en el presente material son:
Transcript: ventana principal del sistema Smalltalk/V, que es un editor de texto utilizado para evaluar
expresiones. El propio entorno tambin la utiliza para mostrar mensajes al programador.
Workspaces: contienen un editor de texto y pueden utilizarse para evaluar expresiones.
Inspect it: permiten observar la estructura interna de un objeto y modificar el valor de las mismas.
Browsers: permite inspeccionar y editar la biblioteca de clases del ambiente.
3.2 ASPECTOS IMPORTANTES DE SMALLTALK [BUDD 91]
3.2.1 ASIGNACIN DINMICA DE MEMORIA

En Smalltalk solo disponemos de objetos, los cuales son manipulados a travs de
apuntadores/referencias.
Todas las referencias tienen un tamao fijo constante y se le asigna espacio en la pila. Los objetos
referenciados se almacenan en otro sector de la memoria, llamado heap (montculo), que no est sujeto al
protocolo de asignacin de la pila.

3.2.2 ASIGNACIN DE REFERENCIAS

Smalltalk usa semntica de referencias para asignacin.
Una asignacin a una referencia, cambia el valor de la referencia por el valor contenido en otra
referencia. De esta manera, si tenemos dos variables no solo tendrn el mismo valor sino que referencian al
mismo objeto. Por ejemplo, x := y.
3.2.3 ASIGNACIN DINMICA DE TIPOS

Para conocer la diferencia entre asignacin esttica y dinmica de tipos, es necesario que
distingamos entre identificadores, tipos y valores. Un identificador o variable, es simplemente un nombre
que utiliza el programador para manipular un espacio de memoria. Valor describe los contenidos actuales de
la memoria del computador asociados a la variable. Dependiendo del lenguaje, un tipo se puede asociar con
una variable o con un valor.
En los lenguajes con asignacin de esttica de tipos, como Java cuando trabaja con tipos primitivos
de datos, los tipos se asocian con las variables al momento de ser declaradas. Por ejemplo (en Java): int var
En Smalltalk, las variables no se declaran con tipos especficos. De esta manera, no es posible
asignar a una variable un valor ilegal.
En un lenguaje con asignacin dinmica de tipos, cada valor debe llevar consigo una identificacin
que permite conocer la naturaleza exacta del valor. Esta identificacin queda ligada al valor a travs de la
asignacin. Con el paso del tiempo, a un identificador se le pueden pasar valores de muchos tipos
diferentes.
Por ejemplo, en Smalltalk, podramos tener:
| identificadorVariable | Declaracin del identificador de una variable sin indicar el tipo
identificadorVariable := 10.
identificadorVariable := Hola.
3.2.4 OBJETOS POLIMRFICOS

Al ser un lenguaje con asignacin dinmica todos los objetos son potencialmente polimrficos.
Cualquier objeto puede tener valores de cualquier tipo.

3.3 SINTAXIS Y SEMNTICA DEL LENGUAJE SMALLTALK
3.3.1 COMENTARIOS
Esta tcnica permite comentar lo que estamos haciendo. Cualquier cosa entre comillas dobles es un
comentario y Smalltalk lo ignora.
Sintaxis:
Un comentario
3.3.2 OPERADOR DE ASIGNACIN (:=)

El operador := se denomina operador de ligadura o asignacin porque asigna la variable de la
izquierda al objeto calculado por la expresin de la derecha. Una vez efectuada la asignacin, la evaluacin
de la variable devuelve el objeto asignado. [LaLonde 97].
Es un operador especial, no es un mensaje.
Por ejemplo:
temperaturaHoy := 22.
3.3.3 LITERALES Y VARIABLES

En Smalltalk, los literales y variables son nombres que se dan a los objetos para luego hacer
referencia a ellos.
Los literales [Cuenca] hacen referencia siempre al mismo objeto. Por ejemplo:
$a denota el carcter a.
'hola' denota al string con las letras h, o, l y a.
10 denota al nmero 10.
#hola denota al smbolo (string constante) con las letras h, o, l y a.

Las variables, en cambio, pueden hacer referencia a un objeto determinado en un instante de

tiempo y, momentos despus, a otro objeto completamente diferente. En un instante de tiempo, una
variable solo puede hacer referencia a un objeto. [LaLonde 97].
El nombre de una variable debe comenzar con una letra y se encuentra compuesto por una secuencia de
letras y dgitos.
En Smalltalk, podemos distinguir los siguientes tipos de variables: variables de instancia, variables globales,
variables locales o temporales, argumentos de mtodos, variables contenedoras y variables globales. Por
ahora, describiremos las variables locales y globales.
3.3.3.1 VARIABLES LOCALES O TEMPORALES

Se utilizan para hacer referencia temporal a objetos que sern utilizados ms adelante [Cuenca].
Para poder utilizar una variable local esta debe estar previamente declarada, para lo cual se listan
sus nombres encerrados entre barras:
| variable1 variable2 variable3|
El identificador de una variable local debe comenzar con minscula.
Asignacin de un objeto a una variable local:
variable1 := expresin.
Ejemplo:
| temperaturaAyer temperaturaHoy |
temperaturaAyer := 10.
temperaturaHoy := 22.
3.3.3.2 VARIABLES GLOBALES .

Son variables que pueden accederse desde cualquier parte del entorno y son persistentes entre
diferentes sesiones de trabajo [Cuenca]. Si asignamos una variable global a un objeto, almacenamos la
imagen y luego reiniciamos Smalltalk una semana ms tarde, la variable estar an asignada al objeto.
[LaLonde 97].

Por ejemplo, las clases se identifican mediante variables globales, como Integer, Number,
Magnitude y Object. Otra variable global es Transcript, que hace referencia a la ventana que encontramos
en Smalltalk. [LaLonde 97].
El nombre de una variable global debe comenzar con maysculas [Cuenca].
Para crear una variable global se debe:
Declaracin de una variable global:
Smalltalk at: #MiMejorAmiga put: ' Objeto de muestra'
Asignacin de la variable global a un objeto:
MiMejorAmiga:= 'Gladys Garcia'
Las variables globales pueden recibir cambios:
MiMejorAmiga:= ' Vera'
Eliminacin de la declaracin de una variable global:
Smalltalk removeKey: #MiMejorAmiga
Otra opcin para la creacin de variables globales es la siguiente [Cuenca]:
Escribir el nombre de la variable global en la ventana Transcript.

Seleccionar y evaluar ese nombre.
Confirmar la creacin de la variable global.
Asignar algn valor a la variable global (caso contrario, su valor ser el objeto nil).
Todas las variables globales se almacenan en un diccionario llamado Smalltalk (que es tambin una
variable global).
3.3.4 PSEUDO-VARIABLES
Es un identificador que referencia a un objeto, no se les puede asignar un objeto y siempre
referencian al mismo objeto.
3.3.4.1 OBJETO ESPECIAL nil

Referencia a un objeto que representa la nada o vacio. Las variables que no han sido asignadas
a un objeto referencian a nil. Es una instancia de la clase UndefinedObject. Si investigamos la clase
UndefinedObject encontramos que es clase hija de la clase Object, no posee atributos y entiende los
mensajes: isNil y notNil. [LaLonde 97].

nil isNil cuyo resultado es: true
nil notNil cuyo resultado es: false
25 isNil cuyo resultado es: false
25 notNil cuyo resultado es: true
3.3.4.2 true
Referencia a un objeto que representa el verdadero lgico [Gmez Deck 07].
3.3.4.3 false
Referencia a un objeto que representa el falso lgico [Gmez Deck 07].
3.3.4.4 self
Referencia al objeto receptor de un mensaje: objeto actual. Se utiliza cuando como parte de la
implementacin de un mtodo es necesario invocar a un mtodo de la misma clase. No se utiliza self para
hacer referencia a un atributo de la clase.
3.3.4.5 super
Indica que debe ejecutarse el mtodo de la clase base del objeto actual. [Gmez Deck 07].
3.3.4.6 thisContext
Referencia al objeto contexto-de-ejecucin que tiene toda la informacin referente a la activacin
de un mtodo [Gmez Deck 07].
3.3.5 SMBOLOS
Los smbolos (Symbol) son cadenas de caracteres (String) usadas como nombres de clases, mtodos,
etc. No pueden existir smbolos con el mismo conjunto de caracteres.
Sintaxis:
#unSmbolo.
Ejemplo:
#'un smbolo con espacios en blanco'.

3.4 IMPLEMENTACIN DE CONCEPTOS DEL POO EN SMALLTALK
3.4.1 CLASES
Una clase contiene elementos llamados miembros, que pueden ser atributos (variables de instancias),
variables de clase y poolDictionaries.
La sintaxis para la definicin de una clase en Smalltalk es:
Object subclass: #NombreClase
instanceVariableNames: ' '
classVariableNames: ' '
poolDictionaries: ' '
Donde:
Object subclass: indica la clase madre o base de la cual es clase hija la clase que se est creando.
#NombreClase: indica el identificador que se le asigna a la clase. Este identificador debe comenzar con
mayscula y si se encuentra constituido por ms de una palabra, cada palabra debe comenzar con
maysculas. El nombre de la clase debe ser representativo de los objetos que permite instanciar.
Variables de instancia: son los atributos del objeto y existen durante el tiempo de vida del objeto
instancia de la clase [Goldberg/ Robson 83]. Los nombres de atributos slo pueden ser referidos desde
el interior de los mtodos de su clase.
Variables de clase: son compartidas por todas las instancias de una clase [Goldberg/ Robson 83]. En
consecuencia, hay una sola instancia de cada una de estas variables. Por otra parte, la clase, sus
rosubclases, las subclases de stas, y as sucesivamente, y cada una de las instancias de sta (y de las
subclases) pueden acceder a los objetos de las variables de clase [Lalonde 97].
Pool dictionaries: son variables contenedoras. Todas las variables mantenidas por los diccionarios
comunes son accesibles desde las instancias y la clase que tiene el diccionario comn en su definicin.
[Lalonde 97].
Si debiramos desarrollar una aplicacin bancaria, y se detecta que uno de los conceptos principales es
el de CuentaBancaria, nos llevar a pensar en la necesidad de disear una clase que provea objetos para
representar las cuentas del banco.
Si la informacin a mantener de cada cuenta fuera: nmero, titular, saldo y cantidad de cuentas que
posee el banco, la definicin de la clase en Smalltalk sera la siguiente:

Object subclass: #CuentaBancaria
instanceVariableNames: ' numero titular saldo '
classVariableNames: ' cantidadCuentas '
Continuacin de Tipos de variables en Smalltalk
3.4.1.1 VARIABLES DE INSTANCIA

Representan los atributos de un objeto y se listan en la definicin de la clase:
Una convencin entre desarrolladores Smalltalk, indica que si el nombre de una variable se
encuentra compuesta de ms de una palabra (a excepcin de la primer palabra), cada una de ellas debe
comenzar con una letra mayscula.
Por ejemplo, si tuviramos una clase que representa una CuentaBancaria con los atributos nmero,
titular y saldo:
instanceVariableNames: 'numero titular saldo '
3.4.1.2 VARIABLES DE CLASE

Son compartidas por todas las instancias de una clase y se listan en la definicin de la clase:

El identificador de una variable de clase debe comenzar con una letra mayscula.
Supongamos que la clase CuentaBancaria posee una tasa de inters comn para todas las cuentas
bancarias y adems posee una variable de clase que determina la cantidad de instancias que se han creado a
partir de la clase. La declaracin sera la siguiente:
classVariableNames: 'tasaInteres cantidadInstancias '
3.4.1.3 VARIABLES CONTENEDORAS

Bsicamente, son variables que nos permiten mantener listas de constantes. Las variables contenedoras
son llamadas diccionarios globales.
Para crear diccionarios globales, como MarcasAutomoviles y Colores, podemos ejecutar:
MarcasAutomoviles := Dictionary new.
Colores := Dictionary new.
Luego se inspecciona el diccionario y se agregan las distintas constantes (ver en el tema Colecciones
la clase Dictionary). Por ejemplo, en el diccionario global MarcasAutomoviles se pueden agregar las
constantes (Claves): Chevrolet, Fiat, Renault. Las distintas opciones deben comenzar con mayscula.
Adems, de la clave de la opcin se debe agregar el valor asociado a dicha clave.
Seguidamente, cuando se define una clase en el apartado poolDictionaries listamos los diccionarios
globales que sern accesibles a las instancias de la clase y a la propia clase.
Se debe tener presente que estos diccionarios no son accesibles desde las clase hijas ni de las
instancias de las clases hijas.

Object subclass: #Consecionaria
poolDictionaries: 'MarcasAutomoviles'
3.4.2 INSTANCIAS DE UNA CLASE

Para la creacin de la instancia de una clase se debe enviar el mensaje new a la clase a instanciar.
Por ejemplo:
unObjeto:= Object new
unaCuenta:= CuentaBancaria new
otraCuenta:= CuentaBancaria new
Cuando se crea un objeto, todas sus variables de instancia (atributos) se inicializan en nil. Lo
correcto es que inmediatamente despus de instanciar un objeto, sus variables de instancia asuman valores
iniciales vlidos a travs del mtodo de inicializacin.
No todos los objetos se pueden crear enviando el mensaje new, as por ejemplo, si le enviamos el
mensaje new a la clase Fraction el sistema nos visualizar un mensaje de error. Para ello es necesario enviar
el mensaje de divisin a un entero, como: 1/2.
| variable |
variable := 1/2.
3.4.3 MTODOS
Un mtodo en Smalltalk consta de dos partes:
Un patrn del mensaje (tambin denominado cabecera del mtodo) con el nombre del selector
que identifica el mtodo y los nombres de sus parmetros, denominados parmetros del mtodo o
colaboradores externos.
Cuerpo del mtodo, que se encuentra constituido por tres componentes:
o Un comentario para describir la actuacin de ese mtodo concreto.

o Una lista de variables temporales o locales que puedan ser utilizadas en las sentencias.
o Las sentencias que responden al mensaje enviado.
Las variables temporales o locales creadas en los mtodos, son creadas para una tarea especfica y
se encuentran disponibles solo mientras dura la actividad para la cual han sido creadas [Goldberg/ Robson
83].
Sintaxis
patrnDelMensaje
comentario
|variablesTemporales|
sentencias.
Por ejemplo, si la clase CuentaBancaria posee un mtodo que le permite incrementar su saldo en
un 20%, el mtodo sera:
Depositar
Acredita en la cuenta un porcentaje fijo del 20%
saldo:= saldo+ (saldo* 0.20).
Argumentos de mtodos
Permiten la participacin de colaboradores externos en los mtodos. Dichos

parmetros/argumentos son necesarios para completar la funcionalidad del mtodoi.
El identificador de una variable local debe comenzar con minscula.

Sintaxis de un mtodo sin argumentos
patrnDelMensaje
comentario
sentencias.
Sintaxis de un mtodo con argumentos
patrnDelMensaje: colaboradorExterno1 <nombreArgumento: colaboradorexterno2>

comentario
sentencias.
Nota: Los caracteres <> indican opcionalidad (no forman parte de la sintaxis del mtodo)
Ejemplo de un mtodo con un parmetro:
depositar: importe
Acredita el importe indicado en la cuenta
saldo:= saldo + importe.
Ejemplo de un mtodo con ms de un parmetro usando variables locales:
depositar: importe porcentaje: porc
Acredita en la cuenta un importe y porcentaje pasados por parmetros
|porcentaje|
porcentaje:= saldo * porc.
saldo:= saldo+ (importe+ porcentaje).
3.4.3.1 MTODOS DE ACCESO Y MODIFICACIN

Para respetar la propiedad del POO: Encapsulamiento, la nica forma de obtener informacin de un
objeto es enviarle un mensaje solicitndole dicha informacin. En consecuencia, el objeto debe disponer de
un mtodo asociado a dicho mensaje que le permita devolver informacin sobre el objeto. Este mtodo
recibe el nombre de mtodo de acceso (o accesor).
Por correspondencia, un mtodo definido para cargar o modificar los atributos de un objeto, recibe el
nombre de mtodo de modificacin (o modificador).
Por convenio, los programadores de Smalltalk, como nombres de mtodos de acceso y modificacin
utilizan los mismos nombres que los de sus correspondientes nombres de atributos.
En consecuencia, si la clase CuentaBancaria posee el atributo numero, los nombres de los mtodos de
acceso y de modificacin sern:

Mtodo de Modificacin
titular: unTitular
Mtodo modificador del atributo titular
titular:= unTitular.
Mtodo de Acceso
titular
Mtodo de acceso al atributo titular
^titular. Retorno del objeto desde el mtodo
3.4.3.2 MTODOS DE INICIALIZACIN
3.4.3.2.1 INICIALIZACIN DE VARIABLES DE INSTANCIA

Como se indic anteriormente, cuando se crea un objeto, todas sus variables de instancia (atributos) se
inicializan en nil. El mtodo de inicializacin se invoca inmediatamente despus de creada una instancia y
asegura que el estado inicial del objeto sea vlido.
La convencin, entre desarrolladores de Smalltalk, es denominar initialize a dicho mtodo.
Si consideramos la clase CuentaBancaria donde sus atributos son: numero, titular y saldo su mtodo de
inicializacin tendra, por ejemplo, la siguiente forma:
initialize
Inicializa la instancia
numero:= 0.
titular:= ' '.
saldo:= 0.
Este mensaje se enva al objeto de la siguiente manera:
unaCuenta := CuentaBancaria new initialize.

3.4.3.2.2 INICIALIZACIN DE VARIABLES DE CLASE

Para la inicializacin de variables de clase se debe disponer de un mtodo de clase que tenga como
objetivo inicializar las variables de clase. Se puede crear un solo mtodo que inicialice todas las variables de
clase o un mtodo por variable de clase.
Este mensaje debe ser enviado a la clase antes de la creacin de sus instancias, siempre que sus
instancias as lo requieran.
Por ejemplo, si la clase Cuenta Bancaria tuviera la variable de clase cantidadInstancias y se desea
inicializarla en cero:
inicializarVariablesDeClase
Inicializa la variable de clase cantidadInstancias
cantidadInstancias isNil
ifTrue: [ cantidadInstancias := 0].
Este mensaje se enva a la clase de la siguiente manera:
CuentaBancaria inicializarVariablesDeClase
3.4.4 PASO DE MENSAJES

Cuando se enva un mensaje a un objeto, se busca en la clase receptora el mtodo correspondiente. Si
se encuentra, se hace una copia y se ejecuta la copia. Si no se encuentra, el proceso se repite en la
superclase. [LaLonde 94].
La nica forma de acceder a un objeto es envindole un mensaje. [Cuenca].
Ejemplos:
5 factorial => 120 enva el mensaje factorial al objeto 5
8 + 2 => 10 enva el mensaje +2 al objeto 8
10 between: 5 and: 15 => true enva el mensaje between: 5 and: 15 al objeto

10
Componentes de un mensaje [Cuenca]:
10 between: 5 and: 15
Objeto receptor Selectores Colaboradores externos

En los ejemplos anteriores:
5 factorial Receptor: 5
Selector: factorial
Colaboradores externos: no tiene
8 + 2 Receptor: 8
Selector: +
Colaborador externo: 2
10 between:5 and:15 Receptor: 10
Selector: between: and:
Colaboradores externos: 5 y 15
Los mensajes en Smalltalk se clasifican en:
Mensajes Unarios
Es similar a la llamada de una funcin sin parmetros. Se compone de un nombre de mensaje y un

operando. El operando es el objeto al que se le enva el mensaje. Por ello, algunos lo interpretan como una
funcin de un nico parmetro.
Por ejemplo: x sin se puede interpretar como el sin(x)
Ejemplos de mensajes unarios:
5 factorial
Date tomorrow
Mensajes Binarios
Son usados para especificar operaciones aritmticas, de comparacin y lgicas.
Un mensaje binario se puede encontrar constituido por uno o dos caracteres y pueden contener una
combinacin de los siguientes caracteres especiales:
+ / \ * - < > = @ % | & ? ! ,
Por ejemplo:

a + b retorna el resultado de sumar a y b
a+b se puede interpretar como que el mensaje + es enviado al objeto a con el

parmetro b.
Mensajes de palabra clave
Es equivalente a llamar a una funcin con uno o ms parmetros.
Por ejemplo:
a isKindOf: Integer
Transcript show: El valor de x es: , x
Los mensajes de palabra clave tienen variaciones algo ms complejas.
Por ejemplo, podramos preguntar:
5 between: 1 and: 10 (el cual devuelve como resultado true)
Aqu, between: 1 and: 10 es un mensaje compuesto por dos palabras claves, donde:
between: es una palabra clave y,
and: es otra palabra clave.
Por analoga con 1+2, podemos observar que 5, 1 y 10 son los operandos y between: and: es el
operador. Obsrvese que los smbolos dos puntos forman parte del operador.
No hay lmite en cuanto al nmero de operandos que puede tener un mensaje, pero entre cada
operando deber haber un palabra clave. Por lo tanto, lo siguiente no est permitido:
5 between: 1 10 (No permitido: falta la palabra clave para el operando 10)
5 between 1 and 10 (No permitido: faltan dos veces los dos puntos)
5 between: 1 and 10 (No permitido: faltan dos puntos)
Expresiones como: 1 class, 1 + 2, y 1 between: 0 and: 10, constan de un receptor (objeto receptor del
mensaje): el objeto es 1 y en cada expresin se le envan, respectivamente, los mensajes:
class
+2
between:0 and:10, respectivamente.

Todo mensaje en Smalltalk est compuesto de:
Un selector: class, +2 y between:0 and:10, respectivamente.

y parmetros: que son los operandos del mensaje. Segn nuestro ejemplo, respectivamente,
ningn parmetro, un parmetro (2) y dos parmetros (0 y 10).
Tambin nos podemos referir a los selectores como:
Selectores unarios, por ejemplo: class

Selectores binarios, por ejemplo: +
Selectores de palabra clave, por ejemplo: between: and:
Ejemplo de envo de mensajes en Smalltalk
unaCuenta depositar: 3000- 500 porcentaje: 20+ 10
3.4.4.1 PASOS IMPLICADOS EN LA EJECUCIN DE UN MENSAJE
1. Evaluacin de los parmetros del mensaje.

En el ejemplo:
3000- 500 se transforma en 2500
20+ 10 se transforma en 30
2. Envo del mensaje al receptor.

En el ejemplo el mensaje depositar: 3000- 500 porcentaje: 20+ 10 se enva al objeto unaCuenta.
3. Localizacin del mtodo correspondiente a un objeto receptor particular y realizacin de una copia, el
mtodo se copia.
4. Emparejamiento del mtodo con el patrn del mensaje perteneciente al mtodo copia, de la forma:
a. Emparejamiento del objeto receptor codificado en la expresin con la variable especial self -
tambin denominada pseudovariable- que identifica al objeto receptor, al tiempo que se
ejecuta el mtodo copia.
En el ejemplo, se empareja unaCuenta con self.
b. Emparejamiento del selector codificado en la expresin con la cabecera del mtodo copia.
En el ejemplo, la clusula depositar: porcentaje: de la expresin se empareja con la clusula
depositar: porcentaje: que se encuentra en la cabecera del mtodo copia.

c. Emparejamiento de los parmetros de la expresin, los parmetros del mensaje con sus
correspondientes parmetros que se encuentran en la cabecera del mtodo copia.
En el ejemplo, el entero 2500 se empareja con el parmetro del mtodo importe y el
entero 30 se empareja con el parmetro del mtodo porcentaje del mtodo copia.
5. Ejecucin del cuerpo del mtodo copia hasta la localizacin de una expresin de respuesta. Si el mtodo
no posee una expresin de respuesta, se ejecutar una expresin de respuesta por omisin ^self.
6. Devolucin del objeto calculado en la expresin de respuesta al emisor del mensaje, para su uso en
posteriores clculos.
3.4.4.2 ENVO DE MS DE UN MENSAJE A UN OBJETO

Un punto y coma entre dos mensajes indica que el mensaje que se encuentra inmediatamente a
continuacin de ste se va a enviar al mismo objeto receptor al que se ha enviado el anterior
Por ejemplo, si la clase Cuenta Bancaria contara con los mtodos depositar y extraer:
unaCuenta depositar:3000;
extraer:500;
depositar:400 porcentaje:20.
3.4.4.3 REGLAS DE PRIORIDAD DE MENSAJES

Dados dos selectores consecutivos, el selector de la izquierda se evala antes si ambos tienen la misma
prioridad. En caso contrario, se evala antes el selector con mayor prioridad.
Selectores Unitarios: mxima prioridad.

Selectores Binarios: la siguiente prioridad ms alta.
Selectores de Palabra Clave: mnima prioridad.
Ejemplo 1 con selector binario: La prioridad de los selectores unarios se realiza estrictamente de izquierda a
derecha.
1 + 2 (devuelve como resultado el objeto 3)
Ejemplo 2 con selector unitario: La prioridad de los selectores unarios se realiza estrictamente de izquierda a
derecha.
1 negated (devuelve como resultado el objeto -1)
-1 negated (devuelve como resultado el objeto 1)
0 factorial (devuelve como resultado el objeto 1)
1 factorial (devuelve como resultado el objeto 1)
1 negated negated (devuelve como resultado el objeto 1)

Evaluacin de esta expresin paso a paso:

1 negated negated
-1 negated
1
Ejemplo 3 con mezcla de selectores unitarios y binarios: Los selectores unitarios tienen asignada una
prioridad ms alta que los selectores binarios.
1 negated + 2 (devuelve como resultado el objeto 1)
Evaluacin paso a paso:
1 negated + 2
-1 +2
1
1 + 2 negated (devuelve como resultado el objeto -1)
1 + 2 negated
-1 +2
1
Ejemplo 4 con mezcla de selectores unitarios, binarios y de palabra clave:
25 between: 10 + 3 factorial and: 5 factorial + 3 (devuelve como resultado el objeto true)
25 between: 10 + 3 factorial and: 5 factorial + 3
25 between: 10 + 6 and: 5 factorial + 3 (porque se evala de izquierda a derecha)
25 between: 16 and: 5 factorial + 3
25 between: 16 and: 120 +3
25 between: 16 and: 123
True
3.4.5 RESOLUCIN DE UN CASO DE ESTUDIO
Desarrollar un programa que permita representar un punto en el plano y calcule la

distancia que existe entre el origen de las coordenadas (0,0) y un punto (x,y)
determinado.

Object subclass: #Punto "Autor: Ing. Karina Ligorria"

instanceVariableNames: 'x y'
classVariableNames: ''
poolDictionaries: ''
category: 'CoordenadasCartesianas'
initialize
x:=0.
y:=0.
x
"Answer the value of x"
^ x
x: anObject
"Set the value of x"
x := anObject
y
"Answer the value of y"
^ y
y: anObject
"Set the value of y"
y := anObject
asString
"Retorna los valores de x e y, en forma de coordenadas cartesianas"
^ '(' , x, ', ', y, ')'.
calcularDistancia
"La distancia entre el origen y la coordenada x,y es igual a la
hipotenusa: raiz cuadrada de la suma del cuadrado de x y cuadrado de y"
^((self x squared) + (self y squared) ) sqrt.
En Workspace:
|p|
p:= Punto new initialize.
p x:10;
y:5.
Transcript show: 'Distancia desde la coordenada (0,0) a ', p asString, ' es: ',
p calcularDistancia asString.

3.5 IMPLEMENTACIN DE COMPOSICIN EN SMALLTALK

Como estudiamos en la primera seccin la relacin de composicin se da cuando una clase posee
objetos de otras clases (relacin tiene un). Se puede reutilizar los atributos y mtodos de otras clases, a
travs de la invocacin de los mensajes correspondientes.
Algunos ejemplos grficos:
WorkSpace Curso Docente

Usa 5 Tiene 1
nombre, legajo,
aula, nombre,
docente sueldo
cant. de Alumnos inscriptos
cant. de Alumnos regulares
WorkSpace Curso Docente

Tiene 1 legajo,
Usa 1
nombre,
sueldo
nombre,
aula, Alumno
docente legajo,
alumnos Tiene n nombre,
nota1,
nota2
A continuacin plantearemos un ejemplo, utilizando el siguiente modelo:

1. Definicin de la clase Docente
Object subclass: #Docente "Autor: Ing. Anala Guzman"

instanceVariableNames: 'legajo apellido cargo'
category: 'ComposicionPPR'
initialize
legajo := 0.
apellido := ''.
cargo := ''.
legajo
^legajo
legajo: anObject
legajo := anObject
apellido
âpellido
apellido: anObject
apellido := anObject
cargo
^cargo
cargo: anObject
cargo := anObject
asString
|res|
res := String cr, 'Legajo: ', self legajo asString,

' - Apellido: ', self apellido asString,
' - Cargo: ', self cargo asString.
^ res
2. Definicin de la clase Curso
Object subclass: #Curso "Autor: Ing. Anala Guzman"

instanceVariableNames: 'codigo turno docente'
category: 'ComposicionPPR'

initialize
codigo := ''.
turno := ''.
docente := nil.
codigo
^codigo
codigo: anObject
codigo := anObject
turno
^turno
turno: anObject
turno := anObject
docente
^docente.
docente: anObject
docente := anObject.
asString
|res|
res := 'Codigo del curso: ', self codigo asString,

'Turno: ', self turno asString,
'Docente: ', self docente asString. Se invoca el mtodo
^ res asString de la clase
Docente.
3. Invocacin de objetos en Workspace
Para mostrar la invocacin de objetos en cascada, vamos a implementar en Workspace como se debe
hacer para mostrar el nombre del docente, por ejemplo.
En Workspace para poder mostrar en Transcript el nombre del docente, se deber seguir el
proceso de invocacin de mensajes, correspondiente a la relacin definida, se deber pedirle al curso el
nombre del docente y este le pedir al docente su nombre, vemos a continuacin el ejemplo en Workspace:
|unCurso unDocente|
unDocente := Docente new initialize.
unDocente legajo: 1;
apellido: 'Lopez';
cargo: 'Adjunto'.
unCurso := Curso new initialize.

unCurso codigo: '2K01';

turno: 'Noche';
docente: unDocente. "objeto de tipo Docente"
Transcript show: String cr, 'Los datos del curso son: ', unCurso asString.
Transcript show: String cr, 'El nombre del docente del curso: ', unCurso codigo
asString, ' es: ', (unCurso docente) nombre asString.
Se pide al curso Se pide al docente

el docente el nombre
3.6 IMPLEMENTACIN DE HERENCIA EN SMALLTALK
Como estudiamos en la primera seccin, La Herencia es la propiedad que permite a los objetos
construirse a partir de otros objetos.
Una subclase o clase hija o clase derivada, es un nuevo tipo de objetos definido por el usuario que
tiene la propiedad de heredar los atributos y mtodos de una clase definida previamente, denominada
superclase o clase madre o clase base [Ceballos, 2003].
Cuando se define una nueva clase, las variables de instancia proporcionadas por la nueva clase se
aaden a las variables de instancia que se obtienen automticamente de las clases que se encuentran ms
arriba en la jerarqua. La subclase puede aadir ms variables de instancia pero no puede eliminar ninguno
de los atributos heredados.
Una subclase puede, a su vez, ser una superclase de otra clase dando lugar a una jerarqua de clases.
Por lo tanto, una clase puede ser una superclase directa de una subclase, si figura explcitamente en la
definicin de la subclase, o una superclase indirecta si est varios niveles arriba en la jerarqua de clases, y
por lo tanto no figura explcitamente en el encabezado de la subclase [Ceballos, 2003].
Smalltalk admite herencia simple, es decir, que una clase hija solo puede tener una clase madre. Sin
embargo, una clase madre puede tener tantas clases hijas como se requieran.
Cuando se crea una instancia de una subclase su estructura de atributos est conformada por los
atributos propios ms los atributos heredados, no teniendo acceso directo a los atributos heredados por
respetar la propiedad de encapsulamiento de las superclases. En este caso, se deber utilizar el mtodo de
acceso que corresponda de la superclase.

3.6.1.1 D EFINIR UNA SUBCLASE

La sintaxis para declarar una subclase es la siguiente:
ClaseBase subclass: #ClaseHija

instanceVariableNames: ''
category: 'HerenciaPPR'
En Smalltalk, los inspectores indican de dnde proceden las variables de instancia heredadas.
A continuacin se presenta un ejemplo de cmo crear una jerarqua simple:
Object
Persona
Alumno
Se declara la clase base Persona, utilizando como clase base a la clase Object por defecto:
Object subclass: #Persona
instanceVariableNames: 'dni nombre telefono'
Se declara la clase derivada Alumno, utilizando como base a la clase Persona:
Persona subclass: #Alumno
instanceVariableNames: 'legajo promedio'

3.6.1.2 USO DE SUPER
El uso de super provoca que la bsqueda del mtodo comience en la superclase del objeto receptor.
Cuando super es encontrado en la ejecucin de un programa, Smalltalk busca el mtodo en la

superclase del receptor.
Por ejemplo:
super unMensaje. invoca a un mensaje de la clase base o superclase
self unMensaje. invoca a un mensaje de la propia clase
3.6.1.3 HERENCIA DE VARIABLES

La jerarqua del lenguaje Smalltalk, ha sido diseada para que las subclases hereden las variables de
sus superclases. Las subclases tambin pueden poseer variables propias.
Las variables de instancia estn definidas en la definicin de la clase. Los datos de la instancia se
mantienen en un rea de datos creada por Smalltalk.
Variables de Instancia: Cada subclase tiene su propia copia (estado) de variables, tanto las propias
como las heredadas.
Por ejemplo: el objeto alumno tiene las variables de instancia: dni, nombre, telefono, legajo y
promedio. Estas variables incluyen las variables de instancia heredadas de Persona.
Objeto usuario Instancia de Alumno Estructura Interna
Persona
dni dni
nombre
nombre
telfono
alumno telfono
legajo
promedio legajo
Alumno
promedio
El objeto usuario observa todos El objeto usuario no conoce la
los protocolos del alumno estructura interna del alumno
Variables de Clase: Una variable de clase es una variable que es compartida por todos los objetos
de la clase.

Slo existe una copia de la variable de clase en la jerarqua local de clases. Todos los objetos de la
clase referencian a esta nica copia de la variable.
Las variables de clase tambin permiten compartir la informacin a travs de todas las subclases de
la clase en que fueron declaradas.
3.6.1.4 INICIALIZACIN DE ATRIBUTOS EN UNA CLASE HIJA
Por defecto las variables de instancia se inicializan con el valor nil. A travs del mtodo initialize se
inicializan las variables de instancia a un valor por defecto definido por el usuario.
Para inicializar los atributos propios y heredados de una clase hija, en el mtodo de inicializacin de
la clase hija se deben inicializar en primer lugar los atributos heredados llamando al mtodo initialize de la
clase base y seguidamente sus propias variables de instancia.
Sintaxis del mtodo de inicializacin en la clase derivada:
Initialize
Inicializar atributos heredados de su clase base
super initialize.
Inicializar atributos propios
atributoPropio1:= 0.
atributoPropio2:= ' '.
3.6.1.5 HERENCIA DE MTODOS
La herencia de mtodos es til para permitir a una clase modificar su comportamiento respecto de
su superclase. Esto puede ser hecho agregando nuevos mtodos, o redefiniendo los mtodos heredados.
Agregacin de Mtodos:
Se puede agregar mtodos de manera muy simple, incorporndolos, ya sean de instancia o de

clase, en la definicin de la clase. Todo objeto de la subclase soporta los mtodos de su superclase, ms los
nuevos mtodos.

Redefinicin de Mtodos:
Redefinir un mtodo heredado significa volverlo a escribir en la subclase con el mismo nombre y
los mismos colaboradores externos que tena en la superclase y su implementacin adaptada a las
necesidades de la subclase.
Una subclase puede redefinir (volver a definir) algn mtodo existente en la superclase, con el
objeto de proveer una implementacin diferente, por ejemplo: mtodo asString.
Para redefinir un mtodo en la subclase, se tiene que declarar con la misma signatura (nombre y
colaboradores externos).
En la invocacin de mtodos, si existen dos mtodos con la misma signatura, uno en la subclase y
otro en la superclase, se ejecutar siempre el de la subclase.
Usando el ejemplo de la clase Alumno, al definir el mtodo asString se lo est redifiniendo, ya que
tanto la clase base Persona, como la clase Object ya las tienen implementadas.
asString
|res| datos de Persona datos de Alumno
res := super asString,
', Legajo: ', self legajo asString,
', Promedio: ', self promedio asString.
^res.
3.6.1.6 ENLACE DINMICO
Cuando un objeto recibe un mensaje se busca el mtodo asociado al mensaje en la clase del objeto
receptor del mensaje, si no se encuentra en la clase de dicho objeto se continua la bsqueda en la clase
inmediata superior jerrquicamente y, as sucesivamente, hasta ejecutar el mtodo correspondiente. En el
caso de no existir dicho mtodo, el sistema emite un error. Este procedimiento recibe el nombre de enlace
dinmico.
3.6.1.7 C LASES ABSTRACTAS
Son clases genricas que sirven para agrupar clases del mismo gnero. Definen comportamientos
que se implementarn en las subclases.
Definen un protocolo comn para una jerarqua de clases que es independiente de las opciones de
representacin.

No se pueden instanciar, es decir no se pueden crear objetos a partir de ellas, ya que representan
conceptos tan generales, con comportamientos que no siempre se pueden definir cmo ser la
implementacin de los mismos.
Los mtodos abstractos, son mtodos que no poseen implementacin, se definen en las clases
abstractas.
Smalltalk no tiene una sintaxis dedicada para especificar que un mtodo o una clase es abstracta.
Por convencin, el cuerpo de un mtodo abstracto consiste en la expresin: self subclassResponsibility.
Este es conocido como un "mtodo de marcador", e indica que subclases tienen la responsabilidad
de definir una versin concreta del mtodo.
Los mtodos subclassResponsibility siempre deben ser redefinidos, y por lo tanto no deben ser
ejecutados. Si se olvida de redefinir uno, y se ejecuta, se produce una excepcin.
Una clase se considera abstracta si uno de sus mtodos es abstracto. Nada en realidad le impide
crear una instancia de una clase abstracta; todo funcionar hasta que se invoca un mtodo abstracto.
Por ejemplo, si queremos definir un mtodo abstracto, llamado size, en una clase abstracta,
definimos:
size
self subclassResponsibility.
Tambin podemos definirlo sin cuerpo, pero no producir una excepcin si se invoca
equivocadamente, por ejemplo:
size
sin implementacin
Para finalizar, en alguna clase derivada se deber redefinir e implementar el mtodo, por ejemplo:
size
^ size
Una fbrica de dulces desea implementar un sistema de produccin donde se manejen los datos de
las golosinas especficamente de sus chocolates, caramelos sin relleno y con relleno.

De los chocolates se disponen los siguientes datos: cdigo (entero), nombre, precio, ingredientes
(cadena de caracteres) y tipo de chocolate (negro o blanco).
De los caramelos sin relleno: cdigo (entero), nombre, precio, ingredientes (cadena de caracteres),
sabor y color.
De los caramelos con relleno: cdigo (entero), nombre, precio, ingredientes (cadena de caracteres),
sabor del relleno y cantidad de relleno.
A partir de este relevamiento llegamos a la siguiente jerarqua de clases:
Object
Atributos propios
Golosina cdigo
nombre
precio
ingredientes
Chocolate Caramelo Atributos propios

sabor
Atributos propios color
tipo
CarameloCon Atributos propios
Relleno
saborRelleno
cantidadRelleno
Codificacin en Smalltalk (se generan los mtodos de acceso y modificacin automticamente

desde Pharo 3.0.).
Object subclass: #Golosina "Autor: Ing. Karina Ligorria"

instanceVariableNames: 'codigo nombre precio ingredientes'
category: 'FabricaGolosinas'
initialize
self codigo: 0. "El cero representa que no tiene codigo asignado aun"
self nombre: 'Sin nombre asignado'.
self precio: 0.0.
self ingredientes: 'Sin ingredientes establecidos'.

asString
^String cr, 'Codigo: ', self cdigo asString, ' Nombre:', self nombre
asString, ' Precio: $', self precio asString, ' Ingredientes: ', self
ingredientes asString.
Golosina subclass: #Chocolate "Autor: Ing. Karina Ligorria"

instanceVariableNames: 'tipo'
initialize
super initialize.
self tipo: 'Negro'. "Por defecto el chocolate es negro"
asString "Redefinicin de mtodos"

^String cr, 'CHOCOLATE: ', super asString, 'Tipo de chocolate: ' , self
tipo asString.
Golosina subclass: #Caramelo "Autor: Ing. Karina Ligorria"

instanceVariableNames: 'sabor color'
initialize
super initialize.
self sabor: 'No asigando'.
self color:'No asignado'.

^String cr, 'CARAMELO: ', super asString, ' Sabor: ' , self sabor
asString, ' Color: ', self color asString.
Caramelo subclass: #CarameloConRelleno "Autor: Ing. Karina Ligorria"

instanceVariableNames: 'saborRelleno cantidadRelleno'
initialize
super initialize.
self saborRelleno: 'No asignado'.
self cantidadRelleno: 0.

^String cr, super asString, ' Sabor del relleno: ' , ' RELLENO: ', self
saborRelleno asString, ' Cantidad de relleno: ' , self cantidadRelleno asString.
En Workspace:
g:= CarameloConRelleno new initialize.
g codigo: 1; "Mtodo heredado de la clase Golosina"

nombre: 'Gomita'; "Mtodo heredado de la clase Golosina"
precio: 1; "Mtodo heredado de la clase Golosina"
ingredientes: 'azcar - agua - gelatina sin sabor - gelatina del sabor
que se quiera'; "Metodo heredado de la clase Golosina"
sabor: 'chocolate'; "Mtodo heredado de la clase Caramelo"

color: 'marron'; "Mtodo heredado de la clase Caramelo"
saborRelleno: 'Coco'; "Mtodo propio"

cantidadRelleno: 2. "Mtodo propio"
Transcript show: g asString. "Mtodo redefinido en la clase CarameloRelleno"
3.7 IMPLEMENTACIN DE POLIMORFISMO EN SMALLTALK
Smalltalk Implementa los tres tipos de polimorfismo estudiados en la seccin anterior:
Polimorfismo de sobrecarga:
Por ejemplo, el operador +, se comporta de diferentes formas segn la clase donde est definido:
| a b c|
a := 2.
b := 6.
suma enteros el resultado es 8

c := a + b.
a := 2.5.
b := 3.5.
suma reales el resultado es 6.0

c := a + b.

Polimorfismo paramtrico:
Por ejemplo, usando la clase Alumno vista anteriormente, el mensaje legajo responde al
polimorfismo paramtrico, utiliza en el mismo objeto (mbito), el mismo nombre de mensaje con
colaboradores diferentes:
|alumno leg|
alumno := Alumno new.
modifica el legajo del alumno

alumno legajo:25658.
retorna el legajo del alumno

leg := alumno legajo
Transcript show: leg; cr.
Polimorfismo de subtipado
En SmallTalk, el manejo de colecciones es polimrfica, posee una jerarqua y operaciones genricas

asociadas, pueden almacenar objetos de cualquier clase y presentan un protocolo unificado, por lo que
todas las diferentes formas de colecciones provistas por el entorno responden a un mismo conjunto de
mensajes bsicos, lo que facilita su aprendizaje y el cambio de un tipo de coleccin a otra.
El siguiente grfico muestra la jerarqua de colecciones de Smalltalk/V [Cuenca]:
Object
Collection
Bag IndexCollection
Set
OrderedCollection FixedSizeCollection Dictionary
SortedCollection Array String Interval
Symbol

Enunciado
Para administrar los empleados de una empresa, se debe desarrollar un programa orientado a
objetos que pueda manejar mediante clases las siguientes entidades descubiertas durante la etapa de
anlisis del sistema:
Empleado: que tiene los siguientes datos: legajo y nombre.
Empleado Asalariado: (es un Empleado) que tiene como atributo el monto del salario semanal. El
clculo del ingreso de este empleado se establece por el monto del salario semanal.
Empleado por Comisin: (es un Empleado) que tiene como datos: el monto de ventas por semana,
y el porcentaje de comisin por ventas. El ingreso para estos empleados es el montoComision que se
calcula como el porcentajeComision*montoVentas/100.
Se acompaa un diagrama orientativo:
Object
Atributos propios
Empleado legajo,
nombre
Asalariado PorComision
Atributos propios Atributos propios

salarioSemanal montoVentas
porcentajeComision
Se pide:
1. Implementar las clases Empleado, Asalariado y PorComision que tengan los mtodos para
inicializar, los mtodos de acceso y modificadores, el mtodo asString, que retorna una cadena con
los atributos y el mtodo montoIngreso, que retorna el ingreso que le corresponde segn lo
enunciado anteriormente.
2. Realizar las pruebas de funcionamiento instanciando algunos objetos e invocando sus mtodos.
Resolucin
1. Codificacin en Smalltalk (se generan los mtodos de acceso y modificacin automticamente desde
Pharo 3.0.).

Object subclass: #Empleado "Autor: Ing. Anala Guzman"

instanceVariableNames: 'legajo nombre'
category: 'practicoPolimorfismo'
initialize
legajo := 0.
nombre := ''.
legajo
^ legajo
legajo: anObject
legajo := anObject
nombre
^ nombre
nombre: anObject
nombre := anObject
asString
"Mtodo redefinido"
|res|
res := String cr, 'El Empleado: ', self legajo asString,', con nombre: ',
self nombre asString.
^ res.
montoIngreso
"Mtodo abstracto"
self subclassResponsibility.
Empleado subclass: #Asalariado "Autor: Ing. Anala Guzman"

instanceVariableNames: 'salarioSemanal'
initialize
super initialize.
salarioSemanal := 0.0.
salarioSemanal
^ salarioSemanal
salarioSemanal: anObject
salarioSemanal := anObject

asString
"Mtodo redefinido"
|res|
res := super asString, ' tiene un salario semanal de ', self salarioSemanal
asString.
^ res.
montoIngreso
"Mtodo redefinido"
^ self salarioSemanal.
Empleado subclass: #PorComision "Autor: Ing. Anala Guzman"

instanceVariableNames: 'montoVenta porcentajeComision'
initialize
super intialize.
montoVenta := 0.0
porcentajeComision := 0.0.
montoVenta
^ montoVenta
montoVenta: anObject
montoVenta := anObject
porcentajeComision
^ porcentajeComision
porcentajeComision: anObject
porcentajeComision := anObject
asString
"Mtodo redefinido"
|res|
res := super asString, 'tiene una comision de ', self porcentajeComision
asString, ' y genero un monto de ', self montoVenta asString.
^ res.
montoIngreso
"Mtodo redefinido"
|montoComision |
"calcula el monto de la comision"

montoComision := (porcentajeComision * montoVenta) asFloat /100.0.
"retorna el monto de comision"

^ montoComision.
2. Crear objetos e invocar sus mtodos en Workspace:
|empleadoAsalariado empleadoComision|
empleadoAsalariado := Asalariado new initialize.
empleadoAsalariado legajo: 1; "Mtodo heredado de la clase Empleado"

nombre: 'Juan Perez'; "Mtodo heredado de la clase Empleado"
salarioSemanal: 5000. "Mtodo propio de la clase Asalariado"
Transcript show: String cr, empleadoAsalariado asString. "Mtodo polimrfico,

redefinido en la clase Asalariado "
Transcript show: String cr, 'El monto de Ingreso es: ', empleadoAsalariado
montoIngreso asString. "Mtodo polimrfico, redefinido en la clase Asalariado "
empleadoComision := PorComision new initialize.
empleadoComision legajo: 2; "Mtodo heredado de la clase Empleado"

nombre: 'Maria Juarez'; "Mtodo heredado de la clase Empleado"
montoVenta: 2000; "Mtodo propio de la clase Comision"
pocentajeComision: 20. "Mtodo propio de la clase Comision"
Transcript show: String cr, empleadoComision asString. "Mtodo polimrfico,

redefinido en la clase Comision "
Transcript show: String cr, 'El monto de Ingreso es: ', empleadoComision
montoIngreso asString. "Mtodo polimrfico, redefinido en la clase Comision"
Atencin: Lo que no debemos hacer en Workspace
Como la clase empleado tiene un mtodo abstracto, si bien la misma se puede instanciar en
Smalltalk, no se podr invocar al mtodo montoIngreso, ya que producir una excepcin:
|empleado|
empleado := Empleado new initialize.
empleado legajo: 1; nombre: 'Juan Perez';

Transcript show: String cr, empleado asString.
Transcript show: String cr, 'El monto de Ingreso es: ', empleado montoIngreso
asString.
Se produce el error de
excepcin, porque
montoIngreso no est
implementado.
3.8 BIBLIOTECA DE CLASES DE SMALLTALK

En Smalltalk, todas las clases deben estar contenidas en una sola jerarqua de herencia donde la clase
raz de dicha jerarqua es la clase Object. La ventaja de este enfoque es que la funcionalidad proporcionada
en la clase Object es heredada por todos los objetos.
Al ser un lenguaje que usa asignacin dinmica de tipos, los objetos se caracterizan por los mensajes que
entienden. Si dos objetos entienden el mismo conjunto de mensajes y reaccionan de la misma manera, para
todo propsito prctico son indistintos, independientemente de las relaciones de sus clases respectivas. Por
este motivo, es til hacer que todos los objetos hereden gran parte de su comportamiento de una clase base
comn.
En un lenguaje as, toda clase definida por el usuario debe ser una subclase de alguna clase ya existente.
3.8.1 CLASE OBJECT

Todas las clases de Smalltalk son subclases (directa o indirectamente) de la clase Object. Es la nica
clase que no tiene superclase y define el comportamiento que es comn a todos los objetos. [Cuenca].
La siguiente es una lista de los principales mensajes que responden todos los objetos:
Mensaje Ejemplos Pharo-3.0

Class Devuelve la clase del 5 class Kernel-Objects/ProtoObject/
receptor class membership
isKindOf: UnaClase Devuelve true si el $A isKindOf: Character Kernel-Objects/Object/class

receptor es instancias de la membership
clase indicada o de alguna
de sus subclases
respondsTo: unSelector Responde true si el 100 respondsTo:#negated Kernel-Objects/Object/class
receptor puede responder membership

un mensaje con el selector

que se indica
= otroObjeto Devuelve true si el 3 = (6/2) Kernel-
receptor es igual a Objects/Object/comparing
otroObjeto
~= otroObjeto Devuelve true si el 5 ~= 10 Kernel-
receptor es distinto a Objects/Object/comparing
otroObjeto
isNil Responde true si el nil isNil Kernel-
receptor es el objeto Objects/UndefinedObject/tes
ting
indefinido
notNil Responde true si el true notNil Kernel-
receptor no es el objeto Objects/UndefinedObject/tes
ting
indefinido
Copy Retorna un duplicado del $A copy Kernel-
receptor Objects/Object/copying
printString Retorna un string 3.14 printString Kernel-

descriptivo del receptor Objects/Object/printing
printOn: Transcript Muestra el receptor en la 'hola' printOn: Kernel-

ventana Transcript Transcript Objects/Object/printing
Resultados obtenidos de la ejecucin de los ejemplos:

3.8.2 OBJETO INDEFINIDO

Es la representacin de la nada. El objeto indefinido se llama nil y es instancia de la clase
UndefinedObject.
Todas las variables (globales o locales) tienen el valor nil hasta que se les asigna algn otro objeto.
nil isNil cuyo resultado es: true
nil notNil cuyo resultado es: false
25 isNil cuyo resultado es: false
25 notNil cuyo resultado es: true
3.8.3 MAGNITUDES
La librera de Smalltalk ofrece objetos muy diferentes, tales como nmeros, fechas y horas; todos esos
objetos (totalmente dismiles en su significado y utilizacin) tienen, sin embargo, algo en comn: pueden ser
ordenados de mayor a menor y compararse entre s. Todos ellos son magnitudes. [Cuenca].
La clase Magnitude es una superclase abstracta que define lo que tienen en comn tanto los nmeros como
las fechas y las horas; dicho de otra forma, define qu comportamientos debe tener un objeto para ser
considerado como una magnitud lineal.
< otraMagnitud Comparacin por menor 5 < 10 Kernel-Numbers/Magnitude/testing
<= otraMagnitud Comparacin por menor o 3 <= 3 Kernel-Numbers/Magnitude/testing

igual
> otraMagnitud Comparacin por mayor 4 > 10 Kernel-Numbers/Magnitude/testing
>= otraMagnitud Comparacin por mayor o 5 >= 0 Kernel-Numbers/Magnitude/testing

igual
between: Retorna true si el receptor 5 between: Kernel-Numbers/Magnitude/testing

limiteInferior and: se encuentra comprendido 3.14 and: 10
limiteSuperior entre los lmites indicados

Resultados obtenidos de la ejecucin de los ejemplos:
Las diferentes subclases de Magnitude agregan el comportamiento necesario para especializar esta
definicin abstracta de magnitud hasta obtener magnitudes concretas tales como nmeros, fracciones,
fechas y horas.
Object
Magnitude
Character Number Date Time
Float Fraction Integer
LargeNegativeInteger SmallInteger LargePositiveInteger

3.8.3.1 NMEROS
Smalltalk cuenta con varias clases de nmeros, todos ellos instancias de subclases de Number.
Number es una clase abstracta que agrupa las caractersticas y comportamientos de los nmeros en general.
Los nmeros pueden ser enteros, fraccionarios y reales (o de punto flotante).
Los nmeros reales, tales como 3.1415927 2.4633, son instancia de la clase Float, mientras que las
fracciones como 1/3 2/5 son instancia de la clase Fraction. Esto significa que tanto la Float como Fraction
son clases concretas.
La siguiente es una lista de los principales mensajes que comprenden todos los objetos numricos:

+ unNumero Suma 5 + 10 Kernel-Numbers/Number/arithmetic
Rta: 15
- unNumero Resta 2 7 Kernel-Numbers/Number/arithmetic

Rta:-5
* unNumero Multiplicacin 2.5 * 2 Kernel-Numbers/Number/arithmetic
Rta: 5
/ unNumero Divisin 10 / 3 Kernel-Numbers/Number/arithmetic
Rta: 3.33
// unNumero Divisin entera 10 // 3 Kernel-Numbers/Number/arithmetic
Rta: 3 (heredado)
\\ unNumero Resto de la divisin entera 10 \\ 3 Kernel-Numbers/Number/arithmetic

Rta: 1 (heredado)
Abs Valor absoluto -10.5 abs Kernel-Numbers/Number/arithmetic

Rta: 10.5
Negated Devuelve el receptor 1 negated Kernel-Numbers/Number/arithmetic
cambiado de signo Rta: -1
Squared Devuelve el cuadrado del 5 squared Kernel-Numbers/Number/mathematical

receptor Rta: 25 functions (heredado)
raisedTo: Devuelve el receptor 2 raisedTo: 3 Kernel-Numbers/Number/mathematical

unNumero elevado a la potencia Rta: 8 functions (heredado)
indicada por unNumero

Sqrt Devuelve la raz cuadrada 16 sqrt Kernel-Numbers/Number/mathematical
del receptor Rta: 4 functions
Negative Retorna true si el receptor -5 negative Kernel-Numbers/Number/testing

es negativo Rta:true
Positive Retorna true si el receptor 10 positive Kernel-Numbers/Number/testing

es positivo Rta: true

Even Retorna true si el receptor 4 even Kernel-Numbers/Number/testing

es par Rta: true
Odd Retorna true si el receptor 3 odd Kernel-Numbers/Number/testing

es impar Rta: true
Rounded Retorna el receptor como 3.1415927 Kernel-Numbers/Number/truncation

un entero rounded and round off
Rta: 3
3.5 rounded
Rta: 4
3.8.3.1.1 ENTEROS
La clase que representa nmeros enteros es Integer; sin embargo nmeros como 4 10000 no son
instancia de Integer, sino de alguna de sus subclases. Esto se debe a que atendiendo a razones de eficiencia
en el uso de la memoria y dependiendo del valor absoluto del nmero en cuestin, es conveniente
almacenarlo usando diferentes representaciones internas: para nmeros pequeos basta con usar 16 bits,
pero para nmeros ms grandes sern necesarios 32 bits. Pero estas diferencias de representacin no hacen
variar el comportamiento que exhiben los objetos numricos enteros, que se encuentra definido en su
totalidad en la clase abstracta Integer; sus subclases concretas solamente especializan la forma en que sus
instancias se almacenan en memoria. [Cuenca].
Las instancias de Integer, adems de todos los mensajes anteriores, son capaces de contestar los siguientes
mensajes:

asCharacter Devuelve el carcter 65 asCharacter Kernel-Numbers/Integer/converting
cuyo cdigo ASCII es Rta: $A
igual al valor del
receptor
Factorial Devuelve el factorial del 5 factorial Kernel-
receptor Rta: 120 Numbers/Integer/mathematical
functions
radix: unEntero Devuelve en un string la 25 radix: 15 Kernel-Numbers/Integer/printing-
representacin del Rta: '1A' numerative
receptor en la base de
numeracin indicada por
unEntero
3.8.3.1.2 FRACCIONES
Cuando el resultado de una divisin entre enteros no da como resultado otro nmero entero, el
resultado ser una instancia de la clase Fraction.

Las fracciones tambin son nmeros, por lo que responden a todo el protocolo descripto ms arriba y
adems cuenta con los siguientes mensajes principales:

numerator Devuelve el numerador (2/5)numerator Kernel-Numbers/Fraction/private
del receptor Rta: 2
denominator Devuelve el (2/5)denominator Kernel-Numbers/Fraction/private

denominador del Rta: 5
receptor
asFloat Devuelve el receptor (1/3)asFloat Kernel-Numbers/Fraction/converting
como un nmero de Rta:
punto flotante 0.3333333333333333
3.8.3.2 CARACTERES
Las instancias de la clase Character representan caracteres del cdigo ASCII; hay por lo tanto 256
instancias de sta clase. [Cuenca].
En adicin a los heredados de Magnitude, los principales mensajes que comprenden las instancias de
Character son los siguientes:

isAlphaNumeric Devuelve true si el receptor $v isAlphaNumeric Kernel-
es un carcter alfanumrico Rta: true BasicObjects/Character/testi
ng
isDigit Retorna true si el receptor $5 isDigit Kernel-
es un dgito del 0 al 9 Rta:true BasicObjects/Character/testi
ng
isLowercase Retorna true si el receptor $a isLowercase Kernel-
es un carcter en minscula Rta: true BasicObjects/Character/testi
ng
asUppercase Retorna el receptor en $a asUppercase Kernel-
maysculas Rta: $A BasicObjects/Character/testi
ng
3.8.3.3 FECHAS Y HORAS
Las clases Date y Time permiten obtener objetos que representan respectivamente fechas y horas. [Cuenca].
3.8.3.3.1 CLASE DATE

La fecha de hoy puede obtenerse con la siguiente expresin:

Date today
Retorna la nueva fecha vigente, por ejemplo: 21 July 2014
En general, una fecha cualquiera puede obtenerse con el siguiente mensaje:
Date newDay: nroDa month: nombreMes year: nroAo
Por ejemplo:
Date newDay: 10 month: #july year: 1982
Nos devuelve un objeto representando la fecha: 10 de Julio de 1982
Para evitar escribir el nombre del mes en el keyword month: ; es posible utilizar el servicio de traduccin
ofrecido por la clase Date:
Date newDay: 10 month: (Date nameOfMonth: 2) year: 1982
Los principales mensajes ofrecidos por las instancias de Date son los siguientes (en los ejemplos se asumir
que la variable unaFecha se refiere al objeto creado con la expresin anterior, es decir: 10/7/1982):

dayOfMonth Retorna el da del mes unaFecha dayOfMonth Kernel-
Rta: 10 Chronology/DateAndTime/accessing
monthIndex Devuelve el unaFecha monthIndex Kernel-

denominador del Rta: 7 Chronology/DateAndTime/accessing
receptor
Year Devuelve el receptor unaFecha year Kernel-
como un nmero de Rta: 1982 Chronology/DateAndTime/accessing
punto flotante
addDays: Retorna otra fecha que unaFecha addDays: 30 Kernel-Chronology/Date/adding
unNumero resulta de sumar Rta: 9 August 1982
unNumero das al
receptor
subtractDays: Retorna otra fecha que unaFecha Kernel-Chronology/Date/adding
unNumero resulta de restar subtractDays: 10
unNumero das al Rta: 30 June 1982
receptor
subtractDate: Retorna la cantidad de supongamos fecha2 = Kernel-Chronology/Date/adding
24 Enero 1982

otraFecha das que separan al unaFecha

receptor de otraFecha subtractDate:
unaFecha2
Rta: 167
Mmddyyy Retorna un String unaFecha mmddyyyy Kernel-Chronology/Date/printing
conteniendo una Rta:'7/10/1982'
representacin
imprimible del receptor
Ejemplos de ejecucin en la ventana Transcript o Workspace [Cuenca]:
Ejemplo 1:
|unaFecha|
unaFecha:= Date newDay:10 month:#July year: 1982.
unaFecha dayOfMonth
Rta: 10
Ejemplo 2:
|unaFecha unaFecha2|
unaFecha:= Date newDay:10 month:#July year: 1982.
unaFecha2:= Date newDay:24 month:#January year: 1982.
unaFecha subtractDate: unaFecha2
Rta: 167
3.8.3.3.2 CLASE TIME

Las instancias de Time representan un instante particular del da, expresado en segundo desde
medianoche.
Para obtener la hora actual, se utiliza la expresin:
Time now

Para crear un objeto que represente un instante de tiempo en especial, se utiliza el mensaje:
Time fromSeconds: cantSegundosDesdeLasCeroHoras
Las instancias de Time responden a los siguientes mensajes (los ejemplos asumen que la variable unTiempo
ha sido inicializada con la siguiente expresin: Time fromSeconds: ( (60*60*6) + (30*60) ) Equivalente a las
6:30 a.m ).

Hours Retorna la hora unTiempo hours Kernel-
Minutes Retorna los minutos unTiempo minutes Kernel-

Seconds Retorna los segundos unTiempo seconds Kernel-

addTime: Retorna otro objeto supongamos que Kernel-Chronology/Time/adding

otroTime Time que resulta de unTiempo2 es 1 hora
30 min 50 seg
sumar otroTime al
unTiempo addTime:
receptor
unTiempo2
Rta: 8:00:50 am
subtractTime: Retorna otro objeto supongamos que Kernel-Chronology/Time/adding
otroTime Time que resulta de unTiempo2 es 1 hora
30 min 50 seg
restar otroTime al
unTiempo addTime:
receptor
unTiempo2
Rta: 4:59:10 am
Ejemplo 1:
|unTiempo|
unTiempo:= Time fromSeconds: ( (60*60*6) + (30*60)).
unTiempo minutes
Rta: 30
Ejemplo 2:

supongamos que unTiempo2 es 1 hora 30 min 50 seg
|unTiempo unTiempo2|
unTiempo:= Time fromSeconds: ( (60*60*6) + (30*60)).
unTiempo2:= Time fromSeconds: ((60*60) + (30*60) + (50)).
unTiempo addTime: unTiempo2
Rta: 8:00:50 am
3.8.4 BOOLEANOS
Los objetos booleanos representan valores de verdad y falsedad. Existen solo 2 objetos booleanos: true
y false, instancias respectivamente de las clases True y False, subclases a su vez de la clase abstracta
Boolean.
Object
Boolean
True False
Los objetos booleanos se obtienen principalmente a travs de la comparacin de magnitudes.
Los objetos booleanos definen mensajes para permitir la construccin de expresiones lgicas:

& AND
| OR
3.8.5 BLOQUES
Los bloques son objetos que representan secuencia de expresiones Smalltalk (cdigo). [Cuenca].
Los bloques ms altos son objetos instancias de la clase HomeContext y los bloques anidados son instancias
de la clase Context. No es posible crear bloques mediante el envo del mensaje new a Context o
HomeContext. [Lalonde97].
Object
`Context
HomeContext
Un bloque est formado por una secuencia de sentencias separadas por punto y encerrada entre corchetes.
Ejemplo:

| a b c |
[ a:= 5. b:= 7. c:= a negated + b factorial ].
La secuencia de instrucciones contenida en el bloque se ejecuta cuando el bloque recibe el mensaje value. El
resultado de la evaluacin del bloque es igual al valor de la ltima sentencia del bloque.
Si evaluamos el bloque del ejemplo anterior, obtenemos:
| a b c |
[ a:= 5.
b:= 7.
c:= a negated + b factorial
] value
Resultado: 5035
Los bloques constituyen objetos como cualquier otro, por lo cual pueden ser asignados a variables:
| a b c unBloque|
unBloque := [ a:= 5.
b:= 7.
c:= a negated + b factorial
].
unBloque value Resultado: 5035
Un bloque sin instrucciones se denomina bloque nulo y al ser evaluado devuelve nil.
| bloqueNulo |
bloqueNulo := [ ].
bloqueNulo value Resultado: nil
Un bloque puede recibir ninguno, uno o dos parmetros. En cada uno de esos casos la sintaxis es la
siguiente:
[ sentencias ]. ningn parmetro
[ : x | sentencias ]. un parmetro
[ :x :y | sentencias ]. dos parmetros
Los mensajes para evaluar bloques de uno y dos parmetros son, respectivamente:
value: parmetro

value: parmetro value: parmetro2
Ejemplos:
bloque de un parmetro
| unBloque |
unBloque := [ :x | x*2 ].
Paso de mensajes al bloque con un parmetro:
unBloque value: 2 Resultado: 4
unBloque value: 3 Resultado: 6
bloque de dos parmetros

| unBloque |
unBloque := [ :x :y | x + y ].
Paso de mensajes al bloque con dos parmetros:
unBloque value: 2 value: 3 Resultado: 5
unBloque value: 5 value: -8 Resultado: -3
El principal uso de los bloques es en la construccin de estructuras de control. Adems, pueden

utilizarse para construir objetos que encapsulen algoritmos.
3.8.5.1 ESTRUCTURAS DE C ONTROL

En Smalltalk, las estructuras de control se construyen a partir de mensajes enviados a objetos
booleanos, bloques y nmeros, y de la cooperacin entre ellos.
3.8.5.1.1 ESTRUCTURAS CONDICIONALES

Se forman enviando mensajes a objetos booleanos y evaluando bloques si las condiciones se cumplen.
Ejemplos:
( a>b ) ifTrue: [ c:= a + b ]. Ejecuta el bloque si la condicin es verdadera
( a=b ) ifFalse: [ c:= a + b]. Ejecuta el bloque si la condicin es falsa.
( a>=b ) Ejecuta el bloque [ c:= a + b ] si la condicin
ifTrue: [ c:= a + b ]. es verdadera; en caso contrario, ejecuta

ifFalse: [ c:= a - b ]. el otro bloque.
Ejemplo completo para ejecutar en el framework:
3.8.5.1.2 ESTRUCTURAS REPETITIVAS DETERMINADAS

Se forman a partir de mensajes enviados a nmeros entero y bloques de un parmetro.
Ejemplo 1:
1 to: 10 Itera de 1 hasta 10, imprimiendo los sucesivos nmeros
do: [ :x | Transcript show: x; cr]. en la ventana Transcript.
Resultado visualizado en la ventana Transcript:

Ejemplo 2:
0 to: -10 Itera de 0 a -10, de a dos valores por vez, e imprime
by: -2 esos valores en la ventana Transcript.
do: [ :x | Transcript show: x; cr.]
Resultado visualizado en la ventana Transcript

:

3.8.5.1.3 ESTRUCTURAS REPETITIVAS INDETERMINADAS (O CONDICIONALES )

Se forman a partir de mensajes a bloques que evalan en valores booleanos.
|k total|
k:= 1.
total:= 0. Repite el segundo bloque mientras la condicin
k<10 sea verdadera.
[ k<10]
whileTrue: [
total:= total + k factorial.
Transcript show: total; cr.
k := k +1
]
|k total|
k:= 1.
total:= 0. Repite el segundo bloque mientras la condicin k=0 sea falsa.

[k=0]
whileFalse: [ total:= total + k factorial.
k := k -1].
Transcript show: total.
3.8.5.1.4 RESOLUCIN DE CASO DE ESTUDIO
Se requiere desarrollar un programa orientado a objetos en Smalltalk, que permita modelar los artculos que
tiene a la venta un comercio. De cada artculo se conoce su:
Cdigo, es un valor numrico que identifica a cada artculo.
Descripcin, correspondiente al nombre del artculo.
Costo, que representa el costo de compra en pesos del artculo.
Tipo, los valores que puede asumir son: 1, 2, 3.
Stock, que representa la cantidad de unidades disponibles en stock del artculo.
Adems, cada artculo debe exhibir el siguiente comportamiento:
a) precioVenta, que calcule el precio unitario de venta el cual se calcula sumndole al costo un porcentaje
de ganancia que depende directamente del tipo de artculo. Si es tipo 1 el porcentaje de ganancia es el
10%; si es tipo 2, el porcentaje de ganancia es del 20%; si es tipo 3, el porcentaje de ganancia es del
25%.

b) += unaCantidad, que permita incrementar el stock actual del artculo en una cierta cantidad, siempre y
cuando esta cantidad fuese mayor o igual a cero.
a) -= unaCantidad, que permita descontar del stock actual del artculo una cierta cantidad, siempre y
cuando el stock sea mayor o igual a esta cantidad, y esta cantidad fuese positiva o cero.
c) calcularImporteTotalStock, que calcule el importe total de venta que se obtendra de todo el stock de
artculos.
d) asString, que devuelva todos los datos del artculo.
Object subclass: #Articulo "Autor: Ing. Nicolas Colaccioppo"

instanceVariableNames: 'codigo descripcion tipo costo stock'
category: 'EjPrimeraSemana-GestinArtculos'
initialize
"inicializa los atributos de un artculo con valores por defecto"
self codigo: 0.
self descripcion: 'no especificado'.
self costo:0.
self tipo: 1.
self stock: 0.
codigo
"devuelve el valor de cdigo"
^ codigo
codigo: unCodigo
"asigna unCodigo al atributo cdigo del artculo"
codigo:=unCodigo.
costo
"Devuelve el valor de costo"
^ costo
costo: unCosto
"asigna unCosto al atributo costo del artculo siempre y cuando unCosto
sea Number y sea positivo o 0"
unCosto isNumber
ifTrue:
[
(unCosto>=0.0)
ifTrue:
[
costo:=unCosto.
^true.
].

].
^false.
descripcion
"Devuelve el valor de descripcion"
^ descripcin
descripcion: unaDescripcion
"asigna unaDescripcion al atributo descripcin del artculo"
descripcion:=unaDescripcion.
stock
"Devuelve el valor de stock"
^ stock
stock: unStock
"asigna unStock al atributo stock del artculo siempre y cuando unStock
sea Number y sea positivo o 0"
unStock isNumber
ifTrue:
[
(unStock>=0)
ifTrue:
[
stock:=unStock.
^true.
].
].
^false.
tipo
"Devuelve el valor de tipo"
^ tipo
tipo: unTipo
"asigna unTipo al atributo tipo del artculo siempre y cuando unTipo sea
Integer y est comprendido entre 1 y 3"
unTipo isInteger
ifTrue:
[
((unTipo>=1) & (unTipo<=3))
ifTrue:
[
tipo:=unTipo.
^true.
].
].
^false.
asString
"devuelve todos los datos del artculo"
^String cr, 'Cdigo: ',self codigo asString, String cr, 'Descripcin:

',self descripcion asString, String cr, 'Tipo: ',self tipo asString, String
cr, 'Stock: ',self stock asString.
+=unaCantidad
"agrega unaCantidad al stock de artculos"
unaCantidad isNumber
ifTrue:
[
unaCantidad>=0
ifTrue:
[
self stock: self stock + unaCantidad.
].
].
-=unaCantidad
"descuenta unaCantidad del stock de artculos"
unaCantidad isNumber
ifTrue:
[
self stock >= unaCantidad
ifTrue:
[
self stock: self stock - unaCantidad.
].
].
importeTotalEnStock
"devuelve el importe total de todos los artculos en stock"
^self stock * self importeVenta.
importeVenta
"devuelve el importe de venta unitario en base al costo y tipo de
artculo"
|porcGanancia|
porcGanancia:=10. "Por defecto asumimos que es tipo 1"
(self tipo = 2)
ifTrue: [
porcGanancia:=20.
]
;
ifFalse: [
(self tipo = 3)
ifTrue: [
porcGanancia:=25.
].
].
^self costo + (self costo * (porcGanancia/100) asFloat).

En Workspace:
|art|
art:=Articulo new initialize.
Transcript show: art asString; cr.
art codigo:1; descripcion:'Mouse'; tipo:4; costo: 100; stock:100.

Transcript show: 'Importe total en stock: $',art importeTotalEnStock; cr.
art -=30.
art+=50.
3.9 COLECCIONES EN SMALLTALK

3.9.1 INTRODUCCIN
Imaginemos querer modelar una agenda para una semana. Creamos nuestra clase Semana y, como
sabemos que los das de la semana son 7, creamos 7 variables de instancia para cada uno de ellos en la
clase. Esta situacin no siempre es posible representar slo con variables de instancias. Muchas veces vamos
a necesitar modelar relaciones entre un objeto y varios (una relacin 1 a N). Por ejemplo, los departamentos
de un edificio, los estudiantes de una universidad, etc. En muchas oportunidades no vamos a poder conocer
el nmero total o mximo de elementos o simplemente slo sabremos que van a ser muchos. Para tales
situaciones nos van a servir las colecciones.
Las colecciones permiten agrupar objetos para poder operar sobre ellos. En general podremos
referirnos a esa coleccin de objetos bajo un mismo nombre, y poder agregar o sacar objetos, filtrarlos,
recorrerlos y muchas otras cosas de manera mucho ms sencilla. Las colecciones nos van a permitir modelar
conjuntos de objetos, como ser: las piezas de un tablero, los empleados de una fbrica, la flota de buques de
una empresa de transporte fluvial, etc. y poder realizar operaciones sobre ese grupo.
Las colecciones se pueden ver como un conjunto de objetos, y de hecho vamos a decir eso
normalmente (abusando del lenguaje), pero en realidad las colecciones son conjuntos de referencias a
objetos; es decir, los objetos no estn adentro de la coleccin, sino que la coleccin los conoce (los
referencia) de alguna forma. Es importante aclarar que, conceptualmente, la coleccin no tiene adentro
suyo a sus elementos. Al agregar un objeto a la coleccin simplemente se agrega una referencia que parte
de la coleccin y llega al objeto agregado. Es importante destacar tambin que los objetos que se agregan
a una coleccin pueden estar referenciados por otros objetos que existan y que no necesariamente estn
relacionados con la coleccin.
Los objetos agregados pueden ser incluso otras colecciones, dado que las colecciones son tambin objetos.

Pero, y si las colecciones son un conjunto de objetos (o referencias ms correctamente), cmo las
representamos? Sabemos que en Smalltalk slo tenemos objetos y mensajes, por lo cual las colecciones van
a ser representadas como...objetos!!!
Resumiendo, un objeto coleccin es un objeto que representa un conjunto de referencias a otros

objetos, con el cual se van a poder realizar distintas operaciones sobre los elementos que ella referencia.
Qu operaciones podemos hacer con una coleccin?

Para poder responder ms fcilmente y poder comprenderlo, vamos a elegir un ejemplo: una
coleccin de CDs.
Con la coleccin de CDs podemos:
Mirar los CDs (recorrer la coleccin)
Organizarlos por artista (ordenar la coleccin)
Agregar nuevos CDs (agregar elementos a la coleccin)
Regalar un CD (quitar elementos de la coleccin.
Quedarme con los CDs de rock nacional (hacer un filtro o seleccin de los elementos segn un
criterio)
Saber si tengo un CD de Kill Bill (preguntarle a una coleccin si incluye o no un determinado objeto
como elemento)
Y cmo se modela este comportamiento con objetos de Smalltalk?

La respuesta debera ser obvia: con mtodos definidos para las colecciones. Es decir, podemos crear
nuestra instancia de coleccin que representa a nuestra coleccin de CDs y a ese objeto enviarle mensajes
para agregarle un nuevo objeto CD, para que nos filtre los CDs de rock nacional, etc.
En Smalltalk no estamos limitados en cuanto al tipo de objeto que podemos agregar. Por ejemplo,
podemos agregar a nuestra coleccionCDs un nmero, un String, una fecha... lo que sea. Se dice que las
colecciones en Smalltalk son heterogneas dado que permiten que cualquier objeto de cualquier clase
pueda ser agregado a ellas junto con otros objetos de otras clases.
Las colecciones de Smalltalk son polimrficas y presentan un protocolo unificado, por lo que todas
las diferentes formas de colecciones provistas por el entorno responden a un mismo conjunto de mensajes
bsicos, lo que facilita su aprendizaje y el cambio de un tipo de coleccin a otra. [Cuenca].
El siguiente grfico muestra la jerarqua de colecciones de Smalltalk/V [Cuenca]:

Object
Collection
Bag IndexCollection
Set
OrderedCollection FixedSizeCollection Dictionary
SortedCollection Array String Interval
Symbol
Existen en esta jerarqua clases abstractas y concretas.
CLASES ABSTRACTAS [Cuenca]:
Collection: define el comportamiento comn a todas las posibles formas de representar colecciones.
IndexedCollection: representa una forma ms especializada de coleccin en donde es posible acceder a
cada elemento de la coleccin por medio de subndices numricos.
FixedSizeColletion: especializa IndexCollection parar representar colecciones subindicables con una
cantidad fija de elementos. Sus subclases concretas permiten manejar arreglos (Array), cadenas de
caracteres (String) e intervalos numricos (Interval).
CLASES CONCRETAS [Cuenca]:
Set y Bag son colecciones desordenadas, las instancias de Bag admiten duplicados, mientras que las de
Set no.
OrderedCollection es una coleccin indexada en la que se mantiene el orden en que los objetos son
insertados. Tiene una subclase, SortedCollection, en la cual es posible especificar que los elementos de
la coleccin se ordenen siguiendo un criterio especfico (por ejemplo, de menor a mayor).
Dictionary es una coleccin que mantiene asociaciones entre objetos llamados claves (keys) y valores
(values).

3.9.2 SET1
La primera clase que vamos a usar es una coleccin que se llama Set. Un Set representa un conjunto
entendido como los conjuntos matemticos que aprendimos en la escuela.
El orden de los objetos agregados en una coleccin Ser no corresponde con el orden de insercin de
los mismos y tampoco tiene un criterio de orden detectable. sta es una de las caractersticas que distinguen
a un Set entre otros tipos de colecciones que existen en Smalltalk: los elementos no estn ordenados. La
otra caracterstica de un Set es que no repite sus elementos, es decir que si agregamos dos veces un mismo
objeto, no aparecer dos veces en l.
Para crear una coleccin Set y asignarla a una variable que represente a nuestra coleccin de CDs,
escribimos:
coleccionCDs := Set new.
Supongamos que tenemos definida la clase de los CDs. Creamos instancias de CDs y los agregamos
a nuestro conjunto coleccionCDs, mandndole el mensaje add:. Definimos adems un cuarto CD que no
agregamos.
cd1 := CD new.
cd1 titulo: Abbey Road.
cd1 autor: The Beatles.
cd1 origen: U.K..
cd2 := CD new.
cd2 titulo: Tribalistas.
cd2 autor: Tribalistas.
cd2 origen: Brasil.
cd3 := CD new.
cd3 titulo: Peluson of milk.
cd3 autor: Spinetta.
cd3 origen: Argentina.
cd4 := CD new.
cd4 titulo: Piano Bar.
cd4 autor: Charly Garca.
cd4 origen: Argentina.
coleccionCDs add: cd1.

A este conjunto se le pueden enviar algunos mensajes:
coleccionCDs size. => devuelve 3
1
Basado en el apunte Colecciones en Smalltalk de la Universidad Tecnolgica Nacional Facultad Regional Buenos
Aires (ctedra de Paradigmas de Programacin), de Victoria Pocladova, Carlos Lombardi, Leonardo Volinier y Jorge Silva.

coleccionCDs isEmpty. => devuelve false ya que la coleccin tiene

elementos
coleccionCDs includes: cd2. => devuelve true
coleccionCDs includes: cd4. => devuelve false
3.9.3 BAG2
Esta coleccin es de las denominadas sin orden y es la representacin de una bolsa. Una bolsa de
objetos. El Bag es la coleccin ms adecuada para representar por ejemplo un carrito o bolsa de
supermercado. Imagnense que puedo poner tres latas de tomates, dos botellas de agua y siete peras.
Imagnense que tengo una lata de tomates. Lo vamos a representar as:
unaLata := LataDeTomates new.

unaLata conTomates: perita.
unaLata deLaMarca: La Marca que a uds les guste
unaLata conPrecio: 1.00
Bien, tenemos el objeto unaLata y queremos agregar a mi carrito de compras 3 latas de tomates.
Entonces hago:
miCarrito add: unaLata.

En mi carrito debera haber 3 latas de tomates. Pero, como vimos, si representamos a mi carrito de
compras con un Bag s voy a tener 3 objetos dentro de mi carrito.
El Set est concebido para la representacin de conjuntos. Una propiedad distintiva sobre conjuntos
es que los elementos que pertenecen al conjunto son nicos en l. Es decir, en los conjuntos no vamos a
tener dos veces el mismo elemento (no admite repetidos). Salvo por esta propiedad, el comportamiento es
el mismo que el del Bag.
3.9.4 ORDEREDCOLLECTION
Es una coleccin indexada en la que se mantiene el orden en que los objetos son insertados o agregados
a la coleccin [Cuenca]. Al contrario de un Set o un Bag, en donde los elementos estn "todos tirados".
Operaciones que se pueden llevar a cabo con las colecciones indexadas:
2

Mensaje
at: indice put: unObjeto Coloca unObjeto en la posicin indice de la coleccin (ndice debe ser un
nmero entero)
at: indice Retorna el objeto ubicado en la posicin indice de la coleccin
indexOf: unObjeto Retorna el ndice de la posicin que unObjeto ocupa en la coleccin ( uno
(1) es el ndice del primer elemento). Si unObjeto no figura en la coleccin,
devuelve cero (0)
indexOf: unObjeto Retorna el ndice de la posicin que unObjeto ocupa en la coleccin ( uno
ifAbsent: unBloque (1) es el ndice del primer elemento). Si unObjeto no figura en la coleccin,
evala unBloque
First Retorna el primer elemento de la coleccin
Last Devuelve el ltimo elemento de la coleccin
copyFrom: inicio to: fin Retorna una coleccin conteniendo los elementos del receptor
comprendidos entre inicio y fin.
replaceFrom: inicio to: fin Reemplaza los elementos del receptor comprendidos entre inicio y fin por
with: otraColeccion los objetos contenidos en otraColeccion
with: otraColeccion los objetos contenidos en otraColeccion, extrayndolos a partir de la
posicin otroIndice
startingAt: otroIndice
withObject: unObjeto unObjeto
Si creamos mi coleccin as3:
miCol := OrderedCollection new.

miCol add: 'esto'.
miCol add: 'es'.
miCol add: 'un'.
miCol add: 'ejemplo'.
Despus podemos pedirle varias cosas:
miCol first el primero 'esto'

miCol last el ltimo 'ejemplo'
miCol at: 3 el tercero 'un'
miCol at: 4 el cuarto 'ejemplo'
miCol size cantidad de elementos 4
3

Y podemos seguir agregndole elementos, ante lo cual la coleccin "se estira", pues tiene un tamao
variable (a diferencia de un array que veremos ms adelante).
miCol add: 'agrego'.

miCol add: 'cosas'.
miCol size cantidad de elementos ahora 6
miCol last el ltimo ahora 'cosas'
Aqu presentamos otro ejemplo:
l unString fragmento l
unString := 'Hola, buenos das'.
fragmento := unString copyFrom: 7 to: (unString size).
fragmento Resultado: 'buenos das'
3.9.5 SORTEDCOLLECTION
La clase SortedCollection [Cuenca] provee colecciones ordenadas segn un criterio especifico.
Si no definimos el criterio, la SortedCollection ordena los elementos por su orden natural

(significa que los ordenar de menor a mayor, usando el mensaje <). Dicho de otra forma, no ordena por
orden de llegada, sino por comparacin entre los elementos.
Si se instancia una SortedCollection con la expresin:
SortedCollection new
Se obtiene una coleccin que ordena sus elementos de menor a mayor. Esto implica que los objetos
contenidos en una Sortedcollection que utiliza el criterio de ordenamiento por defecto deben poder
responder al mensaje <=.
Ejemplo 1:
| unaSortedCollection |
unaSortedCollection := SortedCollection new.
unaSortedCollection add: 1 => ( 1 )
unaSortedCollection add: 5 => ( 1 5 )
unaSortedCollection add: 2 => ( 1 2 5 )
unaSortedCollection add: 4 => ( 1 2 4 5 )

unaSortedCollection add : -8 => ( -8 1 2 4 5 )
Ejecucin del ejemplo:
Si queremos ordenar los elementos de la coleccin con un criterio en particular, necesitamos

pasrselo a la coleccin ya creada. La forma de hacerlo, es pasarle lo que denominamos sortBlock, que es
un bloque (objeto de la clase BlockClosure).
Para especificar un algoritmo de ordenamiento diferente, la coleccin debe instanciarse con la

siguiente expresin:
SortedCollecion sortBlock: unBloqueBinario
En donde unBloqueBinario es un bloque de dos parmetros cuya misin es determinar si el primero

de ellos debe ubicarse antes que el segundo.
Ejemplo: crear una coleccin que ordene de mayor a menor:
l unBloque unaColeccion l
unBloque := [ :x :y | x >= y ].
unaColeccion := SortedCollection sortBlock: unBloque.
Ejecucin del ejemplo:

Una SortedCollection puede reordenarse en cualquier momento envindole el mensaje:
unaSortedCollection sortBlock: otroBloqueBinario
Acerca del sortblock4
El sortBlock es un bloque que necesita 2 parmetros, que son los objetos a comparar. El cdigo del
bloque es un cdigo que debe devolver true o false. Para ordenar los objetos dentro de la coleccin, se
evala el cdigo y si el objeto retornado es true, el primer parmetro va antes que el segundo. Si retorna
false, el segundo parmetro se ubica antes que el primero.
3.9.6 ARRAY
Array es una coleccin donde su caracterstica distintiva es que es de tamao fijo. Por ejemplo, para
instanciar un Array, hacemos Array new: 6, donde 6 es la cantidad de elementos que contendr.
En casos especiales donde los elementos son literales booleanos, strings o numeros, se pueden crear los
arreglos de la siguiente forma:
# (objeto1 objeto2 objeto3 . . . objetoN)
que representa una instancia de Array conteniendo los objetos que se indican.
Los arreglos literales son especialmente tiles para crear colecciones inicializadas.
4

Ejemplo 1: #(1 2 3 4 5) class "Resultado: "
Ejemplo 2: #('hola' true 5 1/3 $D) class "Resultado: "
Los Arrays no implementan el mensaje add:, justamente porque no se pueden modificar su tamao.
La forma de agregarles elementos es a travs del mensaje at:put:, como por ejemplo:
miVector := Array new: 2.

miVector at: 1 put: unaLata.
3.9.7 DE UN TIPO A OTRO
Si bien los arreglos literales son instancia de Array, es posible obtener a partir de ellos una instancia
de la clase deseada usando los mensajes de conversin; por ejemplo: [Cuenca]

#(1 2 3 4 5 ) asOrderedCollection
#(1 2 3 4 5 ) asSet
#(1 2 3 4 5 ) asBag
#(1 2 3 4 5 ) asSortedCollection
Todas las colecciones5 entienden una serie de mensajes que permiten obtener distintos tipos de
colecciones con los mismos elementos que la coleccin receptora. Estos mensajes son de la forma
as{ColeccionQueQuiero}.
Por ejemplo, si tuviese una coleccin de la clase Bag, y quiero sacarle los repetidos, s que el Set no tiene
repetidos, entonces tomo mi coleccin como un Set. Hacemos lo siguiente:
sinRepetidos := miCarrito asSet.
Si tuviese un array, y lo quiero convertir en una coleccin de tamao variable, podra hacer:
coleccionVariable := miVector asOrderedCollection.
Si quisiera ordenar mi carrito de compras del producto ms caro al ms barato, hara algo como:
ordenadosPorPrecio := miCarrito asSortedCollection:

[:unProd :otroProd | unProd precio > otroProd
precio].
El mensaje asSortedCollection: recibe un parmetro que, obviamente, es un sortBlock.
Tambin est el mensaje asSortedCollection (o sea sin el dos-puntos, o sea que no requiere parmetro) que,
como dijimos antes, ordenar los elementos por el orden natural, dado por el mensaje <. En este caso,
5

debemos tener en cuenta que todos los objetos que agreguemos a esta coleccin debern entender el
mensaje <, pues si as no fuera, tendramos un error de mensaje no entendido.
3.9.8 OPERACIONES SOBRE COLECCIONES
3.9.8.1 C REACIN DE INSTANCIAS

Para crear colecciones se debe enviar alguno de los siguientes mensajes a la clase que se debe instanciar:
Mensaje Ejemplos
New Instancia una coleccin, sin especificar OrderedCollection new

el tamao inicial Dictionary new
new: tamaoInicial Instancia una coleccin, con un cierto Array new: 20
tamao inicial
with: unObjeto Instancia una coleccin conteniendo OrderedCollection with:
inicialmente unObjeto 'Hola'
with:objeto1 with:objeto2 Instancia una coleccin conteniendo Array with:1 with:2

inicialmente los dos objetos indicados
with:objeto1 with:objeto2 Instancia una coleccin conteniendo Set with:1 with:true
inicialmente los tres objetos indicados with:'Hola'
with:objeto3
with:objeto1 with:objeto2 Instancia una coleccin conteniendo SortedCollection with:1
inicialmente los cuatro objetos with:6 with:4.5 with:1/3
with:objeto3 with:objeto4
indicados
Nota:
Los mensajes new y new: tamao inicial son ilegales en intervalos.

with: no son aplicables a intervalos y diccionarios.
Ejemplo:

3.9.8.2 C ONSULTA
Mensaje
Size Devuelve la cantidad de elementos contenidos en la coleccin
isEmpty Retorna true si la coleccin est vaca
notEmpty Retorna true la coleccin contiene algn objeto
includes: unObjeto Retorna true si la coleccin incluye a unObjeto
ocurrencesOf: unObjeto Retorna la cantidad de elementos de la coleccin que son iguales a unObjeto
Ejemplo 1:
| unaColeccion |
unaColeccion := OrderedCollection new.
unaColeccion isEmpty Respuesta: true
unaColeccion size Respuesta: 0
unaColeccion := #( 2 'Hola').
unaColeccion size Respuesta: 2
unaColeccion includes: 2 Respuesta: true
unaColeccion includes: 5 Respuesta: false
unaColeccion := Array with:1 with:5 with:2 with:5.
unaColeccion ocurrencesOf: 5 Respuesta: 2
Ejemplo 2:
De la ltima cadena de caracteres agregada a la coleccin, el mensaje size devuelve su cantidad de

caracteres.

Ejemplo 3:
Ejemplo 4 (utilizando variables):
Utilizando variables, el mensaje size devuelve la cantidad de elementos que posee la coleccin.
3.9.8.3 AADIR Y REMOVER OBJETOS

Mensaje
add: unObjeto Agrega unObjeto a la coleccin
addAll: otraColeccion Agrega otraColeccion a la coleccin receptora
remove: unObjeto Elimina el primer unObjeto que encuentra en la coleccin. Si unObjeto no
est incluido en la coleccin, genera un error
remove: unObjeto Elimina unObjeto de la coleccin. Si unObjeto no est incluido en la
ifAbsent : unBloque coleccin, ejecuta unBloque
removeAll: otraColeccion Elimina de la coleccin receptora los objetos incluidos en otraColeccion
Nota: Estos mensajes son ilegales en instancias de FixedSizeCollection.

Ejemplo 1:
Ejemplo 2:
Ejemplo 3:

3.9.8.4 RECORRIDO
Mensaje
do: unBloque Evala unBloque para cada elemento de la coleccin, pasndole cada
elemento de la coleccin como parmetro a unBloque
select: unBloque Evala unBloque para cada elemento de la coleccin.
Retorna una nueva coleccin conteniendo todos aquellos elementos que
hicieron que unBloque evaluara en true
reject: unBloque Evala unBloque para cada elemento de la coleccin.
Retorna una nueva coleccin conteniendo todos aquellos elementos que
hicieron que unBloque evaluara en false
collect: unBloque Evala unBloque para cada elemento de la coleccin.
Retorna una nueva coleccin conteniendo el resultado de las sucesivas
evaluaciones del bloque
detect: unBloque Evala unBloque para cada elemento de la coleccin.
Retorna el primer elemento que haga que unBloque evale en true. Si
ningn elemento cumple la condicin, provoca un error
detect: unBloque Evala unBloque para cada elemento de la coleccin.
ifNone: bloqueExcepcion Retorna el primer elemento que haga que unBloque evale en true. Si
ningn elemento cumple la condicin, bloqueExcepcion es evaluado
inject: objetoInicial Evala unBloqueBinario para cada elemento de la coleccin. Este bloque
into: unBloqueBinario tiene dos parmetros: el segundo es el elemento de la coleccin receptora
del mensaje; el primero es el resultado de la evaluacin de unBloqueBinario
en la intervencin anterior. La primera vez es objeoInicial. Retorna el valor
unBloqueBinario en la ltima iteracin.
Ejemplo 1: Contar cuantas veces figura la letra A en la frase: Hola, que tal?

Ejemplo 2: Encontrar los nmeros pares del arreglo (1 2 3 4 5 6 7 8 9 10)
3.9.9 DICTIONARY
Los diccionarios6 (Dictionary) son un tipo especial de colecciones, ya que sus elementos son pares de claves
y valores. Los objetos que referencia esta coleccin son instancias de una clase particular: Association. En
una Association se tienen dos objetos, uno que juega el rol de clave y el otro el valor. En particular el objeto
nil no puede ser la clave de una asociacin de un diccionario.
Con los diccionarios se pueden representar obviamente diccionarios de palabras o sinnimos, pero tambin
se pueden representar cosas interesantes como una agenda, donde cada elemento del diccionario es una
letra, y el valor asociado son todos los contactos que empiezan con esa letra.
Otra forma de ver a un diccionario es como una lista, donde el acceso a los elementos no se hace por ndice
entero sino por cualquier otro objeto. De hecho, el mensaje para agregar nuevos elementos al diccionario es
at: put:, pero en este caso el primer parmetro puede ser cualquier objeto.
Vemoslo grficamente con un ejemplo de cdigo:
6

dic := Dictionary new.
col1 := OrderedCollection new.

contacto1 := Contacto new: 'Armendariz Garcia' nombre: 'Joaqun'
nro:'8122967'.
contacto2 := Contacto new: 'Andrade Cantu' nombre: 'Rolando' nro:'913-3122'.
col1 add: contacto1.
dic at: 'A' put: col1.
col2 := OrderedCollection new.

contacto3 := Contacto new: 'Blanco Castillo' nombre: 'Juan' nro:''.
contacto4 := Contacto new: 'Barrera Bravo' nombre: 'Felipe' nro:'8120298'.
dic at: 'B' put: col2.
Observar que el diccionario crea una instancia de Association y que cada instancia referencia a la clave y
valor que se agregaron al diccionario.

Ejemplo: una tabla de traduccin que asocie palabras en castellano con su equivalente ingls, tal como la
siguiente:
Clave Valor
Auto Car
Mesa Table
Perro Dog
Gato Cat
Azul Blue
puede implementarse por medio de una instancia de Dictionary:
A diferencia del resto de las colecciones, los diccionarios definen mtodos que permiten realizar
operaciones sobre las asociaciones, sobre los objetos que son clave y sobre los objetos que son valor.
3.9.9.1 INSERSIN Y REMOCIN DE ELEMENTOS

Los mensajes para agregar y eliminar elementos son los siguientes:
Mensaje
at: unaClave put: unValor Inserta unValor en el diccionario y lo asocia a unaClave
removeKey: unaClave Elimina el valor asociado a unaClave. Si unaClave no figura en el diccionario,

produce un error
removeKey: unaClave Elimina el valor asociado a unaClave. Si unaClave no figura en el diccionario, ejecuta
unBloque
ifAbsent: unBloque
Ejemplo 1:
Ejemplo 2:

Ejemplo 3:
3.9.9.2 RECUPERACIN DE ELEMENTOS
Los mensajes bsicos para la recuperacin de los elementos de un Dictionary son los siguientes:

Mensaje
at: unaClave Devuelve el valor asociado a unaClave. Si la clase no figura en el diccionario,
genera un error
at: unaClave Devuelve el valor asociado a unaClave. Si la clase no figura en el diccionario,

ifAbsent: unBloque se ejecuta unBloque
keyAtValue: unObjeto Busca si entre los valores figura unObjeto y si lo encuentra, devuelve la
clave de la que est asociado. En caso contrario, devuelve nil
keyAtValue: unObjeto Busca si entre los valores figura unObjeto y si lo encuentra, devuelve la
ifAbsent: unBloque clave de la que est asociado. En caso contrario, ejecuta unBloque
Keys Retorna una coleccin conteniendo todas las claves del diccionario
Values Retorna una coleccin conteniendo todos los valores del diccionario
Por ejemplo:
Ejemplo 1: unDiccionario at: 5 => #cinco

Ejemplo 2: unDiccionario at: 'Hola' => ERROR!!

Ejemplo 3: unDiccionario keyAtValue: true => #verdadero
Ejemplo 4: unDiccionario keys => (5 #Auto #Perro #Arreglo )
Ejemplo 5: unDiccionario values => ( #Cinco #Car #Dog #(1 2 3 4 5) )

Dentro de un diccionario, los pares clave-valor se almacenan en instancias de la clase Association. [Cuenca].
Las asociaciones pueden recuperarse con los siguientes mensajes:
Mensaje
associationAt: unaClave Devuelve la asociacin que tiene como clave a unaClave. Si la clave no figura
en el diccionario, genera un error
associationAt: unaClave Devuelve la asociacin que tiene como clave a unaClave. Si la clave no figura
en el diccionario, ejecuta unBloque
ifAbsent: unBloque
Una vez obtenida la asociacin, pueden recuperarse la clave y el valor envindole los mensajes key y value
respectivamente.
Ejemplo 1:

Ejemplo 2:
Ejemplo 3:

3.9.9.3 RECORRIDO
En adicin a las operaciones de recorrido heredadas de Collection, Dictionary ofrece adems los siguientes
servicios:
Mensaje
associationsDo: unBloque Para cada asociacin, evaluar unBloque con esa asociacin como
parmetro
associationsSelect: unBloque Para cada asociacin, evaluar unBloque con esa asociacin como
parmetro.
Retorna otra coleccin conteniendo las asociaciones que hicieron que

unBloque evaluara en true
keysDo: unBloque Para cada una de las claves del diccionario, evaluar unBloque con esa clave
como argumento
3.9.10 C MO ELEGIR LA COLECCIN MS ADECUADA?

A continuacin se muestra un algoritmo posible a seguir para seleccionar la coleccin ms adecuada de
acuerdo al problema a modelar. Sin embargo, la eleccin de la coleccin debera hacerse de manera
intuitiva, considerando las caractersticas de cada una de las opciones disponibles.

4. ANEXO I: EJEMPLOS
4.1 EJEMPLO: LA GOLONDRINA

A continuacin realizaremos un ejemplo incremental, el cul ser desarrollado paso a paso de manera de
reforzar lo visto hasta el momento.
La idea Original del presente ejemplo est tomada de Apunte: Introduccin a la orientacin a objetos de
la Asignatura Paradigmas de Programacin UTN FRBA Autores: Carlos Lombardi Nicols Passerini
Este ejemplo ha sido ajustado a la teora explicitada en el presente apunte y ajustado a la

implementacin en Samalltalk Pharo 3.0.
Ejemplo: Doa Pepita

Pongamos como objeto a Pepita, una golondrina tijerita; y analicemos la conducta de distintos
observadores.
A un ornitlogo le puede interesar p.ej. a qu velocidad vuela, qu come, cmo digiere, cunto
pesa, cules son sus patrones de consumo de energa, cules son sus ritos de apareamiento; las
interacciones (lo que va a hacer el ornitlogo con la golondrina) van a ser pesarla, medirla, analizar su
sangre, ponerle comida y esperar que coma, llevar un registro con los momentos en que empieza y para de
volar, medir su velocidad, ponerle un anillo de reconocimiento.
A un fotgrafo de la naturaleza le pueden interesar de Pepita cosas como los colores, el brillo, a qu
horas aparece, tambin los ritos de apareamiento; las interacciones van a ser esperarla, sacarle fotos,
atraerla.
Un zorro con hambre claramente va a tener otra perspectiva acerca de Pepita: le van a interesar
ms que nada el peso y la velocidad; y sus interacciones van a ser bastante primitivas, perseguirla, cazarla
y comrsela.
Resumiendo: a distintos observadores les van a interesar distintas caractersticas y formas de
interaccin con los mismos objetos.
Entonces, de todos los objetos con los que podramos interactuar, nos quedamos con algunos; y de
todas las formas de interactuar con cada objeto, nos quedamos con algunas.
Estas operaciones de recorte forman el modelo que el observador se hace de lo que quiere
observar.
Armar modelos y trabajar en base a ellos es la forma que encontramos las personas para poder
pensar acerca del mundo complejo en el que vivimos (lo que hablbamos al principio).
En qu consiste, dnde est, el modelo que el ornitlogo se hace de Pepita?

En el montn de notas, fotos, cuadros, etc., que tom a partir de sus observaciones; y en lo que
qued en su cabeza que le permite pensar acerca de Pepita.
El modelo es la representacin que el ornitlogo se hizo de Pepita; no es Pepita ni est en ella.

Yo, que soy una persona, digo

Pepita vuela moviendo sus alas como buena golondrina que es
A Pepita no le hacen falta los conceptos de volar, ala ni golondrina para hacer eso que yo
llamo volar.
Resumiendo: el modelo est separado del objeto, queda del lado del observador. El observador
genera una representacin de los objetos con los que interacta.
Y ac es donde entra el software. Los objetos de la orientacin a objetos son las representaciones
computacionales de los entes con los que vamos a interactuar.
Si hago una aplicacin para que el ornitlogo registre la informacin que va obteniendo y genere
reportes y otros resultados, s voy a tener en esa aplicacin un objeto que representa a Pepita. Si un usuario
quiere saber cunto vol Pepita entre el 21 y el 25 de febrero, su velocidad standard de vuelo, su peso, cul
fue el vuelo ms largo que hizo, etc.; se lo va a pedir al objeto que representa a Pepita.
Cuando el ornitlogo quiera registrar un vuelo de Pepita, el resultado de un anlisis, el cdigo de su
anillo identificatorio; es probable que lo haga pidindole a ese objeto que registre la informacin.
El cdigo que voy a escribir es el que va a implementar el objeto que representa a Pepita, de forma
tal de poder registrar todo lo que resulta de las interacciones del ornitlogo, y poder responder
correctamente a las consultas que le puedan interesar al mismo ornitlogo o a otro usuario.
Concentrmonos ahora en el primer pedido: cunto vol Pepita entre el 21 y el 25 de febrero.
Supongamos que la respuesta es 32 km.
Para poder formular la pregunta, el usuario tiene que poder representar de alguna forma las dos
fechas y/o el perodo entre ambas. S, adivinaste: va a haber objetos que representen las fechas, y objetos
que representen perodos de tiempo.
La respuesta tambin va a estar dada por un objeto, que representa la magnitud 32 km, y que
est a su vez compuesto por dos, uno que representa al nmero 32 y el otro a la unidad de medida
kilmetro.
Si le pido el cdigo del anillo identificatorio, me va a responder un cdigo, p.ej. AZQ48. Si ya tens
claro que hay un objeto que representa al cdigo, y tambin hay un objeto que representa a cada letra, le
ests tomando la onda.
Resumiendo: adems de los objetos que representan los entes que tienen sentido para los usuarios
(en este caso Pepita), aparecen muchos objetos ms que representan conceptos ms bsicos (fechas,
distancias, nmeros, cdigos, texto, unidades de medida. Cualquier ente que quiera representar, lo tengo
que representar mediante un objeto; la orientacin a objetos no me da otras formas.
A partir de ahora, en vez de decir el objeto que representa a X vamos a decir el objeto X. P.ej.
vamos a hablar del objeto Pepita, los objetos fecha, los objetos nmero, etc.
Los objetos con los cuales decida trabajar van a conformar el modelo y los vamos a elegir en base
al criterio: Que tenga sentido interactuar con ellos de alguna forma.
Por lo expuesto hasta el momento, claramente va a existir un objeto Pepita; es aquel con el que va
a interactuar el ornitlogo en las formas que describimos ms arriba. A una fecha le puedo pedir el mes, qu
da de la semana es, si eso no anterior a otra fecha, y otras cosas; entonces es probable que aparezcan
objetos fecha. Lo mismo con una distancia (le puedo pedir que se sume a otra distancia, que me diga a

cuntos metros equivale), un nmero (le puedo pedir que se multiplique con otro nmero), un texto (le
puedo pedir la cantidad de letras, si aparece o no cierta letra).
A las interacciones vistas como una unidad las vamos a llamar comportamiento; es la palabra que
se usa en la literatura sobre orientacin a objetos.
Si le quiero indicar al objeto Pepita que Pepita (la golondrina de verdad) comi 30 gramos de alpiste
(lo que el objeto Pepita necesita saber porque eso aumenta su energa), el 30 (o el 30 gramos) va a ser
un parmetro. Si no, el objeto Pepita debera entender un mensaje comiste 30 gramos de alpiste, otro
distinto comiste 50 gramos de alpiste, y as hasta el infinito
Puede haber un resultado, que es la respuesta que obtiene el emisor. P.ej. si le pido al objeto Pepita
la energa, un resultado posible es 48 joules.
Est claro que tanto los parmetros como el resultado son objetos, en los ejemplos de recin el
parmetro es el objeto 30 (o 30 gramos) y el resultado es el objeto 48 (o 48 joules).
Hasta ac queda claro que si el ornitlogo quiere saber cunta energa tiene Pepita en un
determinado momento, lo que tiene que hacer es enviarle el mensaje energa al objeto pepita. Bajemos un
poco a detalle.
El ornitlogo trabaja en un entorno Smalltalk. En el entorno en el que est trabajando, el ornitlogo
tuvo que haber configurado al objeto Pepita.
Para poder interactuar directamente con un objeto, se le pone un nombre dentro del entorno en el
que estoy trabajando; p.ej. pepita. En Smalltalk los nombres de los objetos empiezan en minscula, salvo
excepciones que veremos ms adelante.
La configuracin va a incluir pasarle a pepita las observaciones relevantes; si lo que le interesa es ir
viendo la evolucin de la energa, le va a pasar los registros de los eventos que la afectan, p.ej. las veces que
comi (que aumentan su energa) y las veces que vol (que la disminuyen).
energia
pepita
Despus de esto, slo queda enviarle a pepita el mensaje energa. En cdigo, esto se hace as:
pepita energa
En Smalltalk podemos (y lo vamos a hacer): abrir un entorno de trabajo, configurar ah a pepita,

despus escribir lo que dice arriba, pintarlo y pedirle mostrame el resultado de esto, y anda.
La sintaxis de Smalltalk para enviarle un mensaje a un objeto es:
objeto mensaje

Donde objeto es el nombre que le di al objeto en el entorno en donde estoy escribiendo el

cdigo. As se entiende el ejemplo de arriba; pepita es el (nombre del) objeto, energa es el (selector del)
mensaje.
Y va exactamente as, sin puntos ni parntesis ni nada.
Volviendo: cuando el ornitlogo enva el mensaje pepita energa qu pasa? Obviamente, pasa que
se ejecuta cdigo.
Qu cdigo? Ah vamos. Para que el ornitlogo pueda interactuar con pepita, alguien la tuvo que
programar; donde programar quiere decir: indicar qu mensajes va a entender pepita, y para cada uno
escribir el cdigo que se va a ejecutar cuando pepita lo reciba.
O sea: fue un programador el que decidi que pepita va a entender el mensaje energa, y escribi el
cdigo asociado a ese mensaje. Ese cdigo es el que se va a ejecutar cuando el ornitlogo ejecute pepita
energa.
La seccin de cdigo que se asocia a un mensaje se llama mtodo. Un mtodo tiene un nombre,
que es el del mensaje correspondiente; y un cuerpo, que es el cdigo que se ejecuta.
Un detalle: en la jerga de objetos, se usa mucho el trmino evaluar en vez de ejecutar.
Lo que no vimos es dnde se escriben los mtodos. Para eso falta un rato.
Antes de pasar a otro tema; arriba dijimos el ornitlogo tuvo que haber configurado al objeto
Pepita. Cmo hizo? Obviamente envindole los mensajes que le dicen a pepita lo que le pas a Pepita.
Dicho en general, los que le indican a la representacin computacional lo que le pas al objeto
representado.
Insistimos, la nica forma que tengo de interactuar con un objeto es envindole mensajes. P.ej.
para indicarle que Pepita comi 30 gramos de alpiste una forma posible es
pepita comiAlpiste: 30
Los nombres de mensaje con un parmetro terminan con dos puntos, eso indica que atrs viene un
parmetro; los dos puntos forman parte del nombre. La sintaxis de envo es
objeto mensaje parametro

Ac estamos suponiendo que pepita entiende el mensaje comiAlpiste:, y que el parmetro es un
nmero que expresa la cantidad en gramos.
En el apunte vamos a ir introduciendo ms elementos de la sintaxis de Smalltalk.
Vamos a programar una versin muy simplificada de pepita. Los que queremos que pepita haga es:
lo nico que quiero es poder saber en cada momento cunta energa tiene pepita,
los nicos eventos relevantes son comer alpiste y volar,
el alpiste le brinda 4 joules por cada gramo que come,
en cada vuelo consume 10 joules de costo fijo (es lo que le cuesta arrancar), ms un joule por cada
minuto que vuela,

Para hacerla fcil vamos a representar los joules, gramos y minutos con nmeros, p.ej. la cantidad
30 joules la vamos a representar con el nmero 30.
Los mensajes que va a entender pepita (Protocolo) son:

energa, que devuelve la energa expresada en joules
comiAlpiste:, que registra la ingestin de alpiste; el parmetro es la cantidad expresada en
gramos
vol: que registra un vuelo; el parmetro es la duracin expresada en minutos (no vamos a tener
en cuenta los errores, como que la energa quede negativa despus de volar)
Para implementar este comportamiento, hagamos que pepita recalcule la energa despus de cada
accin; cuando le preguntan la energa, devuelve la que tiene calculada.
Dnde guardo la energa calculada? Ah vamos. A cada objeto le puedo asociar un conjunto de
variables (colaboradores internos), cuyo valor vive entre envos de mensajes al mismo objeto.
Nuestro Modelo de Objetos de pepita , queda:
energia
energiaCalculada
comiAlpiste: gramos
vol: minutos
Pepita
Volviendo, con el planteo que hicimos alcanza con que pepita tenga una sola variable (un solo
colaborador interno), llammosla energaCalculada.
El cdigo para pepita es como sigue, indentando para marcar las distintas partes
Pepita
variables
energaCalculada
mtodos
comiAlpiste: gramos
"Le indican a pepita que comi alpiste; el parmetro es la cantidad expresada en gramos"
energiaCalculada := energiaCalculada + (gramos * 4)
vol: minutos
"Le indican a pepita que vol; el parmetro es la duracin del vuelo expresada en minutos"

energiaCalculada := energiaCalculada - (10 + minutos)

energa
"Devuelve la energa del receptor medida en joules"
ênergiaCalculada
reset
"Vuelve pepita a un estado inicial"
energiaCalculada := 0
La sintaxis es la de Smalltalk; resaltamos algunos elementos

la asignacin es con :=
los comentarios van entre comillas dobles
para indicar el resultado de un mtodo se pone ^resultado (el circunflejo es anlogo al return
en otros lenguajes).
Agregamos reset al comportamiento de pepita para poder hacer muchas pruebas empezando
siempre de 0.
Una observacin interesante: el selector para pedirle la energa a pepita es energa, no
dameTuEnerga, getEnerga u otras variantes. Es la convencin Smalltalk, los selectores que piden info
tienen el nombre de lo que piden sin ningn agregado; en principio conviene adherir a las convenciones del
lenguaje/entorno que usamos. Adems, se escribe menos y el cdigo queda ms legible.
Ahora en el Ambiente Smalltalk Pharo 3.0.

Una vez abierto en ambiente Pharo 3.0., lo primero que hacemos es presionar el botn derecho del
ratn sobre el fondo de la interfaz de la ventana principal, y abrirse un men contextual, seleccionamos la
opcin System Browser.

Se nos abre luego la ventana de System Browser: Nautilus, en la cual podemos crear nuestros
paquetes, con sus clases y sus correspondientes categoras de mtodos y mtodos, modificarlos, entre otras
cosas.
Creamos un paquete llamado PPR-EjemploLaGolondrina.

Luego, en este paquete, creamos la clase Pepita.
Presionamos el botn OK, y agregamos la clase en cuestin a este paquete.

Luego, podemos ir agregando los protocolos y mtodos correspondientes.

En este caso, creamos en forma automtica los siguientes mtodos:

a) De inicializacin o initialize, el cual se agrupa en un protocolo con el mismo nombre.
b) Y los mtodos de acceso y modificacin, los cuales se agrupan en el protocolo accessing.
Luego, creamos un nuevo protocolo llamado negocio, con los mtodos especficos de la clase.

Una vez creados todos estos protocolos, obtendramos lo siguiente:
En la categora negocio creamos los mtodos: comiAlpiste, energa, reset y vol.

Ahora usemos a pepita. En Smalltalk Pharo, esto se puede hacer creando un entorno en el cual se
interacta con el objeto (obviamente, envindole mensajes). Ese entorno es una ventana de texto; el texto
se escribe, se pinta y se evala; si hay un resultado, se muestra en la misma ventana. Los envos de mensajes
se separan con un punto decimal, como si cada uno fuera una oracin.
Supongamos que la simulacin que le interesa al ornitlogo es esta secuencia: comer 50 gramos de
alpiste, volar 5 minutos, comer otros 30 gramos, volar 10 minutos. Entonces abrimos una ventana
Workspace, de la siguiente forma:
a) Para abrir la ventana Workspace, presionamos botn derecho del ratn, y seleccionamos
Worskspace.
b) Se nos abre la ventana Workspace.

c) All escribimos lo siguiente:

|pepita|
pepita := Pepita new.
pepita reset.
pepita comiAlpiste: 50.
pepita vol: 5.
pepita comiAlpiste: 30.
pepita vol: 10.
Pintamos y ponemos evaluar, y listo.

Hasta ac no obtenemos ningn resultado interesante, la evolucin qued en el estado interno de

pepita, a la que ahora le podemos pedir la energa pepita.
pepita energa.
Para visualizar los resultados, usaremos la ventana Transcript, la cual la podemos encontrar presionando el
botn derecho del ratn, seleccionando Tools, y luego Transcript, como se muestra a continuacin.
Una vez que tenemos abierta la ventana Transcript, en la ventana Worskspace, pintamos solamente
esta lnea (pepita energa), y ponemos evaluar. Ahora s me va a dar un resultado interesante, que es 285
como esperbamos.

Veamos ahora el concepto de encapsulamiento

Otro programador podra haber implementado pepita con un estado de dos variables: una para la
energa ingerida, y otra distinta para la energa consumida. Quedara as:
Pepita
variables
energaIngerida
energaConsumida
mtodos
comiAlpiste: gramos
"Le indican a pepita que comi alpiste; el parmetro es la cantidad expresada en gramos"
energaIngerida := energaIngerida + (gramos * 4)
vol: minutos
"Le indican a pepita que vol; el parmetro es la duracin del vuelo expresada en minutos"
energaConsumida := energaConsumida - (10 + minutos)
energa
ênergaIngerida - energaConsumida
reset
"Vuelve pepita a un estado inicial"
energaIngerida := 0
energaConsumida := 0
Esta implementacin es bastante distinta a la anterior.

Ahora viene el ornitlogo y quiere hacer las mismas pruebas de la seccin anterior, usando la nueva
implementacin de pepita.
Repasamos la parte de uso de pepita, qu impacto tuvo el cambio de implementacin en la forma
de usar a pepita? Claramente ninguno, todos los mensajes que el ornitlogo le enviaba a la vieja pepita se
los puede enviar a la nueva pepita, obteniendo los mismos resultados.
Digmoslo de nuevo en trminos ms generales.

Cambiamos bastante la implementacin de un objeto, y el usuario de ese objeto no se enter.

Cmo logramos esto? Porque no cambiamos el protocolo del objeto, o sea el conjunto de
mensajes que entiende; y lo nico que ve el usuario del objeto son los mensajes que entiende, no ve cmo
el objeto lo implementa adentro suyo (mtodos y estado interno).
Trabajando en Smalltalk, el ornitlogo no tiene forma de conocer la forma del estado interno de
pepita, ni sus valores; y tampoco puede acceder a detalles sobre cul es la implementacin que est detrs
de los mensajes que le enva. Lo nico que conoce es el comportamiento que pepita exhibe; es lo nico que
necesita conocer para poder interactuar con el objeto.
Esta idea de que un observador no ve todos los aspectos de un objeto sino solamente aquellos que
le le sirven para interactuar con l se llama encapsulamiento; la idea del nombre es que los aspectos
internos del objeto se encapsulan de forma tal que los observadores no pueden verlos.
La idea de encapsulamiento tambin puede observarse en la relacin que nosotros tenemos con el
mundo que nos rodea: para interactuar con una videocasettera me alcanza con entender el control remoto,
no necesito (afortunadamente!) saber p.ej. por dnde pasan las correas que llevan el movimiento del
motor a los cabezales; para darle de comer a una golondrina no necesito la composicin qumica de sus
jugos gstricos, y miles de etc.
Al encapsular un objeto, estoy al mismo tiempo acotando y explicitando (haciendo explcitas) las
formas posibles de interaccin; slo se puede interactuar con un objeto mediante el comportamiento que
exhibe. Esto nos da varias ventajas que pasamos a comentar.
Como las formas de interaccin son acotadas y las maneja quien programa el objeto, se hace ms
sencillo probar si un objeto se comporta correctamente.
Veamos ahora el concepto de Polimorfismo

Volvamos a la implementacin de la viaja pepita, en donde tenamos un solo colaborador interno.
Adems de pepita va a aparecer un picaflor llamado pepe. Al ornitlogo le interesa hacer con pepe
lo mismo que con pepita: estudiar la evolucin de su cantidad de energa a medida que come y que vuela.
Obviamente, pepe tiene distintos patrones de consumo de energa:
el alpiste le brinda 16 joules por gramo que come, pero cada vez que come hace un esfuerzo fijo
que le demanda 45 joules.
en cada vuelo consume 30 joules, que es lo que le cuesta arrancar y parar. Es tan liviano, que el
costo de mantenerse en vuelo y de moverse es despreciable.
Qu mensajes queremos que entienda pepe? Una respuesta posible es:

Voy a hacer que pepe entienda los mismos mensajes que pepita, porque las formas de interaccin
del ornitlogo con los dos van a ser las mismas. El ornitlogo le va a enviar los mismos mensajes a los dos, lo
que puede cambiar son las respuestas de cada uno.
Esta respuesta, esta forma de pensarlo, est perfecta. Si tu intuicin te dijo esto (o algo as), vas por
un camino muy bueno. Hay dos aspectos que destacamos:
al pensar en un objeto, lo pienso desde las formas en que el observador va a querer interactuar
con l. Dicho de otra forma, al configurar un objeto lo pienso desde los usuarios que va a tener ese objeto.

si los patrones de interaccin con dos objetos son los mismos, lo lgico es que tengan un
vocabulario en comn(Protocolo Conjunto de mensajes). Yendo un poco ms all en esta idea, si hago esto
le va a ser ms fcil al observador hablar con uno o con el otro indistintamente.
Veamos cmo sera la codificacin de pepe
Pepe
variables
energaCalculada
mtodos
comiAlpiste: gramos
"Le indican a pepe que comi alpiste; el parmetro es la cantidad expresada en gramos"
energiaCalculada := energiaCalculada + (gramos * 16) - 45
vol: minutos
"Le indican a pepe que vol; el parmetro es la duracin del vuelo expresada en minutos"
energiaCalculada := energiaCalculada - 30
energa
ênergaCalculada
reset
"Vuelve pepe a un estado inicial"
energaCalculada := 0.
Si quiero ejecutar la misma simulacin con pepe en lugar de con pepita qu tengo que cambiar en
el cdigo? Solamente el objeto al que le envo los mensajes. Al observador le es felizmente indistinto hablar
con uno o con el otro, no necesita ninguna adaptacin.
Ahora demos un paso ms. El ornitlogo tiene preparados distintas simulaciones, que evalan lo
que pasara con la energa de un ave en distintos escenarios; tiene datos de varias aves y quiere aplicarles
los distintos escenarios a cada una y ver con cunta energa quedan.
A esta altura est clarsimo que vamos a representar cada ave con la que quiere trabajar el
ornitlogo mediante un objeto, y que todos estos objetos van a entender el mismo protocolo, los mensajes
reset, comiAlpiste:, vol: y energa.
Observemos que adems de trabajar con muchas aves, el ornitlogo quiere tener a mano muchas
simulaciones. Entonces, de repente tiene inters de representar simulaciones as como representamos
aves. Una vez decidido esto, debera quedarnos claro que van a aparecer objetos simulacin, porque (otra
vez) cualquier ente que quiera representar, lo voy a representar mediante un objeto.

Cmo va a interactuar el ornitlogo con un objeto simulacin? Pasndole el (objeto) ave con el
que quiere que trabaje, y despus dicindole sencillamente algo as como dale masa.
Ergo, los objetos simulacin van a entender dos mensajes, a los que vamos a llamar trabajCon: y
daleMasa.
Empecemos armando una simulacin en el cual los pjaros comen mucho, al que vamos a llamar
simulacinGlotona.
Pensemos un poco en cmo implementarlo.
En el mtodo daleMasa vamos a indicarle al ave con la que estamos trabajando la secuencia de
eventos propios de la simulacin, y a devolver la energa que tiene el ave despus de estos eventos.
La simulacin necesita acordarse del objeto ave (colaborador externo) que le pasaron para
trabajar, esto lo va a hacer en el mtodo trabajCon:.
El nuevo modelo de objetos lo podemos representar como:
trabajCon: unAve
ave
daleMasa
SimulacionGlotona
trabajCon: unAve
energia
energiaCalculada
comiAlpiste: gramos
T1
vol: minutos
Pepita reset
energia
energiaCalculada
comiAlpiste: gramos
T2
vol: minutos
Pepe reset

Los TIPOS T1 y T2 que se corresponden con los protocolos de ambos Objetos; Pepita y Pepe son Polimorfos,
lo que posibilita que en el mbito del colaborador ave, pueden ser intercambiados.
El cdigo de Simulacin Glotona
SimulacinGlotona
variables
ave
mtodos
trabajCon: unAve
"Le ordenan trabajar con un ave determinada"
ave := unAve
daleMasa
"Le ordenan ejecutar la simulacion"
ave reset.
ave comiAlpiste: 50.
ave vol: 5.
ave comiAlpiste: 30.
ave vol: 10.
âve energa.
Ahora al ornitlogo le resulta mucho ms fcil evaluar la simulacin para un ave, p.ej. pepita. El
cdigo en la ventana de interaccin queda as:
simulacinGlotona trabajCon: pepita.
simulacinGlotona daleMasa.
Para usarlo con pepe, el cambio es trivial:

simulacinGlotona trabajCon: pepe.
simulacinGlotona daleMasa.
Nota antes de seguir: observamos que el parmetro que recibe trabajCon: es un ave. Queremos
destacar esto para mostrar que cualquier objeto puede ser colaborador externo, no solamente los nmeros
uotros objetos simples.
Volviendo, tuvimos que cambiar el cdigo de simulacinGlotona para que trabaje con pepe o con
pepita?
No, para la simulacin trabajar con pepe o con pepita es exactamente lo mismo. De hecho, la idea
es que para la simulacin sea lo mismo trabajar con cualquier ave que yo quiera representar, eso tiene
mucho inters porque puedo usar la misma simulacin para todas las aves.

Obviamente para que esto pase, cada ave que represente tiene que tener un mismo protocolo, o lo
que es lo mismo que entender los mensajes reset, comiAlpiste:, vol: y energa; porque si no en el mtodo
daleMasa le voy a estar enviando al ave un mensaje que no entiende.
De hecho, la simulacin podr interactuar con cualquier objeto que entienda estos cuatro
mensajes, el que sea un ave o no a la simulacin no le importa nada.
Lo que termina pasando es que la simulacin puede interactuar con muchos objetos distintos, de
los cuales lo nico que conoce es cmo de interactuar con ellos, y sin tener que hacer ninguna modificacin
en la simulacin para que trabaje con uno o con el otro.
A esta caracterstica de poder trabajar con objetos distintos en forma transparente la llamamos
polimorfismo; decimos que pepita y pepe son objetos polimrficos.
Ahora, a quin le sirve que pepita y pepe sean polimrficos? A pepita? A pepe? Claro que no!
Le sirve al usuario de pepita y de pepe, que en este caso es es otro objeto, simulacinGlotona.
Lo implementamos ahora en Smalltalk Pharo
pepita := Pepita new.
pepita reset.
pepe := Pepe new.
pepe reset.
simulacion := SimulacionGlotona new.
simulacion trabajCon: pepita.
simulacion daleMasa.
Si ahora:
simulacion trabajCon: pepita.
simulacion daleMasa.

5. BIBLIOGRAFA
Descubra Smalltalk. Autor: Wilf LaLonde. Editorial: ADDISON-WESLEY / DIAZ DE SANTOS. Ao: 1997.
Inside Smalltalk. Vol. II: Lalonde y J. Pugh; Prentice Hall International; 1991.
Introduccin a la Programacin Orientada a Objetos. Autor: Timothy Budd. Editorial: ADDISON-WESLEY

IBEROAMERICANA. Ao: 1994.
Apunte Taller de Orientacin a Objetos: Programacin Orientada a Objetos en Smalltalk/V del

Laboratorio de Sistemas-Universidad Tecnolgica Nacional-Facultad Regional Crdoba. Autor: Ing.
Fernando Cuenca.
Lenguajes de Programacin. Autor: Abdiel Cceres Gonzalez. Instituto Tecnolgico de Monterrey-

Campus Ciudad de Mxico. Ao: 2004.
Smalltalk-80 The Language and Its Implementation. Autores: Adele Goldberg and David Robson.
Editorial: Ao: 1983.
Notas de clase de Tpicos II, curso de la Maestra en Ingeniera de Software UNLP, dictada en 2002 por
Mximo Prieto. Documentos de Juan Carlos Vazquez.
Apunte: Introduccin a la orientacin a objetos de la Asignatura Paradigmas de Programacin UTN

FRBA Autores: Carlos Lombardi Nicols Passerini.
Pharo por Ejemplo. Andrew P. Black, Stphane Ducasse, Oscar Nierstrasz, Damien Pollet With Damien
Cassou and Marcus Denker. Version of 2013-05-12.

Paradigma de Programacion Con Orientacion A Objetos

Cargado por

Copyright:

Formatos disponibles

Paradigma de Programacion Con Orientacion A Objetos

Cargado por

Información del documento

Descripción original:

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Paradigma de Programacion Con Orientacion A Objetos

Cargado por

Copyright:

Formatos disponibles

Universidad Tecnolgica Nacional

Facultad Regional Crdoba

EL PRESENTE CAPTULO HA SIDO ELABORADO, CORREGIDO Y COMPAGINADO POR:

ING. COLACIOPPO NICOLS

Unidad N 4: Paradigma de Programacin con Orientacin a Objetos Pgina 2

2.15 Herencia ........................................................................................................................................... 32

Unidad N 4: Paradigma de Programacin con Orientacin a Objetos Pgina 3

3.4.1.3 Variables Contenedoras .......................................................................................................... 49

Unidad N 4: Paradigma de Programacin con Orientacin a Objetos Pgina 4

3.8.3.2 Caracteres ................................................................................................................................ 84

Unidad N 4: Paradigma de Programacin con Orientacin a Objetos Pgina 5

Conceptos fundamentales. Abstraccin de datos y ocultamiento de la informacin. Estructura de un

Unidad N 4: Paradigma de Programacin con Orientacin a Objetos Pgina 6

Unidad N 4: Paradigma de Programacin con Orientacin a Objetos Pgina 7

2. PARADIGMA ORIENTADO A OBJETOS

PARADIGMA ORIENTADO A OBJETOS OBJETOS + MENSAJE = PROGRAMA

2.1 CONCEPTOS INTRODUCTORIOS

Para resumir, un objeto posee caractersticas y comportamiento:

Unidad N 4: Paradigma de Programacin con Orientacin a Objetos Pgina 8

Y se relaciona con otros objetos a travs de mensajes:

Puede tener parmetros (objetos)

Retorna un resultado (objeto)

2.2 CARACTERSTICAS DE LA POO

Existe un acuerdo acerca de qu caractersticas contempla la "orientacin a objetos", las caractersticas

Abstraccin: denota las caractersticas esenciales de un objeto, donde se capturan sus

Unidad N 4: Paradigma de Programacin con Orientacin a Objetos Pgina 9

Por ejemplo grficamente:

Persona Caractersticas generales Caractersticas esenciales

dni, nombre (identificacin) Persona en la universidad Persona en una agencia

Modularidad: Se denomina Modularidad a la propiedad que permite subdividir una aplicacin en

Unidad N 4: Paradigma de Programacin con Orientacin a Objetos Pgina 10

Interfaz pblica (Protocolo)

Cohesin y acoplamiento: la cohesin mide las responsabilidades asignadas a cada objeto,

Polimorfismo: comportamientos diferentes, asociados a objetos distintos, pueden compartir el

Recoleccin de basura: la recoleccin de basura o garbage collector es la tcnica por la cual el

Unidad N 4: Paradigma de Programacin con Orientacin a Objetos Pgina 11

Un objeto representa alguna entidad o ente de la vida real. Puede representar:

Lo que est vivo: personas, animales, plantas, clulas, pulmones;

Las organizaciones: un equipo de ftbol, un ministerio, un grupo de investigacin, un club, una

Unidad N 4: Paradigma de Programacin con Orientacin a Objetos Pgina 12

FIG. 5.1. PROCESO DE ABSTRACCIN EN POO

En resumen, no podemos definir Objeto si no hablamos de un Sujeto. No podemos hablar de un

Unidad N 4: Paradigma de Programacin con Orientacin a Objetos Pgina 13

2.4 LOS OBJETOS EN EL PARADIGMA ORIENTADO A OBJETOS

Abstraccin: Representacin esencial de la Realidad.

Identidad: Todo objeto es igual a s mismo, y solo a s mismo.

Comportamiento: Descripto a travs de un protocolo

Es un proceso de abstraccin, el cual consiste en separar estas dos caractersticas claramente,

Unidad N 4: Paradigma de Programacin con Orientacin a Objetos Pgina 14

FIG. 5.2. REPRESENTACIN GRFICA DE UN OBJETO

FIG. 5.3 REPRESENTACIN DE UN OBJETO CON SU PROTOCOLO

El protocolo es invariante; si he comprendido la realidad y la he modelado como comportamiento de un

La especificacin del protocolo de un objeto es una decisin de anlisis, jams de diseo.

2.4.4 CAPACIDAD DE INSPECCIN

Unidad N 4: Paradigma de Programacin con Orientacin a Objetos Pgina 15

2.5 COLABORACIONES: MENSAJE Y MTODO

La colaboracin se produce cuando los objetos se envan mensajes.

Un mtodo se asocia a un mensaje que el objeto puede responder.