POO – Trabajo teórico

mayo, 2005

SMALLTALK

Raúl Lucio Gómez

Departamento de Informática y Automática

Universidad de Salamanca
 Información de los autores:

Sergio Castaño Panchuelo

3º Ingeniería Técnica en Informática de Sistemas
Facultad de Ciencias, Universidad de Salamanca
yeyocp19833@hotmail.com

Raúl Lucio Gómez

3º Ingeniería Técnica en Informática de Sistemas
Facultad de Ciencias, Universidad de Salamanca
ralucio28@hotmail.com

Este documento puede ser libremente distribuido.

© 2005 Departamento de Informática y Automática - Universidad de Salamanca.
 Resumen
Este documento pretende ser una introducción a un lenguaje objetual puro como es
Smalltalk, centrándose en los aspectos principales inherentes de la programación orientada a
objetos y ofreciendo un conjunto de nociones básicas para aquellos programadores que
vayan a enfrentarse por primera vez a este interesante lenguaje.

Abstract
This document intends to be an introduction to a pure objectual language as it is Smalltalk,
paying special attention to the main aspects attached to object-oriented programming and
offering a set of basic notions for tose programmers who are aobut to face this interesting
language for the first tiem.

Tabla de contenidos
1. Introducción_____________________________________________________________ 1

2. Objetos y mensajes________________________________________________________ 1

2.1. Dando nombre a objetos y mensajes_______________________________________ 1

2.2. Importancia de los mensajes en Smalltalk___________________________________ 1

2.2.1. Unario__________________________________________________________ 2

2.2.2. Binario_________________________________________________________ 2

2.2.3. De palabra clave__________________________________________________ 2

2.3. Como crear una nueva instancia___________________________________________ 2

3. Instrucciones_____________________________________________________________ 3

3.1. Asignaciones__________________________________________________________ 3

3.2. Como se devuelve valores________________________________________________ 3

3.3. Comentarios en el código________________________________________________ 3

3.4. Variables_____________________________________________________________ 3

3.5. Estructura básica de un método____________________________________________ 4

3.6. Encapsulamiento de variables de instancia___________________________________ 4

3.7. Bloques______________________________________________________________ 5

3.8. Instrucciones en cascadas________________________________________________ 5

4. Datos y operaciones con datos_______________________________________________ 5

4.1. Nil___________________________________________________________________ 5

4.2. Bluques_______________________________________________________________ 6

5. Clases__________________________________________________________________ 6

5.1. Comportamiento de una clase______________________________________________ 6

5.2. Formato de una clase externa_____________________________________________ 7

5.3. Variables de clase______________________________________________________ 8

6. Herencia_______________________________________________________________ 10

6.1. Herencia de métodos___________________________________________________ 10

6.2. Herencia de variables___________________________________________________ 11

6.3. Clases abstractas_______________________________________________________ 11

6.4. Super Vs. Self_________________________________________________________ 11

7. Colecciones_____________________________________________________________ 12

7.1. Comportamientos______________________________________________________ 13

7.2. Métodos_____________________________________________________________ 14

8. Conclusión______________________________________________________________ 14

9. Bibliografía_____________________________________________________________ 15

Anexo: VisualAge 6.0.2_______________________________________________________ 16

Índice de figuras

Figura 1. Comportamiento de las clases ______________________________________ 7

Figura 2. Ejemplo de variables de clases______________________________________ 9

Figura 3. Ejemplo de herencia______________________________________________ 10

Figura 4. Clases abstractas_________________________________________________ 11

Figura 5. Tipos de colecciones__________________________________________ 12

Figura 8. Instalación de VisualAge ( 1 )_______________________________________16

Figura 9. Instalación de VisualAge ( 2 )_______________________________________ 17

Figura 10. Instalación de VisualAge ( 3 )______________________________________ 17

Figura 11. Instalación de VisualAge ( 4 )______________________________________ 18

Figura 12. Pantalla de trabajo del VisualAge Smalltalk___________________________ 18

Figura 13. Ventana editor del VisualAge _____________________________________ 19

Figura 14. Ventana de las clases y bibliotecas__________________________________ 19

 Índice tablas

Tabla 1. Comportamiento de las colecciones_____________________________ 13

Tabla 2. Métodos de las colecciones_________________________________________ 14

1. Introducción.
Smalltalk, lenguaje de programación orientado a objetos integrados con un entorno de
desarrollo multiventana fue diseñado por Alan Kay (quien había diseñado y construido entre
1967 y 1968 la primera computadora personal basada en programación orientada a objetos,
llamada FLEX) y otros en XEROX PARC. Todo en Smalltalk es un objeto y toda la
computación es desarrollada mediante mensajes que son enviados entre los objetos.
Smalltalk es más que un lenguaje, es un extenso programa de entorno de desarrollo con más
de doscientas clases y varios miles de métodos. Smalltalk consta de un lenguaje, modelo de
objetos, un conjunto de clases reutilizables, conjunto de herramientas de desarrollo y un
entorno en tiempo de ejecución.
Muchos conceptos de Smalltalk como los browsers y las técnicas de browsing han
encontrado hoy su rumbo en muchas herramientas de desarrollo de la generación X,
desarrollado por Smalltalk poseen un factor “divertido-de-usar”. Los cambios se graban
instantáneamente y los mismos pueden probarse rápidamente.
La primera versión fue conocida como Smalltalk 72, cuyas raíces fueron Simula 67. Siguió
Smalltalk 76, una versión totalmente orientada a objetos. En 1980, Smalltalk 80, fue la primera
versión comercial del lenguaje, incluyendo un ambiente de programación orientado a objetos
uniforme. El lenguaje Smalltalk ha influido sobre otros lenguajes como C++ y Java, y aunque
no ha tenido el grado de éxito de estos dos últimos, quizás por lo tardío en volverse gratis junto
a razones de eficiencia, este lenguaje tiene un gran número de seguidores en la actualidad.

2. Objetos y mensajes
2.1.Dando nombre a objetos y mensajes.
Consideramos que todos los nombres de clases comienzan con una letra en mayúscula, como
por ejemplo "Alumno". Los nombres de mensajes comienzan con una letra en minúscula y
pueden tener cualquier combinación de letras y números sin espacios en blanco. Cuando el
nombre de un mensaje contiene más de una palabra, las palabras extras comienzan con una letra
en mayúscula. Un nombre válido de mensaje podría ser “unMensaje” .Procurando siempre
utilizar nombres cortos para su mejor facilidad de utilización.

2.2. Importancia de los mensajes en Smalltalk

Todo el procesamiento de Smalltalk se realiza por medio del envío de mensajes a objetos. Un
enfoque inicial de la resolución de problemas, en Smalltalk, es tratar de reutilizar los mensajes y
objetos existentes. El programador de Smalltalk, trabaja para desarrollar una secuencia objeto-
mensaje que proveerá la solución deseada.
Los Objetos son instancias de una clase en particular. Los mensajes a los que un objeto
puede responder están definidos en el protocolo de su clase. El cómo estos mensajes se ejecutan
o son implementados está definido en los métodos de la clase. Los métodos dan los detalles
de implementación para los mensajes, y representan el comportamiento de la clase.
Un mensaje que pasa información o parámetros, el nombre del mensaje debe finalizar con
dos puntos (:). Así que el nombre del mensaje “nombre” se vuelve en "nombre:". Estos tipos
de mensajes son llamados mensajes de palabra clave. Los mensajes que no pasan información
son mensajes unarios.
Un mensaje puede contener múltiples argumentos. Debe haber una palabra clave por cada
argumento en el mensaje. Por ejemplo, es posible indicar el nombre y la dirección de un alumno
en un sólo mensaje. Esto requiere un nombre de mensaje con dos palabras clave, por ejemplo
"nombre:dirección:".
Los mensajes se ejecutan de izquierda a derecha, el resultado del cual reemplaza al mensaje
en la sentencia. Los mensajes entre paréntesis tiene prioridad sobre los que no lo están y
después, por orden unarios, binarios y de palabra clave
Existen tres tipos de mensajes: “unarios”, “binarios” y “de palabra clave”

2.2.1. Unario:
Es el tipo de mensaje que más prioridad tiene. Consiste de un nombre de mensaje y un
operando. Los objetos se colocan antes del nombre del mensaje.
Ej: 'hola' outputToPrinter "Envía la cadena 'hola' a la impresora"

2.2.2. Binarios:
Un mensaje binario puede ser de uno o dos caracteres de longitud. Estos son utilizados para
especificar operaciones aritméticas, lógicas y de comparación con cualquiera de los siguientes
caracteres especiales:

+/\*~<>=@%|&?!,

Lo siguientes son ejemplos de expresiones en Smalltalk, utilizando mensajes binarios:

a + b "devuelve la suma de a y b"

2.2.3.De palabra clave:

Son equivalentes al llamamiento de un procedimiento con al menos dos argumentos. Dentro de
los tres tipos de mensajes, este es el que menos prioridad tiene. Se coloca primero el nombre
del objeto al cual se envía el mensaje, luego el nombre del mensaje (o nombre del
método) y por último el parámetro que se desea pasar.

Ej:
UnObjeto unMensaje: parametro

2.3.Como crear una nueva instancia

Para crear nuevas instancias de una clase se utiliza la palabra reservada “new”, la cual devuelve
un puntero a la nueva clase creada
Ej:
Cliente new

3. Instrucciones
Las instrucciones en Smalltalk son las que forman los códigos ejecutables, las cuales a su vez
están formadas por expresiones.
Las expresiones son de tres tipo:
Un nombre de variable  Cada instrucción separada por un punto
Un literal  Cada instrucción separada por un punto
Un envío de mensajes

3.1.Asignaciones
En Smalltalk, una variable apunta a un objeto en vez de guardarlo. Se dice que una variable
contiene al identificador del objeto.
Una asignación recoge el objeto al cual apunta la variable y le cambia su valor.
La sintaxis para una instrucción de asignación es:
variable := instrucción
Ej:
x : = 1024

3.2.Como se devuelve valores

La devolución producida por un mensaje, será recogida por defecto por el objeto receptor.
Pero se puede anular la devolución del valor al método, colocando el símbolo ^ delante de
una instrucción, por ejemplo ^instruccion
Pero La devolución por defecto, es el receptor del objeto. Un método puede anular su valor
de retorno por defecto, colocando un símbolo de intercalación (^) adelante de una instrucción.
Cuando se encuentra un ^, el método finaliza la ejecución y devuelve el valor de la instrucción
que le sigue al símbolo de retorno ^.

3.3.Comentarios en el código
Un comentario en código en Smalltalk se representa entre comillas dobles.
Ej: “Esto es un comentario”

3.4.Variables
El nombre de una variable temporal comienza con una letra en minúscula, y debe ser único
dentro del método, por lo que no se podrá duplicar el nombre de una variable temporal de una
interfase. Las variables temporales están definidas en la definición de interfase de un método.
Por ejemplo, en la instrucción: artículo: unCodigo
Un método puede tener más variables temporales, listándolas entre barras verticales |
llamadas tuberías.

3.5.Estructura básica de un método

La primera línea define la interfase del método, compuesto por el nombre del método : y una
viable temporal. Es de buen estilo de programación, poner a continuación un comentario para
describir lo que hace el método. Después viene una declaración de una variable temporal
adicional, esta variable temporal es local sólo dentro de este método. Por último, las líneas
finales contienen la descripción del método.
Ej: unMetodo: variableTemporal
"Esto es un ejemplo de un método."
| nuevoValor |
nuevoValor := 4 * 8.
Un punto es opcional para la última línea de un método. La última línea contiene una
expresión de retorno, que no será necesaria a menos que se explicite un valor de retorno
diferente al receptor del mensaje. Quedando:

unMetodo: variableTemporal
"Esto es un ejemplo de un método."
| nuevoValor |
nuevoValor := 4 * 8.
^nuevoValor

3.6.Encapsulando de variables de instancia

Encapsulando las variables de instancia dentro de una clase, los cambios pueden ser hechos a
partes específicas de la clase sin afectar otras partes de la clase. Estas variables se mantienen
con la ayuda de dos métodos llamados en forma general: obtener y determinar. Estos métodos
son la única forma de acceder a las variables de instancia de una clase. Un método determinar
existe para proveer una manera de cambiar el valor de una variable de instancia por un valor
pasado como parámetro. El método obtener provee una forma de hacer que el receptor retorne el
valor de una variable de instancia al objeto emisor.
Por ejemplo, el objeto Alumno tiene tres métodos obtener y determinar, uno por cada una de
sus variables de instancia. Ellos son:
nombre "obtiene el valor de nombre"
direccion "obtiene el valor de dirección"
telefono "obtiene el valor de teléfono"
nombre:unNombre "determina nombre al valor unNombre"
direccion:unaDireccion "determina dirección a valor
unaDireccion"
telefono:unTelefono "determina teléfono a unTelefono"

Métodos adicionales pueden ser creados a partir de estos determinar y obtener para combinar
sus capacidades:
nombre:direccion: "Determina nombre y dirección en un mensaje"
nombre:direccion:telefono: "Determina nombre, dirección y teléfono"
 Los métodos para obtener y determinar proveen a los usuarios, una interfase común y estable
con los atributos (variables) de la clase. Como la implementación de estos métodos está oculta a
los usuarios, cualquier cambio a su procesamiento interno no implica ningún problema,
mientras la interfase permanezca igual.

3.7.Bloques:
Permite que el código sea pasado como argumento en un mensaje y ejecutado posteriormente en
otro método. Hay tres tipos de bloques. Un bloque cero-argumento que no acepta argumentos
cuando se ejecuta. Un bloque de un-argumento que acepta sólo un argumento cuando se ejecuta.
Un bloque de dos-argumentos que acepta dos argumentos cuando se ejecuta.
La sintaxis del bloque consiste en corchete que contienen a 0 ó más expresiones y un código
que realiza iteraciones o ejecuciones condicionales.

3.8.Instrucciones en cascada
Si varias instrucciones envían mensajes al mismo objeto, pueden ser colocadas como
instrucciones en cascada. Las instrucciones en cascada terminan con un punto y coma (;),
exceptuando a la última instrucción que termina con un punto (el punto es opcional si la
secuencia de instrucciones en cascada son la última instrucción del método en donde se
encuentran).
Self es el receptor de los mensajes para todas las instrucciones del método. Para ejecutar los
mensajes correctamente, necesitan aparecer en instrucciones separadas.

4. Datos y operaciones con datos

Smalltalk implementa los tipos de datos como clases de Smalltalk, y las operaciones sobre datos
como métodos en estas clases. Cada dato es una instancia de una de estas clases.
Smalltalk tiene cinco clases de datos: String (cadena), Number (número), Character
(caracter), Symbol (símbolo) y Array (vector). Las subclases de Number: Integer (entero), Float
(real), y Fraction (fracción) son parte de los literales también.
Las operaciones sobre datos, incluyendo las comparaciones lógicas, las operaciones
artiméticas, las operaciones lógicas usando "and" y "or", los condicionales lógicos, y las
iteraciones, son implementadas como métodos en sus respectivas clases.

4.1.NIL
Nil es para Smalltalk lo que null ó 0 para C. Es un objecto que significa "nada". Según se
declara una variable estar tendrá inicialmente el valor nil, aunque tambien se puede conseguir
durante el desarrollo del programa.
Por ejemplo:

Telefono := nil.
 Nil también se puede usar como valor devuelto de una función, en este caso, indicaría que la
operación no fue exitosa. Por ejemplo, la siguiente lógica devuelve nil si un argumento es no
positivo, caso contrario devuelve el resultado de la operación artimética:

raise: unNumero toPower: unaPotencia

"Raise (eleva) unNumero a toPower (a la potencia) especificada
por unaPotencia. Devuelve nil si unaPotencia es no positiva.
Caso contrario, devuelve el resultado." unaPotencia < 0
ifFalse: [^nil].
^aNumber raisedTo: aPower

4.2.Bucles
Hay cuatro tipo de iteraciones: hacer algo n número de veces, hacer algo hasta que se encuentre
con una condición false, hacer algo hasta que se encuentre con una condición true, hacer algo
usando un índice, comenzando con un valor inicial, y finalizando en un valor final.
Los cuatro mensajes de palabra clave que proveen estas funciones son: timesRepeat:,
whileTrue:, whileFalse:, y to:do:.

5. Clases
Existen muchos objetos en el Entorno Smalltalk y estos que responden a los mismos mensajes
con el mismo comportamiento son agrupados. Cuando están agrupados, su memoria privada es
representada de la misma forma, y sus métodos referencian sus datos con el mismo conjunto de
nombres. A un grupo de objetos, con las características así definidas, se le llama clase. Los
objetos pertenecientes a un grupo son llamados instancias de la clase. Programar en el Entorno
Smalltalk consiste en crear nuevas clases, crear instancias de clases, y especificar una secuencia
de intercambios de mensajes a través de todos estos objetos.

5.1.Comportamiento de una Clase

El comportamiento de una clase es útil para proveer funciones que son comunes a través de
todas las instancias de la clase. Esto incluye el manejo de una lisa de instancias de la clase, el
manejo de la inicialización de las instancias, y el mantenimiento de la información común.
El Entorno Smalltalk tiene la habilidad de especificar el comportamiento y el estado de una
clase, en lugar de una instancia de una clase. La definición del comportamiento de una clase
consta de tres partes: mensajes, métodos, y variables. Estas tres partes también están en
comportamientos de instancias.
Los métodos y variables que se utilizan para el comportamiento de una clase son llamados
métodos de clase y variables de clase, respectivamente. Las variables de clase tienen las mismas
convenciones de nombramiento que las variables de instancia, excepto que la primera letra de
una variable de clase debe comenzar con mayúscula. Por otro lado, los métodos de clase tienen
las mismas convenciones de nombramiento que los métodos de instancia. Las variables de clase
son compartidas por muchas clases, por esta razón, el nombre de una variable de clase debe
comenzar con una letra mayúscula.
Una buena forma de inicializar las variables de clase es a través de la inicialización diferida,
la cual asegura que una variable no sea nil (nula) antes de que su valor sea retornado y utilizado.
 Los métodos de instancia y los métodos de clase pueden referirse a las variables de clase,
pero sólo los métodos de instancia pueden referirse a las variables de instancia. El siguiente
diagrama muestra este hecho:

Figura 1. Comportamiento de las clases

En Smalltalk todo es un objeto, incluyendo la definición de una clase, que es una

instancia de una clase llamada Metaclase. No es importante, para el programador principiante,
comprender cómo se manejan las definiciones de clase. Lo que es importante comprender, es
que la definición de una clase, y la definición de los métodos y variables de una clase, son
objetos.

5.2.Formato de una clase externa

Las Definiciones de Clases son creadas con herramientas interactivas. En este entorno los
métodos tienen un formato de texto, pero las clases no; sin embargo, es posible guardar la
definición de una clase en un archivo de texto. Este archivo de texto contiene mensajes y texto
que recrearán la clase dentro de otra imagen de Smalltalk.
Usando EmpleadoConSalario, lo siguiente es un ejemplo de un formato externo:
"Una subclase de Empleado que agrega un protocolo que se
necesita para los empleados con salario"
Empleado subclass: #EmpleadoConSalario
instanceVariableNames: 'posicion salario'
classVariableNames: ' '
poolDictionaries: ' ' !
! EmpleadoConSalario publicMethods !
posicion: unaPosicion
posicion := unaPosicion !
posicion
^posicion !
salario: unSalario
salario := unSalario !
salario
^salario ! !
 La expresión que comienza con Empleado subclass: define a la clase Empleado. Esta es la
misma expresión que se encuentra en los examinadores de clases o aplicaciones en el entorno de
desarrollo.
Las dos primeras líneas definen una nueva clase, EmpleadoConSalario, como una subclase
de Empleado, con dos variables de instancia. Las dos líneas siguientes definen las variables de
clases y los diccionarios compartidos, en este caso no hay ninguno. El signo de admiración (!),
finaliza la definición.
La línea siguiente comienza y termina con el signo !. Especifica la clase y el tipo, público o
privado, de los métodos que siguen. Finalmente, siguen los métodos, cada uno terminando con
un signo !. Después del último método, otro signo ! es utilizado para indicar el fin

5.3.Variables de clase
Una variable de clase apunta al estado de la clase que la define. Sólo existe una copia de la
variable de clase en la jerarquía local de clases, convirtiéndola en una variable compartida. La
clase que define esta variable, y todas sus subclases, se referencian a esta única copia de la
variable.
Tanto las variables de clase como las variables de instancia de clase son importantes al
desarrollar aplicaciones complejas en Smalltalk. Las variables de clase permiten compartir
información a través de todas las subclases. Las variables de instancia de clase permiten heredar
el comportamiento de la clase a las subclases, mientras posibilita que cada subclase maneje su
propio estado de la variable; éstas son como las variables de clase, excepto que cada subclase
tiene su propia copia. Dado que es una variable privada, las variables de instancia de clase
deben comenzar con minúscula. Las variables de instancia de clase soportan el comportamiento
de herencia de clase, teniendo cada clase su propio estado de la variable.

En este ejemplo se usarán las clases Cliente, Vendedor y Persona. Suponga que se desea
obtener tres listas separadas de Cliente, Vendedor, y Persona en vez de una. ¿Cómo se realiza?
Una forma es agregar variables de clase para cada una de estas tres clase, y definir métodos de
clase duplicados para tratar cada lista. Otra forma de obtener estas listas, es definir las variables
como variables de instancia de clase, en vez de definirlas como variables de clase.
Las variables de instancia de clase, son variables de instancia que definen el estado de la
clase, en vez del estado de una instancia de la clase.
Se cambiará la variable Personas de una variable de clase, a una variable de instancia de
clase. Ahora su nombre será personas. Para acceder a la información que posee personas desde
métodos de instancia, se deberá enviar un mensaje a la clase.

Personas
"Devuelve el contenido de personas (variable de instancia
de clase) y se asegura que la variable esté inicializada."

personas isNil ifTrue: [personas := Set new].

^personas
 Ahora, este diseño soporta tres listas separadas, y sólo un conjunto de métodos de clase. Las
tres clases Cliente, Vendedor, y Persona, reciben su propia copia de esta variable de instancia de
clase, que es única para todas ellas. Sólo se necesita un conjunto de métodos de clase que se
define en la clase Persona. El siguiente diagrama ilustra este ejemplo:

Figura 2. Ejemplo de variables de clases.

6. Herencia
Es la característica por la cual una clase pude tener el mismo comportamiento que otra clase,
para luego “refinar” ese comportamiento para llegar a ser mas específica, facilitando la
reusabilidad y extensibilidad.
Un ejemplo de herencia es cuando alguien tiene un programa y desea que su programa
realice más de una función. La herencia permite que el usuario extienda el programa existente
para que realice la función que se necesite. El siguiente diagrama muestra un ejemplo de
herencia:

Figura 3. Ejemplo de herencia

En la herencia, la subclase siempre toma el comportamiento de la superclase

inmediatamente superior a ella. Este comportamiento está conformado por los métodos y
variables.
La herencia involucra superclases y subclases. Estas clases son similares en su jerarquía, a
las ideas de clase, género, y la familia de clasificaciones en el mundo animal. La jerarquía de
herencias es ilimitada. Esto significa que las subclases pueden tener subclases que también tiene
subclases. La clase vehículo podría tener por ejemplo las variables de instancia llamadas motor,
matrícula, nº bastidornombre. La subclase Coche tiene las mismas variables de instancia. La
clase vehículo soporta los mensajes motor, matrícula, nº_bastidor, motor:, matrícula:,
nº_bastidor:. La subclase Coche también soporta estos mensajes. Este es un excelente ejemplo
de cómo una clase hereda los métodos y variables de su superclase.

6.1.Herencia de Métodos
Para que una clase pueda modificar su comportamiento respecto a su superclase, tenemos a la
Herencia de Métodos, bien mediante el agregado de nuevo métodos o bien redefiniendo los ya
existentes heredados. Smalltalk también permite que las instancias de una subclase hereden los
métodos de su superclase y de más altas superclases en la jerarquía.
6.2.Herencia de Variables
La principal ventaja de la herencia es la posibilidad de que una clase herede las variables de la
superclase, a las cuales, las subclases también pueden poseer sus propias variables. Las
variables de clase e instancia se agregan a la clase colocándolas en la definición de clase. Las
clases heredan de manera diferente las variables de instancia y las variables de clase.

6.3.Clases abstractas
Las clases abstractas proveen de un comportamiento a sus subclases, pero nunca tendrán sus
propias instancias. Hay dos tipos de métodos que las clases abstractas proveen. El primer tipo,
brinda un método completo para que una subclase lo herede; el segundo, brinda una "interfaz"
del método que es común a todas las subclases pero que no posee código. La siguiente figura
muestra las clases abstractas de un supuesto árbol de jerarquías de Smalltalk.

Figura 4. Clases abstractas

Las clases abstractas: Collection, SequenceableCollection, AdditiveSequenceableCollection,

and ArrayedCollection proveen un conjunto de mensajes comunes a sus subclases. Cada
sublcase se provee de un código propio para redefinir al método "interfaz". Este método
"interfaz" se define como un protocolo común a todas las subclases pero que no brinda una
implementación común (la implementación estará dada por cada subclase).

6.4.Super vs. Self

El uso de super provoca que la búsqueda del método comience en la superclase del objeto
receptor. Super es la única forma en que la clase pueda agregar comportamiento a los métodos
sin tener que reemplazarlos. Cuando super es encontrado en la ejecución de un programa,
Smalltalk busca el método en la superclase del receptor.
Super también es usado para crear variables de instancia por cada nueva instancia. Esto se hace
por medio de un método de inicialización por cada clase. Un ejemplo para crear una nueva
instancia de una clase es:
Private Class Methods
 new
^super new inicializar
Self hace que la búsqueda del método comience en el mismo objeto receptor. Cuando self es
encontrado en la ejecución de un programa, Smalltalk busca el método en el receptor. Un
ejemplo del uso del comando self es: self calcular que significa enviar el mensaje calcular a self.

7.Colecciones
Las Colecciones son un importante conjunto de clases. Estas clases manejan grupos de
objetos; es casi imposible escribir código en Smalltalk sin utilizar una colección. Una
colección es simplemente un conjunto de elementos donde cada elemento es un puntero
a un objeto.
Smalltalk posee un número de diferentes tipos de colecciones incluyendo: Bag (Bolsa),
Set (Conjunto), Array (Vector), OrderedCollection (Colección Organizada),
SortedCollection (Colección Ordenada), String (Cadena), Symbol (Símbolo), y
Dictionary (Diccionario).

El siguiente diagrama ilustra la jerarquía de clases de estas clases de colecciones:

Figura 5. Tipos de colecciones

7.1.Comportamientos

COMPORTAMIENTOS

Tamaño
COLECCIONES Indexación Duplicados Orden Contenidos
variable

Cualquier objeto, pero

Bag N S S N
no nil

Cualquier objeto, pero

Set N S N N
no nil

Array S N S N Cualquier Objeto

OrderedCollection S S S N Cualquier objeto

SortedCollection S S S S Cualquier objeto

String S N S N Caracteres

Symbol S N N N Caracteres

Clave + Cualquier
Dictionary N S N N
objeto

Tabla 1. Comportamiento de las colecciones

S = Comportamiento soportado, N = Comportamiento no soportado

Las Clases de Colecciones tiene varios comportamientos similares, ellos son:
representan un grupo de objetos llamados elementos
proveen un estructura de datos básica para la programación
reemplazan construcciones iterativas en los lenguajes tradicionales con los mensajes a
las colecciones do:, detect:, select:, y collect:.
soportan cuatro categorías de mensajes que agregarán nuevos elementos, eliminarán
elementos, determinarán las ocurrencias de los elementos, and enumerarán los
elementos
7.2.Métodos

La siguiente tabla resume los métodos que cada colección soporta.

MÉTODOS

COLECCIONES do: add: remove: at: at:put: removeIndex: , detect: select: reject: collect:

Bag S S S N N N N S S S S

Set S S S N N N N S S S S

Array S N N S S N S S S S S

OrderedCollection S S S S S S S S S S S

SortedCollection S S S S N S S S S S S

Dictionary S S N S S N N S S S S

String S N N N S N S S S S S

Symbol S N N N S N S S S S S

Tabla 2. Métodos de las colecciones

8.Conclusión
Smalltalk supuso un revolución debido al ser el primer lenguaje orientada a objetos. Smalltalk
es un modelo puro orientado a objetos lo que significa que todo, en el entorno, es tratado como
un objeto. Entre todos los lenguajes orientados a objetos, el que nos concierne es el más
consistente en cuanto al manejo de las definiciones y propiedades del paradigma
orientado a objetos.
Smalltalk es más que un lenguaje, es un extenso programa de entorno de desarrollo
con más de doscientas clases y varios miles de métodos.

Hay muy poca información en español, lo que nos indica y así es, que no tiene mucha acogida
en Europa, no así en Estados Unidos; aunque en Extremadura hay comunidad que le dan vida a
este robusto y antiguo lenguaje.
9.Bibliografía

• Sobre Smalltalk, manuales, software, noticias...

http://www.smalltalk.org

• Descarga del programa Squeak 3.7 para distintos Unix, Windows ( 98/95, NT, XP y CE ),
Macintosh, Acorn RISC OS e incluso PDA
http://www.squeak.org/download/

• Pasos de instalación, consejos para principiantes, repositorios de proyectos, suscrición al

grupo de Small-Land, descarga de manuales y programa Small-Land
http://swiki.agro.uba.ar/small_land

• Comunidad de Small-Land español, manuales, noticias, foros y descarga del programa

http://www.small-land.org
http://www.small-land.org /libro-badajoz/manual.html

• Manual de Smalltalk de IBM.

http://www.abcdatos.com/tutoriales/tutorial/l6315.html

• Ejercicios de desarrollo sobre Smalltalk.

http://www.ii.uam.es/~mora/tacc2/

• Información y descarga del programa VisualAge.

http://www.ibm.com/

• Manual de referencia del programador de Smalltalk IBM.

http://www.ii.uam.es/~mora/tacc2/ref_v55.pdf

• Manual y distintas versiones para descarga de GNU Smalltalk.

http://www.gnu.org/software/smalltalk/
Anexo A: VisualAge 6.0.2

VisualAge enfatiza sobre las construcciones visuales de interfaces y aplicaciones, contienen dos
niveles de soporte de desarrollo: grupal e individual. Ambos corren en diferentes plataformas,
incluyendo: IBM OS/2, Microsoft Windows, and AIX.
Se trata de un programa de pago, pero para este trabajo se ha utilizado una versión de
evaluación de 30 días.
En primer lugar descomprimimos el zip “va602_cw” donde se encuentra el cliente del
programa, dando una carpeta llamada “cd_c”, en la cual se encuentra otra carpeta llamada
“install_w” , hacemos doble clic en ejecutándose ya el asistente de instalación.

Pantalla de instalación inicial:

Figura 8. Instalación de VisualAge ( 1 ).

 Selección de idioma ( no en español ):

Figura 9. Instalación de VisualAge ( 2 ).

Aceptamos la licencia y seguimos.

Opción a instalar la documentación correspondiente:
 Figura 10. Instalación de VisualAge ( 3 ).

El resto de la instalación es simplemente seguir el asistente...

Figura 11. Instalación de VisualAge ( 4 ).

De forma similar se instala la parte del servidor del programa, donde se encuentran las
bibliotecas necesarias para el programa.
Una vez hecho todo esto, ya podemos ir a ejecutar el programa.
Pantalla inicial:

Figura 12. Pantalla de trabajo del VisualAge Smalltalk.

Ventana de edición: ésta es la ventana de trabajo, comparable en cuanto a aspecto visual y
funcionamiento al Visual Studio de Microsoft, con su correspondiente ventana de propiedades
de cada objeto

Figura 13. Ventana editor del VisualAge

Ventana donde observamos y modificamos las clases existentes:

Figura 14. Ventana de las clases y bibliotecas