electroduendes.com

En este post hablaré sobre algo muy básico aunque imprescindible sobre teoría de clases y composición aplicados a as3. Con él podemos entender la manera en que es tratada la composición de clases (una clase contiene otra clase como atributo) y los conceptos de paso de variables a métodos por valor y por referencia.

El paso de parámetros por valor, se utiliza en programación para realizar una copia del valor del objeto cuando es pasado a través de la invocación de un método. Es decir, al llamar a un método de una clase que requiere un objeto, realizo una copia de dicho objeto. Si dentro de la clase, modifico ese objeto, los cambios no son propagados fuera de la clase.

El paso de parámetros por referencia, pasa “un puntero del objeto”, es decir, de alguna manera estamos pasando el objeto, y si dicho objeto es modificado dentro de la propia clase, sus cambios serán propagados fuera de la misma.

Hay lenguajes que permiten definir el método de paso de variables (referencia o valor), como es el caso de C++. En Actionscript, de momento no podemos pasar por valor de manera nativa, aunque nuestro método siempre puede hacer una copia internamente del argumento recibido para no modificar el original. En Actionscript 3, el paso de parámetros, siempre se realiza de la misma manera:

• Las instancias de clases son pasadas por referencia
• Los tipos primitivos se pasan por valor

Si estás aprendiendo Actionscript 3 y has llegado hasta aquí, te recomiendo que analices a fondo este código, puesto que puede resultarte muy esclarecedor para entender este concepto tan básico como fundamental sobre la orientación a objetos.

Primero, definimos dos Clases, ClaseA y ClaseB. ClaseB está compuesta por un atributo, atributoB que es de tipo Number.

package
{
	public class ClaseB
	{
		public var atributoB:Number;	
		public function ClaseB()
		{
		}
	}
}

ClaseA tiene otro atributo de tipo ClaseB. Estamos hablando por tanto, de una relación de composición entre las dos clases.

package
{
	public class ClaseA
	{
		public var atributoA:ClaseB;
		public function ClaseA(atributo:ClaseB){
			atributoA = atributo;
		}
	}
}

Ahora nuestra clase principal. Nótese cómo atributoB devuelve el mismo valor independientemente del lugar desde donde es modificado (es el mismo objeto) y cómo esto no sucede con tipos primitivos. En este caso paso un parámetro al constructor de la clase ClaseA (nuestro objeto de tipo ClaseB), para posteriormente modificarlo desde diferentes ámbitos y trazar los resultados.

package {
	import flash.display.Sprite;
 
	public class ReferenciaValorTest extends Sprite
	{
		/**
		 * @autor Alejandro Sánchez
		 * http://www.electroduendes.com/blog/
		 * */
		public function ReferenciaValorTest()
		{
			var b:ClaseB = new ClaseB();
			b.atributoB = 10;
			trace(b.atributoB) // OUTPUT: 10
 
			var a:ClaseA = new ClaseA(b);
			trace(a.atributoA.atributoB) // OUTPUT: 10
 
			a.atributoA.atributoB = 5;
			trace(a.atributoA.atributoB) // OUTPUT: 5
			trace(b.atributoB) // OUTPUT: 5
 
			b.atributoB = 10;
			trace(a.atributoA.atributoB) // OUTPUT: 10
			trace(b.atributoB) // OUTPUT: 10
 
			var c:Number = 20;
			a.atributoA.atributoB = c			
			trace(a.atributoA.atributoB); // OUTPUT: 20
			trace(b.atributoB); // OUTPUT: 20
			trace(c); // OUTPUT 20
 
			c = 30;
			trace(a.atributoA.atributoB); // OUTPUT: 20
			trace(b.atributoB); // OUTPUT: 20
			trace(c); // OUTPUT 30
 
		}
	}
}