Tabla de Contenidos

INTRODUCCIN AL LENGUAJE SMALLTALK.......................................... 2 1. BREVE RESEA HISTRICA .................................................................. 2 2. ELEMENTOS DE SMALLTALK ............................................................... 2 2.1. OBJETOS Y VARIABLES. ........................................................................... 2 2.2. MENSAJES ............................................................................................. 4 2.2.1. EXPRESIONES .............................................................................................................. 5 2.2.2. EXPRESIONES EN CASCADA ......................................................................................... 5 2.2.3. MENSAJES DENTRO DE MENSAJES ............................................................................... 5 2.3. SOBRE EL USO DE SQUEAK SMALLTALK................................................ 5 2.4. MTODOS .............................................................................................. 6 2.3.1. MENSAJE NEW A UNA CLASE ........................................................................................ 7 2.5. CONTROL ............................................................................................... 7 2.4.1. SELECCIN E ITERACIN .............................................................................................8 2.6. CLASES.................................................................................................. 9 2.6.1. CMO SE DEFINE UNA NUEVA CLASE EN SQUEAK SMALLTALK ................................ 10 Sobre la Redefinicin del Mtodo new y la Pseudo Variable super.............................. 13 2.7. HERENCIA ............................................................................................13

Introduccin al Lenguaje Smalltalk

1. Breve resea histrica Desde sus orgenes Smalltalk fue concebido para ser mucho ms que un lenguaje de programacin; la idea fue disear un ambiente de programacin que integrara software y hardware, y transformara a la computadora en una herramienta fcil de usar. El sistema Smalltalk puede ser pensado como compuesto por cuatro elementos bsicos: El kernel del lenguaje de programacin. El paradigma de programacin. El sistema de programacin El modelo de interface con el usuario. Estos componentes son bsicamente jerrquicos: la interface del usuario se implementa sobre el sistema de programacin, el cual a su vez est construido siguiendo el paradigma de programacin y usando el kernel. El kernel del lenguaje de programacin es el compilador o intrprete del lenguaje, que determina la semntica y la sintaxis. El paradigma de programacin es el estilo de uso del kernel, es decir, una vista del significado asignado a las entidades del mismo. El sistema de programacin es el conjunto de objetos y clases del sistema necesarias para llevar a cabo la programacin; este sistema brinda la estructura fundamental y resume en una coleccin jerrquica de clases la concepcin de la programacin en Smalltalk. Por ltimo, la interface grfica del usuario representa la utilizacin de las herramientas incorporadas para presentar el sistema al usuario. La combinacin de todas estas piezas conforma el denominado sistema Smalltalk. El proyecto original consisti en integrar en una nica plataforma de software y hardware el ambiente de programacin arriba descripto. El componente de hardware tal vez no tuvo el xito esperado por razones ajenas al proyecto mismo, la dcada pasada estuvo particularmente afectada por la aparicin de la computadora personal cuyo impacto muchas veces no fue dimensionado con la anticipacin necesaria. Pero el componente de software, es decir el sistema denominado Smalltalk/80, se convirti en uno de los pasos fundamentales en el camino de la evolucin de la programacin orientada a objetos, el paradigma que ms ha crecido en los ltimos aos. Smalltalk no slo logr un interesante xito en las aplicaciones industriales y administrativas sino que se convirti en el soporte de los cursos universitarios de orientacin a objetos. 2. Elementos de Smalltalk 2.1. OBJETOS Y VARIABLES. En Smalltalk, cada cosa es un objeto. No hay manera de crear dentro del lenguaje una entidad que no sea un objeto. Desde el punto de vista de la implementacin, los objetos son slo un conjunto de celdas de memoria que se asignan dinmicamente. Estas celdas mantienen el estado del objeto y a diferencia de otros lenguajes las variables no almacenan el valor que representan, sino un puntero al objeto (ver figura 1). Esta propiedad es muchas veces referida como semntica de puntero.

Figura 1. Implementacin de un Objeto en Smalltalk En Smalltalk existen distintas categoras de identificadores, por ejemplo, nombres y variables de clase, variables de instancia, variables globales, pseudo variables, mensajes, etc. Es importante notar que el lenguaje es sensible a maysculas y minsculas. Los nombres y variables de clase deben comenzar con letras maysculas, mientras que las variables de instancia, pseudo variables con minsculas. Los atributos de un objeto pueden ser de dos tipos, variables de clase y variables de instancia. Las variables de clase guardan atributos comunes a todas las instancias de una misma clase. Por lo tanto, estos atributos son accesibles a la clase y sus subclases, as como tambin a todos los objetos que son instancia de dichas clases. Por ejemplo, si tenemos una clase Prrafo una variable de clase puede ser sangra. As, todos los prrafos tendrn siempre la misma sangra. En trminos semnticos, si un prrafo modifica dicho atributo, estar modificando la sangra de todos los prrafos. En cambio, las variables de instancia tienen valores asociados nicamente con cada instancia u objeto creado a partir de una clase. La nica manera de acceder y modificar dichos valores es a travs de los mtodos pertenecientes al protocolo del objeto. Por ejemplo, dada la clase Persona, una variable de instancia es el nombre de la persona. Es claro, que cada instancia de la clase Persona tendr un nombre distinto. Tambin es posible definir variables globales o compartidas. Estas variables son definidas en diccionarios llamados pools. Diferentes tipos de variables globales son definidas en diferentes tipos de pools. Todas las variables globales, al igual que las variables de clase, comienzan con letras maysculas. El nombre de la variable y su valor son ligados dentro de un objeto el cual es una instancia de la clase Association. Esta instancia es ubicada dentro de un pool. En particular, el System Dictionary Smalltalk es un pool que contiene todas las variables globales, las cuales son accesibles a todos los objetos. Note que las variables de clase son un caso particular de variables compartidas, las cuales son implcitamente almacenadas dentro de un pool definido para la clase. Retornando a la implementacin, las variables en Smalltalk recuerdan a los campos de un registro en lenguajes como Pascal pero con algunas diferencias. Por ejemplo, en las variables de instancia el mbito de referencia est delimitado por el objeto donde se encuentra la definicin. Otra diferencia es que las variables son sencillamente designadores de objetos, es decir son uniformes con respecto al espacio ocupado por la referencia ms all del objeto referenciado y en este sentido no tienen un tipo asociado. Adems de las variables de instancia y de clase cada objeto tiene asignada una pseudo variable denominada self. Self es un designador de objeto que representa al objeto receptor del mensaje, luego veremos que la combinacin de esta variable con la herencia conforma una herramienta muy poderosa. Finalmente, Smalltalk tiene variables temporales. Las variables temporales estn asociadas a un fragmento de cdigo. Las mismas se crean cada vez que se ejecuta dicho cdigo. El espacio ocupado por estas variables es desalocado cada vez que finaliza la ejecucin del fragmento. Sintcticamente, las variables temporales son declaradas

entre barras, al principio del cdigo al que estn vinculadas, y sus identificadores deben comenzar con letra minscula. Esta categora de variables es utilizada por los mtodos. 2.2. MENSAJES La computacin en Smalltalk tiene lugar como resultado de enviar mensajes a los objetos. La sintaxis indica que un mensaje se compone de una referencia al objeto receptor seguido por un indicador del mensaje en cuestin, denominado selector del mensaje, seguido de cero o ms argumentos. La semntica asociada a los mensajes puede recordar las llamadas a los procedimientos, pero establece otro orden entre los componentes del lenguaje. En la programacin imperativa el control ocupa el centro del diseo mientas que en la POO los mensajes y mtodos estn subordinados al concepto de objeto. En Smalltalk existen tres tipos de mensajes: unarios, binarios y de palabra clave. Los mensajes unarios no tienen argumentos y deben comenzar con una letra minscula, por ejemplo: pilaUno desapilar pilaUno es el objeto receptor del mensaje, mientras que desapilar es el mtodo o accin que se le solicita a dicho objeto. Naturalmente, el mtodo desapilar debe formar parte del protocolo del objeto pilaUno. En cambio, los mensajes binarios, permiten pasar un argumento y su selector est formado por uno o dos caracteres no alfabticos adyacentes. En general, se emplean para operaciones aritmticas y relacionales. Por ejemplo: x<y En este caso x es el objeto receptor del mensaje, el objeto y es el argumento y < es el selector. Como respuesta a este mensaje, x devolver el objeto true el objeto false. Por otra parte, los mensajes de palabra clave permiten pasar uno o ms argumentos: pilaUno apilar: 80 En este caso estamos pidiendo al objeto pilaUno que apile el objeto 80. Otro ejemplo es: vectorA at: 3 put: 19 En este caso vectorA es una instancia de la clase Array, y el mensaje at:put: esta indicando al objeto vectorA que asigne el objeto 19 al objeto que se encuentra en la posicin 3 de su arreglo. Note que cada argumento tiene asociado una palabra clave, la cual debe comenzar con una letra minscula. Finalmente, un objeto se puede enviar un mensaje a s mismo mediante el uso de la pseudo variable self. Para ilustrar esto, asumamos que el objeto pilaUno contiene el siguiente mtodo: apilar: unElem (self estaLlena) ifTrue: [self error: pila llena] ifFalse: [tope := tope + 1. elementos at: tope put: unElem]

En este caso, self estaLlena es un mensaje que pilaUno se enva a s misma para saber si se encuentra vaca (esto es, la bsqueda del selector error: comenzar en la clase de la cual pilaUno es intancia). 2.2.1. Expresiones Un prrafo aparte merece el tratamiento de expresiones por parte de Smalltalk. Como hemos observado antes, los nmeros son objetos. En particular, 3 es una instancia de la clase Integer, 7.43 es una instancia de la clase Float y 4/7 es una instancia de la clase Fraction. De este modo la siguiente expresin: x := 3 + 4 asigna al objeto x el resultado de enviar el mensaje + al objeto 3 pasando como argumento el objeto 4. En definitiva, x quedar asociado el objeto 7. Es importante destacar que en Smalltalk la evaluacin de las expresiones se realiza de izquierda a derecha. Adems, todos los operadores tienen la misma precedencia, de este modo en la siguiente expresin 2 + 3*5 primero se efecta la suma, luego el resultado es el objeto 25. 2.2.2. Expresiones en Cascada Existen situaciones en que necesitamos enviar varios mensajes al mismo objeto en forma consecutiva. Por ejemplo, suponga que se desea crear una pila e inmediatamente apilarle los elementos 1 y 2. Luego, se debera enviar la siguiente secuencia de mensajes: pilaUno := Pila new. pilaUno apilar: 1. pilaUno apilar: 2 Donde el mensaje new crea una instancia de la clase Pila y el mensaje apilar apila un elemento en un objeto de la clase Pila. Para estos casos, Smalltalk provee un tipo especial de expresiones conocidas como expresiones en cascada, las cuales permiten enviar mltiples mensajes a un mismo objeto. Para nuestro ejemplo, sera equivalente enviar el mensaje: pilaUno := Pila new; apilar: 1; apilar: 2 2.2.3. Mensajes dentro de mensajes Los mensajes pueden combinarse en forma poderosa. Al ser combinados, los mensajes unarios se evalan en primer trmino, luego los binarios y finalmente los de palabra clave. Por ejemplo, en el siguiente mensaje: casa size + #( 1 2 3 4) size Se evala primero los mensajes size, dado que son unarios y luego el mensaje +. El resultado de este mensaje es el objeto 8. 2.3. SOBRE EL USO DE SQUEAK SMALLTALK

Figura 2. Ventana principal de Squeak Samlltalk

Descomprima el archivo squeak.zip y ya puede ejecutar el archivo squeak.exe. Este lenguaje no necesita instalacin. Una vez ejecutado el archivo squeak.exe se le presentar la ventana mostrada en la figura 2. Cierre todas las ventanas que estn a la vista (en total debe cerrar 4 ventanas). De esta forma en la pantalla se vern solamente el gato y las pestaas de los bordes de la ventana principal. Para comenzar a utilizar Squeak Smalltalk haga clic con el botn izquierdo en cualquier lugar vaco de la pantalla. De esta forma accede al men World que se muestra en la Figura 2.

Figura 3. Men World Las opciones a las que accederemos desde este men son: 1) Open 2) Save Una vez elegida la opcin open podremos optar por abrir workspace o browser, que sern las dos ventanas con las que trabajaremos. El workspace es el lugar desde el cual podremos ejecutar expresiones. El browser nos permite modificar y crear nuevas clases y mtodos. Para evaluar expresiones desde el espacio de trabajo debemos escribir la expresin a evaluar, seleccionarla y clickear sobre ella con el botn derecho. Para realizar la evaluacin hay tres opciones: Do It, Inspect It o Print It. Investigue la diferencia entre evaluar una expresin con cada una de estas opciones. 2.4. MTODOS Los objetos responden a los mensajes mediante la ejecucin de mtodos. Un mtodo se compone de dos partes: un encabezado y un cuerpo. Como en los lenguajes tradicionales, el encabezado se utiliza para identificar al mtodo cuando sea invocado y el cuerpo implementa la operacin correspondiente. Por ejemplo, considere el mtodo apilar correspondiente a la clase Pila: apilar: unElem (self estaLlena) ifTrue: [self error: pila llena] ifFalse: [tope := tope + 1. elementos at: tope put: unElem] El encabezado es apilar: unElem, donde unElem es el argumento del mtodo. El resto constituye el cuerpo de la operacin.

Los mtodos existen dentro de los lmites demarcados por un objeto y as pueden acceder a todas las variables de instancias del mismo. Esto resume entonces dos propiedades simtricas: El mtodo de un objeto slo se interesa por el estado interno de dicho objeto. Un mtodo no puede afectar directamente las variables de instancia de otro objeto.

La principal diferencia entre los procedimientos de los lenguajes tradicionales y los mtodos de Smalltalk es el momento en que se ligan la invocacin (envo del mensaje) con la implementacin de la operacin (mtodo). En Pascal, por ejemplo, esta ligadura se lleva a cabo en tiempo de compilacin, en cambio en Smalltalk se lleva a cabo en tiempo de ejecucin. 2.4.1. Mensaje new a una clase Los mtodos ejemplificados anteriormente son mtodos propios de las instancias de una clase. Sin embargo, de alguna manera debemos crear los objetos. Esto se logra mediante el envo de un mensaje de creacin (new) a la clase del objeto. Por ejemplo, si deseamos crear el objeto pilaUno como una instancia de la clase Pila se debe realizar la siguiente asignacin: pilaUno := Pila new Ms adelante, en la seccin 2.5 se retomar este tema. 2.5. CONTROL Las estructuras de control estn implementadas mediante el mecanismo de pasaje de mensajes ms una clase predefinida denominada BlockContext. Esta ltima brinda a Smalltalk la capacidad de encapsular una secuencia de acciones dentro de un objeto: el bloque. Un bloque es una secuencia de expresiones, separadas por puntos, y delimitada por corchetes. Asimismo, un bloque puede tener argumentos, los cuales son especificados entre el corchete izquierdo y una barra. Adems cada argumento debe ir precedido por un :. Por ejemplo: [ :j :k | (j*k) printString ] En el bloque anterior, j y k son parmetros. Dado que un bloque es un objeto, este puede ser asignado a un identificador pasado como argumento de un mensaje. Para poder ejecutar un bloque sin parmetros, la clase Block provee el mtodo value. Luego, en posible mandar el mensaje: [ I := 3. J := 8 printString ] value retornar 8 Siempre, la ejecucin de un bloque retorna el resultado de la ltima expresin evaluada dentro del mismo. Es importante notar que en respuesta al mensaje value, el bloque se ejecuta dentro del contexto en que fue definido, independientemente del contexto en que se encuentra al momento de ser ejecutado. Por ejemplo, suponga que en la clase A se define el siguiente mtodo: metA i := 10. p := B new. ^ p metB: [i := i+1].

Adems, asuma que en la clase B se define el siguiente mtodo metB como sigue: metB: bloque i := 3+4. ^ bloque value. Luego, si a es una instancia de la clase A, y efectuamos la siguiente asignacin: z := a metA resulta que z queda asignado al objeto 11. Cuando, se evalu el mensaje ^bloque value, el objeto i del bloque hace referencia al i asignado en metA y no al empleado en metB. Por otra parte, para bloques con un argumento se emplea el mensaje value:, para el caso de dos argumentos el mensaje value:value: y as siguiendo. Por ejemplo: [ :j :k | (j*k) printString ] value: 2 value: 3 retornar 6 En este caso, j y k quedan asociados a los objetos 2 y 3 respectivamente. 2.5.1. Seleccin En Smalltalk las estructuras de control condicionales son implementadas a travs de mtodos correspondientes a las subclases True y False de la clase Boolean, los cuales tienen la siguiente sintaxis: (<expresin de prueba>) ifTrue: [<secuencia-expresiones>] y (<expresin de prueba>) ifFalse: [< secuencia-expresiones>] La secuencia de expresiones colocada entre corchetes es un bloque sin argumentos. Tambin es posible utilizarlos de manera combinada. Por ejemplo, para el mtodo apilar tenemos: apilar: unElem (self estaLlena) ifTrue: [self error: pila llena] ifFalse: [tope := tope + 1. elementos at: tope put: unElem] El mensaje self estaLlena devuelve uno de los objetos: true o false. Si devuelve el objeto true, entonces se evalan las expresiones del bloque que sigue a ifTrue:; si devuelve false, se evalan las expresiones del bloque que sigue a ifFalse:. Observe que ifTrue:ifFalse: es un mtodo definido tanto en la clase True como en la clase False; si el objeto receptor es true entonces se utiliza el mtodo definido en la clase True, donde se enva el mensaje value al objeto block pasado como argumento en la palabra clave ifTrue:. Si en cambio, el objeto receptor del mensaje ifTrue:ifFalse: es false, luego se ejecutar el mtodo ifTrue:ifFalse: de la clase False, donde directamente se evala el bloque correspondiente a la palabra clave ifFalse:. 2.5.2. Repeticin Smalltalk, tambin define mtodos en la clase Block para expresar repeticin. Un bucle while por ejemplo tiene dos formas, la primera: [<secuencia-expresiones>] whileTrue: [<secuencia-expresiones>] y la segunda: [<secuencia-expresiones>] whileFalse: [<secuencia-expresiones>]

En el caso de whileTrue:, el bloque receptor es repetidamente evaluado. Mientras la evaluacin arroje el objeto true, el argumento del bloque es tambin evaluado, si no retornar el objeto nil. En el caso de whileFalse: es similar. En todos los casos, los bloques receptores deben finalizar con una expresin cuyo resultado sea instancia de la clase Boolean. Por otra parte, tambin se proveen mtodos de la clase Integer para expresar repeticin. Por caso: x timesRepeat: [< secuencia de expresiones >] x to: y do: [< secuencia de expresiones >] x to: y by: step do: [< secuencia de expresiones >] Adems, la clase Collection provee los denominados ITERADORES. Estos mtodos recorren de manera automtica distintas estructuras de datos modeladas mediante subclases de la clase Collection, tales como la clase Array y String. Ejemplos: "cuenta las vocales de un objeto instancia de la clase String usando do:" | vowels | vowels := 0. 'Now is the time' do: [ :char | char isVowel ifTrue: [ vowels := vowels + 1 ] ]. ^vowels "dibuja varios polgonos usando do: definido en la clase Array" Window turtleWindow: 'Turtle Graphics'. #( 3 4 12 24 ) do: [ :sides | sides timesRepeat: [ Turtle go: 20; turn: 360 // sides ] ] "cuenta las vocales de un objeto instancia de la clase String usando select:" ('Now is the time' select: [ :c | c isVowel ]) size El mensaje select: itera sobre el receptor y devuelve en un nuevo String todos los elementos para los que el bloque se evala a true. Luego con size se obtiene la cantidad de elementos de ese String. "retorna un arreglo con los dgitos cuyo factorial es < que el dgito elevado a la 4ta potencia" #( 1 2 3 4 5 6 7 8 9 ) reject: [ :i | i factorial >= ( i * i * i * i ) ] "retorna un arreglo con los cuadrados de cada elemento del arreglo receptor" #(1 13 7 10) collect: [ :i | i * i ] Implementacin de algunos de los mtodos presentados anteriormente: Clase: BlockContext whileTrue: aBlock " Evaluate the argument, aBlock, as long as the value of the receiver is true." self value ifTrue: [ aBlock value. ^self whileTrue: aBlock ] Clase: Number timesRepeat: aBlock "Evaluate the argument, aBlock, the number of times represented by the receiver."

| count | count := 1. [count <= self] whileTrue: [aBlock value. count _ count + 1] to: stop do: aBlock " Evaluate aBlock for each element of the interval (self to: stop by: 1)." | nextValue | nextValue := self. [nextValue <= stop] whileTrue: [aBlock value: nextValue. nextValue _ nextValue + 1] Clase: Collection do: aBlock 1 to: self size do: [:index | aBlock value: (self at: index)] La caracterstica ms importante de estas estructuras de control es la combinacin de una sintaxis muy sencilla con un mecanismo bsico de pasaje de mensajes que conforman una herramienta de programacin muy poderosa y elegante que recuerda a la programacin declarativa. En realidad, los rasgos de la programacin imperativa se ocultan en las profundidades de la jerarqua de clases predefinidas por el sistema. 2.6. CLASES Una clase brinda la estructura general para objetos con caractersticas similares. El punto ms interesante es que en este lenguaje las clases son objetos a los cuales se les pueden enviar mensajes como a cualquier otro objeto. Todo en Smalltalk es un objeto. Esta uniformidad extrema se traduce en que, por ejemplo, el debugger incorporado al ambiente de Smalltalk-80 tambin est escrito en Smalltalk y puede ser extendido o adaptado por el programador. Squeak Smalltalk tiene una gran variedad de clases predefinidas. A estas clases el programador puede agregar otras, las cuales debern insertarse dentro de la estructura jerrquica definida por el lenguaje. 2.6.1. Cmo se define una nueva clase en Squeak Smalltalk Las descripciones de clases pueden ser ingresadas a travs del Browser provisto por el lenguaje. Para ello, se debe seleccionar la opcin Browser dentro del men World. A continuacin se visualizar la ventana que se muestra en la figura 4.

Figura 4. Browser de clases En el resto de esta seccin crearemos la clase pila. En primer lugar vamos a definir una nueva categora en la que incorporaremos todas las clases que definimos. Para esto, debemos clickear en un cuadrado que se encuentra en la esquina superior derecha de la seccin de categoras de clases (marcado con un rectngulo amarillo en la figura 4). All aparecer un nuevo men del que tenemos que seleccionar la opcin add item. Escriba en la ventana el nombre que le dar a la nueva categora (su nombre). Recuerde que no estamos creando todava una clase. Solo estamos definiendo la categora en la que quedar definida por una cuestin de organizacin. Al clickear en el nombre de la nueva categora ver que la misma est vaca. Ahora s procederemos a crear una nueva clase. Para esto debemos decidir quin ser la clase padre. Crearemos la clase Pila como subclase de la clase Object. Al seleccionar la categora recin creada podemos ver en la seccin de cuerpo de los mtodos una porcin de cdigo con la siguiente forma: Object subclass: #NameOfSubclass instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'NuevaCategora' Para crear la clase debemos reemplazar NameOfSublclass por Pila. En ese punto se definen las variables de instancia de la nueva clase. Para nuestro ejemplo son: elemento, tope y cantMax. El texto queda de la siguiente manera: Object subclass: #Pila instanceVariableNames: 'elementos tope cantMax' classVariableNames: '' poolDictionaries: '' category: 'NuevaCategora' Posteriormente se guarda esta definicin seleccionando la opcin Accept del men contextual que aparece al clickear con el botn derecho en la seccin en la que acaba de modificar ese texto. Para crear un nuevo mtodo, debe seleccionar la categora all de la seccin de categoras de mtodos. De esa forma ver un esqueleto de mtodo que deber

completar como corresponda. Para nuestro ejemplo, crearemos el mtodo Inicializar reemplazando el texto: message selector and argument names "comment stating purpose of message" | temporary variable names | statements por el texto: inicializar "metodo de inicializacion de una instancia de la clase pila" Tope:=0. cantMax:=10. Elemento:= Array new: 10. Para guardar esta nueva definicin clickee nuevamente con el botn derecho y seleccione accept. Asegrese de haber creado este mtodo como mtodo de instancia. Para esto debe estar clickeada la opcin Instance debajo de la seccin de clases. Los restantes mtodos de la clase Pila son: Mtodos de Clase new ^(super new) inicializar Mtodos de Instancia estaVacia ^(tope = 0) estaLlena ^(tope = cantMax) apilar: unElem self estaLlena ifTrue: [self error: pila llena] ifFalse: [tope := tope + 1. elementos at:tope put:unElem] desapilar | temp | (self estaVacia) ifTrue: [self error: pila vacia] ifFalse:[temp := elementos at: tope. tope := tope - 1. temp] error: string string printString Al terminar de crear la clase o en cualquier paso intermedio recuerde grabar la imagen de Squeak para que cuando vuelva a ejecutar el programa se mantengan los cambios que realiz en el ambiente. Para esto debe acceder al men World y elegir la opcin Save. Cuando termine de trabajar con Squeak Smalltalk elija la opcin Save and Quit del men World.

SOBRE LA REDEFINICIN DEL MTODO NEW Y LA PSEUDO VARIABLE SUPER En la clase Pila mostrada arriba el mtodo de clase new fue redefinido con el fin de que toda nueva instancia de la clase est inicializada al momento de su creacin. Para ello fue necesario emplear la variable especial super. La variable self permite que un objeto pueda referenciarse a s mismo. Sin embargo, super hace referencia al alcance de la superclase correspondiente. Luego, super permite saltear un nivel en la cadena de herencia. De este modo, cuando en el cuerpo del mtodo se incluye la sentencia super new, este ltimo new refiere al definido en la clase Object. De otra forma, la redefinicin de new sera recursiva y su cmputo nunca finalizara. Esta caracterstica es muy til cuando se desea inicializar los objetos recin creados. 2.7. HERENCIA Smalltalk implementa la herencia en el sentido introducido anteriormente. Una subclase hereda el comportamiento de la superclase. Cuando un mtodo es invocado se inicia una bsqueda a lo largo de la cadena de clases vinculadas por esta relacin, hasta finalizar en la clase Object que es la raz de la estructura de clases predefinidas. La herencia simple establece una jerarqua en forma de rbol. Esto significa que cada clase tiene a lo sumo una superclase, aunque puede tener varias subclases. En la raz de la jerarqua se encuentra la clase Object. Todas las clases, excepto Object, tienen exactamente una superclase. Tambin decimos que Object constituye la metaclase de Smalltalk. Es decir la clase de la que derivan todas las clases. Una subclase hereda variables y mtodos de su superclase. De este modo, las variables y mtodos de instancia de la superclase se convierten automticamente en variables y mtodos de instancia de la subclase. Adems de las variables heredadas, una subclase puede declarar nuevas variables de instancia. Los mtodos de una subclase invalidan a los mtodos heredados con igual nombre. Hemos dicho antes que un mtodo es la implementacin de una operacin. Suponga que para alguna operacin con nombre op, tanto la superclase como la subclase implementan mtodos. En este caso, decimos que la subclase redefine el mtodo de su superclase. Luego, los objetos que sean instancia de la subclase utilizan la implementacin proporcionada por la subclase. Una excepcin a esto lo constituye el uso de la variable super. En resumen, una clase tiene una superclase inmediata y posiblemente una o ms subclases, con la clase Object en la cima de la jerarqua. Las clases situadas ms arriba en la jerarqua representan caractersticas ms generales, mientras que clases ms abajo en la jerarqua representan caractersticas ms especficas (relacin is-a). Un objeto hereda todas las variables de instancia definidas en sus superclases ms las contenidas en su propia clase. Los mtodos tambin se heredan. Cuando se enva un mensaje a un objeto, Smalltalk busca el mtodo correspondiente en la clase del objeto. Si lo encuentra, lo ejecuta. En caso contrario, repite el procedimiento en la superclase del objeto. Este proceso continua hasta llegar a la clase Object. Si no se encuentra el mtodo se produce un error.