En este video, explicaremos un punto rara vez cubierto en cursos de Pharo.
Cómo definir objetos de tamaño variable.
Notarás que ya usamos objetos de diferentes tamaños.
Aquí voy a crear un "Array" usando esta expresión.
Contiene diez elementos, todos con 'nil'.
Usando la misma expresión, Ahora creo un Array
que contiene cinco elementos.
Vemos que la clase Array crea instancias de tamaños variables.
Pero hasta ahora, no hemos explicado como puedes hacerlo.
Asi que,
aquí te mostraremos cómo definir clases con instancias de tamaño variable,
cómo crear instancias de estos objetos,
y cómo acceder estos tamaños variables.
Ahora para el primer punto.
Es muy sencillo.
La definición usa el mensaje "variableSubclass:" en lugar de la "subclass:".
Copiaremos la definición de la clase Array.
Noten que usamos variableSubclass, instanceVariableNames,
y así sucesivamente, para crear la clase.
Mientras que generalmente, cuando definimos la clase "Pointer",
"Counter" o "Dice",
solo usaríamos "subclass".
Usando esta definición, las instancias que creamos tienen tamaño variable.
Usando este ejemplo, si queremos hacer un punto "extraño"
usando dos variables de instancia, x e y,
como un punto y una zona variable, utilizamos esta definición.
Esto crea objetos que se parecen a esto, con un valor para x,
un valor para y, y una zona variable por instancia.
También podríamos tener otra instancia,
que también tiene x e y, con 10 aquí y 20 aquí,
y, por ejemplo, 100 y 200 aquí,
con una zona variable que puede contener diferentes objetos.
Entonces, las instancias de una clase que puede tener instancias de tamaño variable
tener una zona indexada que se agrega después de las variables nombradas, como x e y.
Está implícita y solo hay una por clase,
para evitar problemas de implementación al expandirla.
Ahora hemos visto cómo crear clases
que tienen instancias de diferente tamaño.
Ahora regresaremos a cómo podemos instanciarlas
y cómo acceder a este tamaño variable.
La forma en que las instanciamos
es usar el mensaje "new:" observando el uso del dos puntos.
Discutimos esto en el curso de colecciones.
Aquí queremos crear un objeto de tamaño variable
El tamaño variable del objeto se especifica por su valor "max".
Entonces, creamos un objeto, un Array con cuatro elementos.
Esto muestra los cuatro elementos.
¿Cómo accedemos a este tamaño variable?
Usamos los mensajes "at:" y "at:put:", que vimos en los Arrays.
Esto funciona para todos los objetos con un tamaño variable.
Entonces, si escribimos "at: 2" aquí, agregamos 'lulu'.
Entonces, si accedemos al valor 1, lógicamente devolverá nil.
Y si miramos el valor 2, nos dará 'lulu'.
De hecho, se aplica una correspondencia aquí
entre Arrays y objetos de tamaño variable usando "at:put:" y 'lulu'.
Este protocolo funciona para Arrays
y para todos los objetos que queremos tengan un tamaño variable.
No he explicado mucho aquí,
solo cómo definir la clase Array y extenderlo a otros objetos,
ya que conoces el protocolo.
Entonces, en Pharo hay objetos, o clases,
que toman diferentes formas.
Hay clases que solo tienen variables de instancia nombradas,
como "Counter" con el conteo o "Dice" con el número de lados.
Luego tenemos clases que solo tienen
una zona variable o indexada, como la clase Array.
Luego tenemos otras clases que son una mezcla de ambos.
Sin embargo, hay algunas limitaciones, es más sutil de lo que parece.
Ahora podemos decidir en el tipo de variable de clase.
Solo te mostraré la intención.
Este aspecto variable del que hablamos
pueden simplemente ser punteros de objetos, o quizás variables Byte o Word.
Se usa para la interfaz con el mundo exterior
cuando necesitamos especificar un tamaño,
y dentro de eso ponemos punteros a objetos con una forma específica.
Esta es una característica avanzada, pero quería mostrártelo.
Normalmente solo necesitarás usar "subclass".
A veces usarás "variableSubclass"
y "Bitamp" que representa la pantalla.
Bitmap es un objeto
que tiene una zona variable, denominada "Words".
Solo para que sepas que existe.
Como Pharo es un sistema reflexivo,
podemos hacerle preguntas.
Entonces, usando estos métodos, podemos hacer consultas.
Tal como si el tamaño de la clase es fijo o variable.
O si almacena punteros o bytes, por ejemplo.
Tenemos toda la API para preguntar sobre el tipo de clase.
Esta lista fue creada. haciendo consultas al sistema.
Se aplica una restricción.
Las clases que se definen utilizando "subclass"
puede tener cualquier tipo de subclase.
Si tenemos puntos usando x e y,
podremos agregar una subclase llamada Z
o una subclase llamada XY, más una zona variable.
Pero si quieres crear una subclase de una clase que ya tiene una zona variable,
solo puedes usar variantes que sean variables.
De lo contrario, el sistema que construye las clases dice que es incompatible.
Necesita saber que hay una zona para manejar las restricciones.
En cualquier caso, el sistema le informará si es imposible.
Entonces, ¿qué necesitas saber?
Ahora deberías saber como definir clases
que tienen instancias de tamaños variables
y cómo instanciarlos usando "new:"
y cómo acceder a ella utilizando el protocolo visto en Array.