Algunos conceptos basicos del ActionScript 3

El ActionScript3 es un lenguaje muy potente. De todas las versiones de actionscript, esta es la que me parece más de verdad (sin querer ofender a nadie...) Talvez por venir del lado de Java uno espera encontrarse con algo más maduro y la verdad eso ha pasado con el AS3. Pretendo ir mostrando algunas cosillas que me han ido llamando la atención en este camino.... Aquí hay una muy buena comparación entre el Actionscript 3 y Java si quiere profundizar más.

Algunos conceptos básicos:
En AS3, no existe la herencia múltiple (como en java), solo se permite heredar de una clase directamente. Sin embargo se permite la implementación de múltiples interfaces a la vez.

Las interfaces si pueden heredar de multiples interfaces a la vez.

Cada clase debe estar dentro de un paquete masomenos algo así:

package mi.paquete{

public class miClase{

}

}


No existen metodos o clases abstractas, como se conocen en java. Se pueden tener metodos sin cuerpo dentro de las clases, sin embargo no se obliga a las subclases su implementacion, solamente se podría documentar que el método se debe implementar o hacer uso de las interfaces, que si obligan a implementacion del método.


Ciclos

AS3 cuenta con los mismos ciclos que la mayoría de lenguajes. Sin embargo añade en esta version un ciclo que es muy útil y es el for each...
Se utiliza cuando se tienen una colección de objetos dentro de un Array o ArrayCollection y te permite navegar por la lista completa haciendo él la asignación automáticamente.
Ej:
Suponiendo una coleccion de objetos llamada "objetos" - todos de tipo MiObjeto

var obj:MiObjeto;
for each(obj in objetos){
trace (obj.nombre);
}

la variable obj va tomando un valor de acuerdo a como se va avanzando en la coleccion.
Esto tambien es bueno, ya que muchos programadores tienen la mala costumbre de crear nuevos objetos dentro del ciclo algo como:

for (var i:int=0; i < objetos.lenght ;i++){
var obj:MiObjeto = objetos.get(i);
trace (obj.nombre);
}

Esto lo que hace es ir añadiendo nuevos objetos a memoria y una vez que estos dejan de ser "accesibles" por el resto de la aplicacion, quedan como candidatos para ser recolectados por el Garbage Collector del virtual machine. Talvez se piense que no hay problema si son 10, 20 objetos disponibles para ser recogidos... pero cuando son 100, 1000, 2000 o mas? El performance de la aplicación puede bajar en caso que al GC se le ocurra correr.

Tipos

AS3 es un lenguaje estricto(con tipos definidos) y a la vez dinamico (que se puede alterar ciertas clases añadiendo nuevas variables y tipos en el camino).

Hay tres tipos distintos de Tipos: Null, void y Object.
Null y void tienen un simple valor: null o undefined.
Object puede contener todas los tipos de clases que se definan, pues es la super clase de todas las cases...

Sin embargo es una buena práctica ser lo más apegados a la definición de tipos(modo estricto), por dos razones principales:
1. El performance de la aplicación es mejor, ya que somos específicos con el compilador para decirle que hacer y no tener él que inventar que hacer.
2. Hay menos posibilidades de equivocarse, se permite al compilador ayudarte a comprobar si se esta otorgando a las clases la información que se quiere y no llamando a metodos o atributos que no existen.

Para hacer esa definicion se hace:
var variable:tipo = valor;

El tipo debe contener: nombres de clases u interfaces o el simbolo *, que indica que es una variable sin tipo osea q puede recibir cualquier tipo de informacion que se quiera, sin que se genere un error.

Para verificar si un objeto es de un tipo especifico, se puede realizar de la siguiente manera:

if(objeto is MiObjeto){
trace(objecto.nombre);
}else if(objeto is MiObjeto2){
trace("Es de tipo 2"+objeto);
}

El proceso de casting esta muy ligado con el polimorfismo y la herencia. Es un proceso que nos permite convertir un objeto de un tipo especifico a otro tipo.
Supongase que se tiene un clase que se llama Vehículo, de ahí descienden carro y moto.
Podemos hacer un UpCasting para pasar un objeto de tipo Moto como un objeto de tipo Vehículo. Osea de una subclase a una superclase.
Esto se haria masomenos asi:

var moto:Moto = new Moto();
var vehiculo:Vehiculo = moto as Vehiculo;
o
var vehiculo:Vehiculo = Vehiculo(moto);

El método para pasar de una super clase a una subclase (downcasting), es parecido:
var honda:Vehiculo = new Moto();
var moto:Moto = honda as Moto;
o
var moto:Moto = Moto(honda);

Sin embargo con el downcasting, existe el riesgo que se quiera hacer a una clase que no es subclase... por ejemplo castear de vehiculo a un objeto de tipo perro, que no tienen relación. Por eso es importante usar "is" como metodo de comprobacion, ej:
if(honda is Moto){
var moto:Moto = honda as Moto;
}

Namespaces

Como en XML, definen un area de acción que permite tener varias miembros con un mismo nombre, sin que existan conflictos entre otras clases, por ejemplo que se herede de componentes ya hechos y que no exista conflictos entre las nuevas definiciones y las echas en el componente previamente o para definir mismas funciones pero para distintos ambitos.

Se declaran asi:
Dentro de un paquete:
package mis.clases{
public namespace uno;
public namespace dos;
}

Luego desde una clase se importan:

import mis.clases.*;

y se utilizan desde la clase:

package mis.clases{
public class MiClase{
uno static function holaMundo():void{
trace('Hola Mundo desde namespace uno');
}
dos static function holaMundo():void{
trace('Hola Mundo desde namespace uno');
}
}
}

Y para accesar las funciones de MiClase, desde el cliente se usa la palabra "use"
Ejm:
...
use uno;
use dos;
...
MiClase.uno::holaMundo(); //Imprime: Hola Mundo desde namespace uno
MiClase.dos::holaMundo(); //Imprime: Hola Mundo desde namespace dos