Home » Aportes »AS2 »Flash »POO »Referencia » Currently Reading:

Lo que yo sé de AS2 #Clases, instancias, propiedades

marzo 17, 2007 Aportes, AS2, Flash, POO, Referencia 3 Comments
Lo que yo sé de AS2 #Clases, instancias, propiedades

Lo que yo sé de AS2 (condensado y pasteurizado)

img*AUTOR: Juan Delgado Zárate
zarate.tv | dandolachapa.com | loqueyosede.com
FlashLa.com | After-Hours.org

Clases, instancias, propiedades

>Indice de contenidos

Cualquier elemento de una película Flash puede ser una clase. Un botón, un menú, un componente ScrollArea… lo que sea. Pero no sólo los elementos gráficos pueden ser clases. La “lógica” de tu aplicación también lo puede ser: cuando hago click aquí, sumo 2 y muevo el menú. También puedes crear clases para mandar y recibir datos del servidor, etc.

Decidir qué convertimos en clase y qué dejamos como código “normal” es algo que siempre depende del programador y del proyecto. Supón que quieres hacer una aplicación que lee datos de un xml, los muestra en un campo de texto y que tiene un botón para mandar el texto de nuevo al servidor. El conjunto de clases podría variar desde una clase para hacerlo todo, a una clase para la aplicación, otra para la lectura y envio de datos, otra para el campo de texto y otra para el botón.

Meter todo en la misma clase no parece una idea muy feliz. Podrías fácilmente llegar a 1.000 líneas de código y estarías mezclando lógica con presentación, no podrías reusar nada de lo que hayas hecho… Por el contrario hacer una clase para todos y cada uno de los elementos de una aplicación te puede llevar a una pesadilla de montones de clases que no hacen prácticamente nada. Como siempre, es cuestión de práctica. Asume que para mejorar te tienes que equivocar, así que cuanto más practiques menos errores cometerás.

Como regla general yo diría que siempre es bueno conjuntos de clases para:

  • Manter el estado y la lógica de la aplicación. Lo que luego llamaremos modelo.
  • Una o varias clases para el pintado. Lo que luego llamaremos vista.
  • Una o varias clases para el acceso y escritura de los datos. Suponiendo una aplicación que maneja usuarios (alta, baja, edición), en lugar de poner todos esos procesos (lectura de xml, envio de nuevos datos al servidor) en el modelo, yo prefiero que el modelo haga esas peticiones a una clase específica. De esa forma el modelo (y la aplicación) es independiente de dónde vienen los datos.
  • Clases para componentes gráficos. Típico TextArea, RadioButton, CheckBox, etc. etc.
  • Tener clases comunes para tareas no específicas de un proyecto. Es muy común que necesitemos una clase para pintar un cuadrado o un círculo. En ese caso se puede crear una clase llamada rawUtils con métodos estáticos para círculo, cuadrado, triángulo… Lo mismo para sustituir los protos y añadir funcionalidades extra a String o Array.

Partes de una clase

Cuando se crea una clase, hay que utilizar su classpath completo mas su nombre para definirla. Por ejemplo:

  1. classtv.zarate.Utils.Trace{
  2.     //codigo
  3. }

El nombre de la clase es “Trace” (y ese tiene que ser el nombre del archivo .as), y se encuentra dentro de las carpetas tv > zarate > Utils. A la hora de importarla también hay que utilizar toda la definción de la clase:

importtv.zarate.Utils.Trace;

Dentro de una clase tenemos propiedades (que contienen los datos o información de una clase) y métodos (normalmente para realizar operaciones con la información de las propiedades).

Todos los métodos de una clase pueden acceder a sus propiedades, pero además puede definir variables locales. Las variables locales a una función se eliminan cuando la ejecución de una función se termina.

En AS2 todo lo que tiene representación gráfica se hace sobre objetos MovieClips. Es decir, no se puede “pintar” sobre nada que no sea un MovieClip. Esto NO quiere decir que tus clases tengan que extender de MovieClip, pero de eso hablaremos luego.

Diferencias entre clases/métodos estáticos e instancias de clases

Una clase “normal” es aquella de la que se crean instancias utilizando la palabra clave “new”. Algo como lo siguiente:

  1. varinstance:MyClass=newMyClass();
  1. classMyClass{
  2.     publicvarvariableAccesible:String="Aquí puede acceder todo el mundo";
  3.     privatevarvariableNoAccesible:String="Aquí, teóricamente, no";
  4.     publicfunctionMyClass(){
  5.         //estemétodoeselconstructor
  6.         //yseejecutasiemprequesecrea
  7.         //unanuevainstancia
  8.     }
  9. }

Las clases estáticas son aquellas que se pueden utilizar sin crear una instancia. Por ejemplo la clase Math:

  1. varpi:Number=Math.PI;

¡OJO! Las clases normales pueden tener variables estáticas. De hecho, son muy útiles para algunos casos. Por ejemplo. Supongamos que tenemos una clase que representa un juego.

  1. classMyGame{
  2.     publicstaticvarRIGHT:String="right";
  3.     publicstaticvarWRONG:String="wrong";
  4.     privatevarstate:String="";
  5. }

Eso nos permite hacer algo como:

  1. vargame:MyGame=newMyGame();
  2. game.state=MyGame.RIGHT;

De esa forma sólo definimos la cadena “right” en un sitio y a partir de ahí utilizaríamos el valor de la variable estática. De esa forma nos ahorraremos errores tipográficos y, si por ejemplo hubiera que cambiar la cadena “right” por “correcto”, no habría ningún problema ya que estaríamos accediendo a una variable.

Público vs privado

Los métodos y las propiedades de una clase pueden ser públicos o privados. Aunque sea bastante obvio, las propiedades y métodos públicos son accesibles por la propia clase y clases externas. Todo lo que sea privado sólo puede ser usado (en teoría) por la propia clase y las que extiendan de ella. Por ejemplo:

  1. classA{
  2.     publicfunctionA(){
  3.     }
  4.     publicfunctiondoSomethingPublic():Void{
  5.     }
  6.     privatefunctiondoSomethingPrivate():Void{
  7.     }
  8. }
  1. importclassA;
  2. vara:A = newA():
  3. a.doSomethingPublic(); //bien
  4. a.doSomethingPrivate(); //ERRORalcompilar

Las propiedades y métodos públicos componen la API (Application Programming Interface) de nuestra clase para otras clases. Es decir, suponen el conjunto de “cosas” que se pueden hacer con ella.

Como regla general, haz privado todo lo que puedas. Si no hay una buena razón para que un método sea público, mejor que sea privado. La razón es sencilla. Supongamos que pasado un tiempo nos damos cuenta de que hay que pasar un método de privado a público. Como ninguna clase externa

puede estar utilizando ese método (es privado), no romperemos la compatibilidad hacia atrás, no habrá problemas al compilar.

Sin embargo el caso contrario no es tan sencillo. Si pasamos un método (o propiedad) de público a privado, nos podemos encontrar con que otras clases externas lo pueden estar utilizando. Al intentar recompilar, podríamos tener errores.

Recordar también que en AS2 si no se define public/private, tanto las propiedades como los métodos son públicos por defecto.

Acceder a los métodos y propiedades de una clase desde la propia clase

Para acceder a las propiedades y métodos de una clase desde la propia clase NO es necesario utilizar this. Dicho esto, hay gente que lo considera best practice ya que ayuda a ver dentro de un método si se está usando una propiedad de la clase, una variable local, o un parámetro.

Composición y herencia

Herencia

Una clase hereda de otra utilizando la palabra clave extends. Y cuando una clase hereda de otra automáticamente añade a su código el código de la clase padre, todos sus métodos y propiedades.
Lo bueno es que la clase hija puede decidir si quiere modificar el comportamiento de la clase padre o simplemente añadirle nuevas funcionalidades. Ejemplo:

  1. classA{
  2.     publicvargreeting:String="helloworld";
  3.     publicfunctionA(){
  4.     }
  5.     publicfunctionmyFirstTrace():Void{
  6.         trace(greeting+"I´mclassA!");
  7.     }
  8.     publicfunctionmySecondTrace():Void{
  9.         trace("ClassAsecondtrace");
  10.     }
  11. }
  1. importA;
  2. classBextendsA{
  3.     public function B(){
  4.         super();
  5.         greeting = "Hello people";
  6.     }
  7.     public function myFirstTrace():Void{
  8.         super.myTrace();
  9.         trace(greeting + " I´m class B!");
  10.     }
  11.     public function mySecondTrace():Void{
  12.         trace("ClassBsecondtrace");
  13.     }
  14. }

Fijaos como la clase B no necesita definir como propiedad “greeting”, ya que la hereda de A. Luego, si llamamos al método myFirstTrace de la clase B tendremos 2 traces, el de A y el de B. Esto
es así porque la clase B está llamando al método de la clase padre con la palabra clave super. Importante notar que la traza que obtendremos de la clase A no es la esperada, ya que la variable
“greeting” ha sido predefinida en la clase B.

Sin embargo, si llamamos al método mySecondTrace de la clase B sólo obtendremos una traza, ya que la clase B no llama al método de la clase padre.

Predefinir completamente los métodos o propiedades de la clase padre o llamarlos mediante super y luego ejecutar más acciones específicas depende por completo de la situación y de lo que queramos
conseguir.

Composición

Utilizamos composición entre 2 clases cuando una clase recibe como parámetro una instancia de la otra. Por ejemplo:

  1. classA{
  2.     publicfunctionA(){}
  3. }
  1. importA;
  2. class B{
  3.     private var a:A;
  4.     public function B(_a:A){
  5.         a = _a;
  6.     }
  7. }
  1. importA;
  2. importB;
  3. classC{
  4.     publicfunctionC(){
  5.         vara:A=newA();
  6.         varb:B=newB(a);//BrecibecomoparámetrounainstanciadeA
  7.     }
  8. }

Que empiece la fiesta

Después de probar varios métodos creo que la forma más sencilla de iniciar una aplicación completamente AS2 y OOP es utilizar el método estático “main”. Para empezar en tu clase
necesitarías tener algo como:

  1. classcom.myweb.MyClass{
  2.     privatevartimeLine_mc:MovieClip;
  3.     publicfunctionMyClass(m:MovieClip){
  4.         timeLine_mc=m;//guardamosreferenciaalMCdetrabajo//todotuyoapartirdeaquí:)
  5.     }
  6.     publicstaticfunctionmain(m:MovieClip):Void{
  7.         //aquínosllegacomoparámetroelMovieClipsobre//elque"trabajar"
  8.     varinstance:MyClass=newMyClass(m);
  9.     }
  10. }

Luego, en línea de tiempo principal de tu fla, el siguiente código (que es lo que hace MTASC cuando compilamos con main):

  1. importcom.myweb.MyClass;
  2. MyClass.main(this);

Lo que estamos haciendo es llamar al método estático main y pasarle una referencia al MovieClip sobre el que queremos que trabaje la aplicación.

Lo bueno de utilizar este método o algo parecido es que no estamos haciendo nunca referencia explícita a “_root”, por lo que si por la razón que sea, el swf en el que tenemos compilada la aplicación es cargado dinámicamente por otra película, no tendría ningún problema de referencias. En lugar de trabajar sobre la línea de tiempo principal, lo haría sobre la del MovieClip que haya sido cargada.

[ anterior ] [ siguiente ]

img

Compártelo:

Lo que yo sé de AS2 #Clases, instancias, propiedades
Visto 5.322 veces

Currently there are "3 comments" on this Article:

  1. pet dice:

    Hola, no se si viene mucho al caso, pero estoy haciendo un juego en as3 con MVC y tengo una duda que quizá puedas resolverme.
    La vista como se comunica con el controlador para que este modifique el modelo? lanzando un evento al que esté subscrito el controlador o teniendo una refrencia al controlador?

    gracias

Comment on this Article:








Twitter: zguillez

AdvertisementAdvertisementAdvertisementAdvertisement

Recibe las novedades por email



Map

Ranking

Codigoactionscript.org: 4.65 sobre 5 (106 valoraciones)

twitter-widget.com