caveman
Cuando se crea un objeto, éste queda almacenado en memoria. Pero la memoria no es más que un enorme laberinto de ceros y unos. Necesitamos un mecanismo para localizar cualquiera de los objetos que creamos cuando los necesitemos.
Ese mecanismo, seguro que ya lo conoces, son las variables, y a primera vista puede parecer bastante prosaico. Consiste simplemente en ponerle nombre a los objetos y luego llamarlos por ese nombre.
Pero hay mucho más que eso detrás de las variables y en este artículo vamos a hablar de ello.

Volver al Índice

Introducción

Las variables son enlaces

Una de las operaciones más confusas en programación cuando eres novato (al menos para mi lo era) es la utilización del operador asignación (=). Lo hemos visto y odiado tanto cuando estudiábamos matemáticas que cada vez que lo vemos hay algo en nuestro cerebro que empieza a palpitar y no nos deja pensar con claridad.

En programación, = no significa igual, significa le asigno.
Si tengo definida una variable

		var numero:Number;
		

y la igualo a 5:

		numero = 5;
		

solemos decir que numero es 5, o que a contiene el valor 5. Y lo podemos comprobar utilizando la función trace() para mostrar ese valor en la consola (panel Output o Salida en Flash)

		trace(numero); // -> hace aparecer un 5 en el panel de salida.
		
+

Acerca de la función trace()

Aunque esta forma de hablar está completamente aceptada entre programadores, no es del todo correcta, porque no describe lo que está pasando realmente.

Ni numero es 5 ni contiene a 5 ni es igual a 5.

En realidad, numero es un enlace, una referencia, a un objeto que reside en la memoria. Ese objeto sí es de tipo Number y contiene el valor 5. ¿Ves la diferencia?

Cuando escribimos:

		numero = 5;
		

Deberíamos decir asignamos 5 a la variable numero. No sólo es más exacto desde el punto de vista del significado del operador, sino que además estamos diciendo las cosas en el orden en el que realmente ocurren.
Esto último se ve más claro si escribimos:

		numero = 7 + (3*30)/2;
		

Que se leería asignamos a numero lo que resulte de realizar la operación 7 + (3*30)/2.

En una sentencia de asignación se ejecuta primero lo que hay a la derecha del = y depués se asigna el objeto que resulte a la variable que hay a la izquierda del mismo.

 

Variables locales y Propiedades

Ahora que tenemos más claro lo que es una variable, pongámoslo en el contexto de una clase. Podemos decir que por el lugar de la clase en el que definimos una variable tenemos dos tipos:

  • Variables locales:
    Se definen dentro del cuerpo de un métodoVer Fundamentos de AS3: Definición de métodos y sólo son accesibles desde ese método. Cuando el método termina de ejecutarse la variable se destruye.
    El objeto al que hace referencia continúa existiendo, pero ya no se puede acceder a él a través de esta variable.
  • Propiedades:
    Se definen en la clase, pero fuera de cualquier método (Se suele hacer al principio de la misma, antes del método constructor). Son accesibles desde cualquier método de la misma clase.
    Para que dejen de referenciar a un objeto concreto hay que asignarles otro, o null.
+

Más información

Además, cuando declaramos una variable o propiedad, definimos su tipo de dato. Es decir a que clase de objetos puede hacer referencia esa variable.
Es muy importante hacer esto correctamente, porque si después intentamos asignar a esa variable un objeto de otro tipo no compatible con el declarado, el compilador lanzará un error.

En la siguiente sección vamos a ver cuales son los tipos de dato que se llaman básicos o primitivos, porque son los más sencillos y todos los demás están basados en ellos.

Tipos de dato

El juego de las formas y los colores

Los programas gestionan diferentes tipos de dato de forma distinta. Para cada tipo de dato varían los valores posibles, las operaciones que pueden realizar o se pueden realizar sobre ellos y que patrón se utiliza para almacenar la información en la memoria.

Asignar un tipo de dato a una variable limita lo que la variable puede contener, que se puede hacer con ese valor y como se almacena.

Todo esto puede parecer como un paso extra innecesario e ilógico (al fin y al cabo limitar no puede ser bueno). También tedioso, porque nos obliga a planificar como nuestro programa va a manejar la información antes de empezar a escribir código.

Sin embargo, al declarar los tipos de dato de las variables, tus programas serán más predecibles, tus aplicaciones más estables y el proceso de depuración de errores mucho más simple.

+

Comparación con Javascript

20130321-171559.jpgPuedes pensar en los tipos de dato en los típicos juguetes para niños pequeños para reconocer formas y colores. Las figuras con forma de estrella solo encajan en los agujeros con forma de estrella. Si intentas introducir una figura en un agujero que no le corresponde, el juguete lanza un error de forma inmediata: la figura no cabe 😉

Es lo mismo que hace el compilador cuando intentas asignar un valor de un tipo a una variable de un tipo incompatible… al lanzar el error te dice: no encaja, no te dejo compilar.

Si el juguete te dejara encajar una estrella en un círculo, tarde o temprano alguien se daría cuenta y pensaría que tienes un problema. Es más, siendo niño lo tendrías y serio porque al no limitar las posibilidades este juguete no cumpliría con su labor educativa y tú no aprenderías a reconocer estas formas y colores.

Parece que limitar las cosas no es tan malo después de todo. Más adelante aprenderás que una de las buenas costumbres de programación consiste, precisamente, en limitarnos a nosotros mismos lo que podemos hacer en nuestro programa.

+

Aclaración

Tipos de dato básicos o primitivos

int:
De Integer o entero (sin decimales). Para números enteros positivos, negativos o 0.
Si se trata de asignar un número real a una variable tipo int, cualquier decimal será eliminado.
¡Cuidado! Al contrario que la mayoría de nombres de clase y tipos de dato, int se escribe con minúscula.
Su valor por defecto es 0 (cero).

uint:
De unsigned integer (Enteros sin signo). Para números enteros positivos o 0.
Si se trata de asignar un número real a una variable tipo uint, cualquier decimal será eliminado.
El signo también será ignorado y convertido a positivo siempre. Su valor por defecto es 0 (cero). Se utilizan sobre todo para almacenar colores en formato hexadecimal (0xff0000 equivale al rojo, por ejemplo).

Number:
Para números reales, es decir, que pueden tener decimales.
¡Cuidado! En todos los lenguajes de programación, la coma decimal se expresa con un punto (.).
Su valor por defecto es NaN (acrónimo de Not a Number). Esto quiere decir que si no le asignamos un valor, no tiene valor y si intentamos utilizarlo dará un error.

+

Más información:

Boolean:
Sólo puede tener true o false como valor. Cualquier expresión que se intente asignar a una variable de tipo Boolean será convertida a true o false. Se utilizan mucho en condicionales. Su valor por defecto es false.

String:
Significa cadena, para cadenas de caracteres (letras y/o números), es decir, texto. Los valores se tratarán como texto y deben expresarse entre comillas ("Hola mundo", por ejemplo). Su valor por defecto es null.

void:
Significa vacío. El tipo de datos void tiene un único valor: undefined. Se utiliza para definir el tipo de retorno de las funciones que no devuelven ningún valor.

Null:
Es un tipo de dato especial, cuyo único valor posible es null, el cual se utiliza para representar la ausencia de valor. null es el valor por defecto de cualquier variable de tipo String, Object, MovieClip, Array, … y de cualquier tipo de dato que esté definido por una clase, ya sea de las definidas en ActionScript o de las que definamos nosotros. Las únicas excepciones son int, uint, Number y Boolean.

Sé que muchas de estas explicaciones te van a sonar a chino. Pero no te preocupes, es normal. Sin embargo, recuerda volver a esta página cuando tengas dudas sobre alguno de los tipos de dato primitivos.

 

Tipos de dato complejos

Esto te va a parecer obvio, pero déjame decirlo de todos modos. Los tipos de dato complejos son todos los que no son básicos o primitivos.
Y aquí complejo no significa necesariamente complicado. Se refiere en realidad a que son tipos de dato compuestos en una estructura de propiedades y métodos que implican y utilizan los tipos de dato básicos.

El más sencillo de los tipos compuestos es Object, la clase para los objetos más simples. Todas las clases de ActionScript extienden Object, es decir, heredan sus métodos y propiedades. Es tan así que ni siquiera hay que escribirlo explícitamente al definir la clase. Si no pones extends Object el compilador lo va a añadir por ti.

Detrás de Object viene una larga, larguísima, lista de clases que ya están predefinidas por el lenguaje ActionScript, más todoas las que definas tú, cuando te pongas a ello.

No vamos a describir aquí todas ellas, pero si merecen mención las que se consideran parte del nucleo del lenguaje, porque no hay que importarlas para usarlas. Estas son: Object, Array, Date, Error, Function, RegExp, XML, and XMLList.

De todos estos tipos de dato complejos, los que más vamos a usar son Object y Array. Merecen una explicación aparte así que dejamos para otro día su explocación en detalle.

Si queremos utilizar otro tipo de dato que no sea primitivo o no forme parte del nucleo del lenguaje, tendremos que asegurarnos de importar su clase utilizando una sentencia import. Es lo que ocurre por ejemplo cuando queremos usar MovieClip:

		package 
		{
			import flash.display.MovieClip;
			 
			public class Main extends MovieClip
			{
				public function Main()
				{
					var miPelota:Pelota = new Pelota();
					addChild(miPelota);
					miPelota.x = 100;
					miPelota.y = 175;
				}
			}
		}

Hay una salvedad, y es si el tipo de datos es una clase definida por nosotros en Flash a partir de un símbolo, como es el caso del Pelota en el ejemplo anterior.
También nos libramos de importar la clase si la hemos definido nosotros manualmente (con código) y la colocamos en la misma carpeta que la clase que utiliza ese tipo de datos.

Variables locales

Definición de una variable

En la introducción decíamos que las variables locales se definen dentro del cuerpo de un método. Veamos como:

Definición de variables locales

Se les dice locales porque sólo serán accesibles dentro del método en el que se definen.
Para definir una variable local escribimos, dentro de un método y en este orden:

  1. la palabra clave var
  2. el nombre de la variable
  3. el tipo de dato de los objetos que se le pueden asignar a dicha variable, separado del nombre de la variable por dos puntos (:)

Como todo empieza con el constructor de la clase documento, vamos a declarar nuestra primera variable ahí precisamente:

		package  
		{
			import flash.display.MovieClip;
		
			public class Main extends MovieClip 
			{
				public function Main() 
				{
					var alumno:String;
				}
			}
		}
		

Acabamos de definir la variable local unNombre declarando que su tipo de dato es String. O sea que unNombre sólo podrá contener cadenas de texto.

Uso de variables locales

Vamos a asignarle un valor y a usar la variable para mostrar ese valor en la consola:

		var alumno:String;
		alumno = "Frumencio";
		trace(alumno);

Al compilar y ejecutar este código (pulsando Ctrl + Enter) aparecerá en consola lo siguiente:

		Frumencio
		
+

Ahorrando espacio

En este ejemplo estamos realizando las tres operaciones que se pueden hacer sobre una variable: definirla (línea 9), asignarle un valor (línea 10), y leer su valor (línea 11).

Asignar un valor a una variable

Para asignar un nuevo valor a una variable ya definida utilizamos el operador de asignación (=):
nombreDeVariable = _nuevoValor_

En el ejemplo, el nombreDeVariable es alumno y el valor que le asignamos es "Frumencio".

Errores típicos al asignar variables locales

Fíjate en que la variable ha sido declarada de tipo String y que el valor que le asignamos también es una cadena de texto. Si le asignáramos un valor de otro tipo, por ejemplo Number se produciría un error al compilar. Vamos a comprobarlo, sustituye la línea 10 por la siguiente:

		alumno = 5;

Al compilar de nuevo se abrirá el panel de Errores de compilador con el siguiente error:

			1067: Implicit coercion of a value of type int to an unrelated type String.
		

Que en español se traduce como:

			1067: Conversión implícita de un valor de tipo int a un tipo String no relacionado.
		
+

Localización de un error en el código

En principio, no se puede asignar un valor de un tipo a una variable de otro tipo distinto.

+

Matiz:

Recuperar el valor de una variable

Para leer el valor de una variable escribimos su nombre allá donde lo queramos utilizar.
A efectos prácticos, será como si hubiéramos escrito el valor actual de la variable en ese mismo lugar.

En la línea 11, estamos recuperando el valor de la variable alumno y pasándoselo a la función trace() para que lo muestre en pantalla. A efectos prácticos es como si hubiéramos escrito:

		trace("Frumencio");

Errores típicos al usar variables

Ya que estamos con los errores que pueden aparecer cuando usamos variables, mira lo que ocurre si me equivoco al escribir el nombre de la variable en la línea 11:

		var alumno:String;
		alumno = "Frumencio";
		trace(aluno);

He escrito aluno en lugar de alumno. Al compilar y ejecutar este código aperacerá el siguiente error:

		1120: Access of undefined property aluno.
		

o, en español:

		1120: Acceso a una propiedad aluno no definida.
		

EL compilador interpreta que estoy intentando acceder a una propiedad llamada aluno, pero como no está definida, da un error.
La mayoría de las veces que aparece este error es porque he escrito mal el nombre de una variable o propiedad que ya tengo definida. También lo hace cuando uso una variable o propiedad que no ha sido definida en absoluto.

Este error también salta si me equivoco al escribir el nombre de la variable en la línea 10 en lugar de en la 11. Asignar una variable es una forma de usarla.

Hay que tener cuidado porque los lenguajes de programación, además, son sensibles a mayúsculas y minúsculas, lo que significa que si defino una variable que se llame, por ejemplo nombreAlumno e intento utilizarla después como nombrealumno aparecerá de nuevo el error 1120.

Más Ejemplos

Vamos a definir otras variables de otros tipo, para que veamos algo de variedad, y a utilizarlas en un trace() para componer una frase usando el operador de concatenación (+). Te recuerdo que seguimos escribiendo código en el constructor de la clase documento (Main.as)

		var alumno:String;
		var edad:int;
		var notaTrimestre1:Number;
		var notaTrimestre2:Number:
		var notaTrimestre3:Number;
		
		alumno = "Frumencio";
		edad = 20;
		notaTrimestre1 = 8.53;
		notaTrimestre2 = 5.6;
		notaTrimestre3= 7.33;
		
		var notaMedia:Number = (notaTrimestre1 + notaTrimestre2 + notaTrimestre3) / 3;
		
		trace("El alumno " + alumno + " tiene " + edad +  " años. Su nota media es " + notaMedia);
+

Clase completa:

Vamos a explicar el código. Siéntete libre de saltarte esta explicación si crees que ya entiendes los que estoy haciendo. Si crees que es el caso asegúrate de que entiendes bien las líneas 21 y 23

línea 10:
Definimos la variable edad como un entero. Aunque en rigor nuestra edad no debería esxpresarse como un número entero, nadie dice que tiene 20.37 años.
líneas 11 a 13:
Definimos notaTrimestre1, notaTrimestre2 y notaTrimestre3 como variables de tipo Number, al fin y al cabo las notas pueden tener decimales.
línea 15:
Esta ya la conocíamos. Asignamos a la variable de tipo cadena alumno la cadena de texto "Frumencio".
línea 16:
Asignamos a la variable notaTrimestre1 el valor 8.53. Recuerda que la coma decimal se expresa en programación con un punto (.). La coma se usa como separador de elementos en programación.
líneas 17 y 18:
Hacemos lo propio con notaTrimestre2 y notaTrimestre3
línea 21
¡Atención!Aquí estamos haciendo dos cosas a la vez. Definir la variable notaMedia y asignarle un valor, el resultado de la operación (notaTrimestre1 + notaTrimestre2 + notaTrimestre3) / 3, todo al mismo tiempo.

Mejor dicho, estamos haciendo tres cosas. Primero se define la variable. Después el programa, al ver que tenemos un operador de asignación, ejecuta la operación que hay a su derecha (para ello sustituye las variables por sus valores actuales) calculando el valor resultante. Por último asigna dicho valor a la variable que acabamos de definir. Si no abreviáramos estas tres operaciones las escribiríamos de esta manera:

			var notaMedia:Number;
			notaMedia = (notaTrimestre1 + notaTrimestre2 + notaTrimestre3) / 3;
			

En realidad este tipo de sentencia se utiliza mucho, por que nos ahorramos escribir otra línea de código.

Esta sección sobre las variables locales ha sido larga. No te agobies, la de propiedades será mucho más corta, casi todo lo que hemos hablado aquí es aplicable también a las propiedades, salvo el contexto en el que son accesibles.

Propiedades

Las propiedades son variables de clase

Esta sección va a ser muy cortita en realidad. Ya explicamos todo lo que hay que saber sobre las propiedades de una clase si hemos leído las secciones anteriores.
Las propiedades son variables también, sólo que no son locales. Su ámbito o contexto es toda la clase, en lugar de una sola función.

¿Por qué molestarse entonces en definir variables locales? Si las propiedades son accesibles desde cualquier método de la clase, nos ahorraríamos quebraderos de cabeza al intentar acceder a una variable local desde un método que no es en el que se ha declarado.

La explicación puede no ser obvia ahora mismo, pero poco a poco te darás cuenta de que tiene mucho sentido:

Cada parte de un programa sólo debe conocer la información que necesita

Esta afirmación obedece a un principio general de la POO que se denomina principio de encapsulamiento.

Este aislamiento protege a los datos asociados a cada pieza del puzle contra su modificación por quien no tenga derecho a acceder a ellos, eliminando efectos secundarios e interacciones no previstas e incontroladas.

Sólo si es esctrictamente necesario para el funcionamiento de un conjunto de piezas relacionadas, debemos hacer accesible a todas ellas las variables que contendrán la información que necesitan.

Por eso existen las propiedades de la clase, para hacer accesible a varios métodos que trabajen en equipo la misma información, permitiendo también que todos ellos la modifiquen cuando sea conveniente.

Voy a ponerte un ejemplo:
Supongamos que quiero hacer un programa que realiza la animación de una pelota cayendo y rebotando. Este ejemplo es ya algo más serio que todos los anteriores, así que presta atención:
Recupera el primer ejemplo de la pelota que añadíamos a la pantalla en Fundamentos de AS3: Destripando la clase documento y su constructor. El punto de entrada a un programa
Te recuerdo que debes tener en la biblioteca un símbolo exportado para AS3 con la forma de una pelota.
En la clase documento (en el archivo Main.as) teníamos el siguiente código:

		package 
		{
			import flash.display.MovieClip;
			 
			public class Main extends MovieClip
			{
				public function Main()
				{
					var miPelota:Pelota = new Pelota();
					addChild(miPelota);
					miPelota.x = 100;
					miPelota.y = 175;
				}
			}
		}

Repasa las explicaciones si no te acuerdas de lo que significaba cada línea.
De momento vamos a dejar el constructor como está y vamos a crear el método que va a realizar la animación.
Después suscribiremos ese método a un eventoTe contaré en detalle como funcionan los eventos y este mecanismo de suscripción más adelante. De momento basta con que sepas que un evento es una señal que se dispara cuando algo concreto sucede en el sistema (un click del ratón, una tecla pulsada, etc. Los objetos que descienden de MovieClip son capaces de detectarlos y de llamar a los métodos que sehan suscrito a un evento concreto cuando este se prodduce. A estos métodos se les llama listeners que se dispara en cada fotograma de la línea de tiempo de Flash.

+

Más información

Así, este método va a estar ligado al timeline y se ejecutará en cada fotogramaTantas veces por segundo como el valor que hayamos introducido en la propiedad velocidad de fotogramas del docucumento. De hecho, lo vamos a llamar enCadaFotograma(), y lo vamos a colocar detrás del método constructor (Podríamos colocarlo encima, pero parece más lógico ponerlo debajo ¿no?). De nuevo mantengo los números de línea pero no escribo toda la clase:

		//...
		private function enCadaFotograma(evento:Event):void 
		{
			vX = vX + aX;
			vY = vY + aY;
			pelota.x = pelota.x + vX;
			pelota.y = pelota.y + vY;
		}
		//..

Donde:

  • vX, y vY son las componentes x e y de la velocidad, respectivamente.
  • aX, y aY son las componentes x e y de la aceleración, respectivamente

Antes de que te bloquees porque de repente esto parece más una clase de física que de programación, lee mi explicación. De veras que es muy sencilla:

  1. La velocidad es la distancia que se mueve un objeto por unidad de tiempo.
  2. La aceleración es lo que varía la velocidad por unidad de tiempo

Ya está. No hay más física de por medio. Ahora, la unidad de distancia en la pantalla es el pixel y la de tiempo, cuando programamos en ActionScript, el fotograma.
Si decimos que la velocidad es 3, significa que la pelota se mueve 3 pixeles en cada fotograma. Luego es lógico que en cada fotograma le sumemos a la posición de la pelota su velocidad.
Si la aceleración es -1, por ejemplo, eso significa que la velocidad se ha de reducir en 1 en cada fotograma. Por tanto no es descabellado sumarle a la velocidad la aceleración en cada fotograma.

+

Más información

Se acabó la clase de física, volvamos a la de programación.

Todo esto está muy bien pero tal y como decíamos en el apartado anterior, pelota es una variable local del método constructor. No podemos usarla tal cual en el método enCadaFotograma().

Además, tendremos que definir en algún lugar vX, vY, aX y aY.

El método anterior, tal como está escrito y sin hacer nada más en la clase va a provocar varios errores, debido a ésto.

Está claro que pelota tiene que ser definida como propiedad de la clase y no como variable local. Pero ¿qué pasa con las componentes de la velocidad y de la aceleración? ¿Han de ser propiedades o variables locales?

La respuesta es que han de ser propiedades, porque aunque no tuviera que darles un valor inicial en el constructor (que lo voy a tener que hacer), si las declarara como variables locales en enCadaFotograma() no conservarían su valor entre ejecución y ejecución de dicho método. Recuerda que vamos a hacer que se ejecute en cada fotograma.

Las sentencias que he escrito dentro del método tienen sentido si las variables conservan su valor anterior entre llamada y llamada, para que pueda actualizarlas sumandoles aX en el caso de vX, aY en el de vY, etc.

La clase definiendo todas estas variables como propiedades quedaría como sigue:

		package 
		{
			import flash.display.MovieClip;
			 
			public class Main extends MovieClip
			{
				private var vX:Number;
				private var vY:Number;
				private var aX:Number;
				private var aY:Number;
				private var miPelota:Pelota;
				
				public function Main()
				{
					vX = 0;
					vY = 0;
					aX = 0;
					aY = 0.5;
					
					miPelota = new Pelota();
					addChild(miPelota);
					miPelota.x = 100;
					miPelota.y = 175;
				}
				
				private function enCadaFotograma(evento:Event):void 
				{
					vX = vX + aX;
					vY = vY + aY;
					miPelota.x = miPelota.x + vX;
					miPelota.y = miPelota.y + vY;
				}
			}
		}

Definición de propiedades

Para definir una propiedad tengo que hacer lo mismo que para definir una variable local, salvo por dos detalles:

  1. La sentencia de definición tiene que estár fuera de cualquier método, pero dentro de la clase.

    Normalmente, se colocan entre la sentencia de definición de la clase y el consturctor.

  2. Delante de la palabra clave var hay que poner, lo que se denomina, un atributo de acceso. Este atributo en ActionScript puede ser: private, public, protected o internal.

    Hasta que no empecemos a crear varias clases por cada proyecto sólo tiene sentido utilizar private.

    Los demás valores del atributo de acceso serán explicados a debido su tiempo

Si has probado a compilar el programa anterior habrás visto que no hace nada. La pelota se queda quieta allí donde se ha colocado con las líneas 22 y 23.

Eso es porque falta el ingrediente secreto. La sentencia que suscribe el método enCadaFotograma() al evento Event.ENTER_FRAME, que es el que se dispara cada vez que la línea de tiempo pasa de un frame al siguiente.

Esta sentencia mágica es una llamada a un método de MovieClipRecuerda que nuestra clase documento extiende MovieClip y por eso posee todos los métodos definidos en la clase MovieClip y se ecribe como sigue:

		addEventListener(Event.ENTER_FRAME, enCadaFotograma);
		

addEventListener() es el método al que hay que llamar para suscribir el listener al evento que queremos que escuche.
Necesita lso valores para dos parámetros, en este orden: el evento y el método que hará de listener, es decir que se ejecutará cada vez que se produzca dicho evento.

Pero aún falta algo más. Sí ya sé que parece que esto no se acaba nunca, pero te prometo que esta vez sí.

Event es una clase, que estamos usando en la línea 26 y ahora cuando introduzcamos la llamada a addEventListener(), que no forma parte del núcleo del lenguaje (hablábamos sobre ello al final del apartado sobre los tipos de dato) y hay que importarla, así que la clase final con estas dos adiciones quedaría así:

		package 
		{
			import flash.display.MovieClip;
			import flash.events.Event;
			 
			public class Main extends MovieClip
			{
				private var vX:Number;
				private var vY:Number;
				private var aX:Number;
				private var aY:Number;
				private var miPelota:Pelota;
				
				public function Main()
				{
					vX = 0;
					vY = 0;
					aX = 0;
					aY = 0.5;
					
					miPelota = new Pelota();
					addChild(miPelota);
					miPelota.x = 100;
					miPelota.y = 175;
					
					addEventListener(Event.ENTER_FRAME, enCadaFotograma);
				}
				
				private function enCadaFotograma(evento:Event):void 
				{
					vX = vX + aX;
					vY = vY + aY;
					miPelota.x = miPelota.x + vX;
					miPelota.y = miPelota.y + vY;
				}
			}
		}

Ok!. Si compilas verás caer a la pelota con una aceleración que simula la gravedad.
Pero se te sale enseguida de la pantalla. Vamos a añadir unas líneas al final del método enCadFotograma() para darle un poco de gracia al programa y hacer que la pelota se quede botando en el borde de la ventana:

		package 
		{
			import flash.display.MovieClip;
			import flash.events.Event;
			 
			public class Main extends MovieClip
			{
				private var vX:Number;
				private var vY:Number;
				private var aX:Number;
				private var aY:Number;
				private var miPelota:Pelota;
				
				public function Main()
				{
					vX = 0;
					vY = 0;
					aX = 0;
					aY = 0.5;
					
					miPelota = new Pelota();
					addChild(miPelota);
					miPelota.x = 100;
					miPelota.y = 175;
					
					addEventListener(Event.ENTER_FRAME, enCadaFotograma);
				}
				
				private function enCadaFotograma(evento:Event):void 
				{
					vX = vX + aX;
					vY = vY + aY;
					miPelota.x = miPelota.x + vX;
					miPelota.y = miPelota.y + vY;
					
					if(miPelota.y > stage.stageHeight - miPelota.height/2)
					{
						vY = -vY;
						miPelota.y = stage.stageHeight - miPelota.height/2;
					}
				}
			}
		}

Seguramente no hace falta que te explique lo que hacen esas líneas. Si no lo ves a simple vista considera un ejercicio el averiguarlo. Aquí nos hemos quedado ya sin espacio para más explicaciones 😉

Así es como queda:

Recapitulación

Una variable no contiene valores, es más como un enlace web. Referencia un valor que está almacenado en la memoria. Es la mecanismo que permite localizar, usar y modificar ese valor.

Una variable puede hacer referencia a lo que consideramos un valor simple o a un objeto.
En realidad los valores que consideramos simples (un número, una cadena de texto) también son objetos en los lenguajes orientados a objetos. Así que no hay realmente una distinción, siempre que hablemos de valores, estaremos hablando de objetos que tienen propiedades y métodos.

Las variables hay que definirlas antes de poder usarlas. Al definirlas especificamos su nombre y el tipo de dato u objeto al que referencian.

		var _nombreDeVariable_:_TipoDeDato_;
		

Los tipos de dato se definen, o ya están definidos, en clases.

Por el ámbito de una variable, es decir, por el contexto en el que es accesible, podemos decir que tenemos dos tipos:

  • Variables locales:
    Se definen dentro del cuerpo de un métodoVer Fundamentos de AS3: Definición de métodos y sólo son accesibles desde ese método. Cuando el método termina de ejecutarse la variable se destruye.
    El objeto al que hace referencia continúa existiendo, pero ya no se puede acceder a él a través de esta variable.

    Ejemplo de definición y uso:

    				package 
    				{
    					import flash.display.MovieClip;
    				 
    					public class Main extends MovieClip
    					{
    						public function Main()
    						{
    							var alumno:String;
    							alumno = "Pepito Grillo";
    							trace (alumno);
    						}
    					}
    				}				

    En el ejemplo la variable se está definiendo en el constructor de la clase. Pero podemos definir una variable dentro de cualquier método.

  • Propiedades:
    Se definen en la clase, pero fuera de cualquier método (Se suele hacer al principio de la misma, antes del método constructor). Son accesibles desde cualquier método de la misma clase.

    Ejemplo de definición y uso:

    				package 
    				{
    					import flash.display.MovieClip;
    				 
    					public class Main extends MovieClip
    					{
    						private var alumno:String;
    						
    						public function Main()
    						{
    							alumno = "Pepito Grillo";
    						}
    						
    						private function mostrarAlumno():void
    						{
    							trace (alumno);
    						}
    					}
    				}				

En esencia una variable y una propiedad son lo mismo, un enlace o referencia a un objeto. La diferencia estriba en los lugares desde los que podemos utilizar esa variable una vez definida.

Volver al Índice

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s