Comunidad de diseño web y desarrollo en internet

Programación orientada a objetos en ActionScript 2

Desde que Xerox crease (En teoria) el concepto de objetos en nuestros computadores, la programación orientada a objetos creo un nuevo paradigma del desarrollo en un nuevo entorno mucho mas modular y practico para el programador.
Sin embargo, muchos lenguajes actuales han hecho que la programación estructurada prevalezca.

ActionScript 1.0 es un ejemplo de ellos; que, aunque tenia un sistema "pseudo" basado en objetos; en realidad no implementaba como debia ser la POO y la hacia un poco abstracta para el desarrollador.
Ahora, la nueva versión de ActionScript, 2.0, ha cambiado este panorama, rigiendose a cabalidad con el estandar ECMA (Al que se acojen lenguajes como JavaScript o C#) y con un toque de similaridad a Java. Esto ha hecho mucho mas facil a los experimentados saltar de cualquier otro lenguaje a ActionScript y a los principiantes aprender el camino de la fuerza de una manera mas sencilla.

Recomiendo antes de leer este tutorial; que si no tienes muchos conocimientos en ActionScript o estas recien llegado a Flash MX 2004 leas el Tutorial de ActionScript 2.0 antes de continuar; asi mismo, se requieren conocimientos basicos de programación.

Si eres un experto de la programación o ya sabes que es esto de la orientación a objetos, saltate esta sección y ve directo a "Programación orientada a objetos en ActionScript 2.0"; si en cambio estas recien llegado a este mundo o no sabes que es la POO, inicia desde aqui

Indice de contenidos

  • ¿Que es la programación orientada a objetos?
    • Abstracción
    • Encapsulación
    • Herencia
  • Programación orientada a objetos en ActionScript 2.0
    • 1r Movimiento: Archivos externos .as, primera clase
    • 2o Movimiento: Miembros y Abstracción
    • 3r Movimiento: Encapsulación, getters y setters
    • 4o movimiento: Clases abstractas, Herencia y super
    • 5o Movimiento: Interfaces
  • Conclusiones

¿Que es la programación orientada a objetos?

Esta tecnica en si, se basa en el modelo de la vida real; donde tenemos objetos y estos a su vez tienen atributos y funciones (O en un lenguaje mas tecnico; propiedades y metodos)
Por ejemplo; la mayoria de ustedes tendra el objeto Impresora, este objeto tiene una propiedad color, cuyo valor, probablemente sea gris, tambien tiene otras propiedades como "tener papel en la bandeja", cuyo valor puede ser verdadero o falso; la impresora tambien tiene la función o metodo principal Imprimir, que nos devuelve la hoja impresa, asi como el metodo Apagar, que no nos devuelve nada, pero internamente apaga la impresora.

Esto es precisamente el ejemplo de un objeto; es un elemento (que puede ser considerado como una variable) que nosotros programamos, asignandole propiedades y metodos, a esto se le llama Miembros de la Clase.

Pero ademas, los objetos pueden tener otras caracteristicas especiales que veremos detalladamente:

  1. Abstracción
  2. Encapsulación
  3. Polimorfismo
  4. Herencia

Antes de empezar con cada uno debo aclarar, que el codigo en si que compone a un objeto se llama Clase y cada nueva variable a la que le es asignado un tipo de Clase se llama Objeto; y advertir que el polimorfismo no esta realmente dentro de Flash, asi como, para los mas experiementados, la herencia multiple (Gomen Nasai).

Abstracción

Lo primero que se hace al construir un instrumento electronico es abstraer la mayoria de sus funciones; observa, por ejemplo, tu monitor; tiene una cantidad increible de transistores, chips y elementos electronicos que por medio de complejos mapas y rutas de electrones hacen que funcione como tal; pero para hacerlo funcionar no necesitas saber eso; solo necesitas oprimir el boton de encendido y el mismo guiara la electricidad por todo el flujo del circuito, analizara cada onda que llegue por sus cables de conexión del computador transformandola de analoga a digital y haciando que cada uno de esos unos y ceros aparezca como diferentes tonos de luminosidad frente a tus ojos ... pero tu solo oprimiste el boton de encendido; solo llamaste a la función "encender" del objeto "Monitor" y el objeto lo hizo todo dentro de si mismo; eso es abstraer los metodos de un objeto.

Ahora usemos el ejemplo de un objeto Persona, y todas sus caracteristicas.

En una Persona ocurre lo mismo; nosotros tenemos, por ejemplo, la función de hablar, que es una abstracción de una serie de procesos electricos cerebrales, movimientos musculares y modulación del aire; entonces, si creara un objeto Persona y quisiera hacerla hablar, abstraeria todas las cosas que hacen que una persona hable en una sola función y llamaria a esa función cuando la necesite, pasandole por parametro, lo que quiero que hable; tambien podria hacer que esa persona dijera su nombre si asigno al objeto Persona la propiedad nombre y solicito su valor al pedirle que hable; todo esto en codigo seria similar a :

//Declaro una nueva variable de tipo Persona; y por medio de new la creo en memoria
var sandra:Persona = new Persona();
//Le asigno a su propiedad nombre el valor "Sandra"
sandra.nombre = "Sandra";
//Le pido que hable; pasandole por parametro a su función "hablar" el texto que dira
sandra.hablar("Mi nombre es " + sandra.nombre);
//Esto hara que nuestra Persona "sandra" diga "Mi nombre es Sandra"

En conclusión; abstracción es aislar todos los complejos metodos y propiedades de un objeto; tratando de hacerlos mas simples y modulares cada vez.

Encapsulación

Hay muchos datos que no tiene porque conocerlo aquel que este usando la clase Persona; ya que son inherentes al objeto y solo controlan su funcionamiento interno; por ejemplo, cuando alguien te ve puede saber inmediatamente si eres hombre o mujer (propiedad) o puede hablarte y obtener una respuesta procesada (metodo); tambien puede conocer el color de tu cabello y ojos. En cambio, jamas sabra que cantidad de energia exacta tienes o cuantas neuronas te quedan, ni siquiera preguntandote ya que ninguna de tus propiedades externas visibles o funciones de comunicación al publico te permiten saber esos datos.

Esto es la encapsulación u ocultación; hacer las variables que son innecesarias para el tratamiento del objeto pero necesarias para su funcionamiento privadas, asi como las funciones que no necesitan interacción del usuario o que solo pueden ser llamadas por otras funciones dentro del objeto (Como por ejemplo, palpitar)

La encapsulación es muy conveniente y nos permite (Si programamos bien) colocar en funcionamiento nuestro objeto en cualquier tipo de sistema, de una manera modular y escalable (algunas de las reglas de la ingenieria del software).

Herencia

Este quizas es el tema que mas problemas causa al estudiante; sin embargo, no es dificil en su concepción.
El objeto Persona es un objeto muy generico y limitado en si; asi que se puede considerar como un objeto Abstracto; ya que por si mismo no puede crear una persona completa; sin embargo, sus funciones basicas son las mismas en todos los seres humanos, con diferencias puntuales, asi que podemos crear dos objetos Hombre y Mujer, que hereden todas sus caracteristicas genericas como respirar, hablar, nombre, etc, del objeto Persona, y sea en la implementación de cada objeto donde empiezen las diferencias.

Si lo hago asi, sabre que tanto mis instancias (Ver nota abajo) del objeto Hombre como las del objeto Mujer tendran el metodo respirar, hablar, etc; y la propiedad nombre, color de piel, color de cabello; etc. Pero, por ejemplo, solo el objeto Mujer tendra el metodo "dar a luz" si yo se lo programo y solo el objeto Hombre tendra el metodo "Fecundar".

Nota: Se le llama instancia a cada variable que tenga dentro de si un objeto de una clase especifica; un ejemplo de instancia es el objeto "sandra" que declaramos en el codigo de arriba; solo son consideradas instancias despues de que se les asigna memoria (Con la palabra clave new).


Todo esto es posible gracias a que el objeto Hombre y el objeto Mujer heredaron del objeto Persona todas sus propiedades y metodos.

Aqui llega otro concepto que es el de objeto o Clase Abstracta; como es el objeto Persona, una clase abstracta es una clase de la que no se pueden instanciar objetos; solamente puede heredar a otro objeto sus propiedades y metodos, siendo el objeto heredado el que se instancie; en este caso, las clases Hombre y Mujer son instanciables porque heredan de la clase Persona; pero Persona no puede ser instanciada como un nuevo objeto, ya que al ser abstracta, el programador no se lo permite.

Programación orientada a objetos en ActionScript 2.0

Entremos en materia; vamos a ver ahora todas las caracteristicas anteriormente dichas aplicadas a ActionScript 2.0; asi que empezaremos con algunos ejemplos sencillos de clases incluidas dentro de Flash MX 2004 para ver como funciona.

Observando este codigo encontraras muchas de las propiedades que mencionamos anteriormente acerca de los objetos; en los que son inherentes en Flash; para esto, vamos a suponer que tienes un campo de texto llamado "area_txt" y un MovieClip llamado "pelicula_mc"; lee atentamente los comentarios del codigo por favor:

//Iniciemos con una muestra de como se manejan las propiedades y miembros dentro de Flash

/*Si conoces previamente cualquier lenguaje moderno veras que se rige por una sintaxis del
tipo NOMBRE.VALOR o NOMBRE.FUNCION donde nombre es el nombre de nuestro objeto; aqui en
Flash no es diferente :D*/
/*Para empezar, vamos a ver las PROPIEDADES, en este ejemplo, vamos a modificar la propiedad
"text" de un campo de texto*/

area_txt.text = "Programación orientada a objetos";
/*Como puedes notar, las PROPIEDADES funcionan de la misma manera que simples variables
Guardan un valor que tu puedes modificar */
/*Ahora veamos los METODOS, para esto, vamos a invocar al metodo "gotoAndPlay" de un Movieclip */

pelicula_mc.gotoAndPlay(50);
/*Los METODOS se manejan de la misma manera que las funciones, en este caso, esta tenia un parametro
"frame" cuyo valor pasamos como 50 */

/* Veamos la instanciación de objetos; vamos a crear un nuevo objeto "Date" */
var fecha:Date = new Date();
/* Primero coloco la instrución para declarar "var" luego el nombre de la variable, dos puntos y el
nombre de la clase de la que esta variable sera una instancia; por ultimo por medio de "new" asigno
memoria, diciendole que cree dentro de si un objeto "Date"; usamos el "()" como en las funciones para
invocar su constructor; un concepto que veremos mas adelante */

En este corto ejemplo solo usamos clases incluidas dentro de Flash, TextField (El campo de texto), MovieClip y Date; ahora vamos a ver como se crean estas clases

1r Movimiento: Archivos externos .as, primera clase

Lo primero que debes tener en cuenta que cuando estes programando clases, estas DEBEN ir en archivos externos .as; no pueden ser incluidas como parte del codigo dentro de la pelicula (Esto es muy conveniente, asi el codigo se vuelve reusable para otros proyectos).

Mas adelante trataremos el tema de los paquetes de clases y los namespace; por el momento, solo mantendremos los archivos .as en la misma carpeta de nuestro .fla y .swf.

Dentro de Flash, ve al menu File -> New (No vale CTRL+N) y en el cuadro de dialogo emergente elije "Actionscript File"; aparecera ante nosotros una vista de solo codigo, sin escenario; que sera donde podremos programar nuestra clase (Ahora claro, no es necesario hacer esto dentro del IDE de Flash; podemos perfectamente hacerlo desde el Bloc de Notas, VI o cualquier editor de texto externo a Flash)

Aqui empezaremos, creando nuestra primera clase; la clase Persona.

Coloca este codigo dentro de Flash, en el modo anterior de "Actionscript File"

//Inicio declaración de la clase
class Persona {
//Variable nombre, miembro de la clase
var nombre:String;
//Función constructora; se llama asi porque se ejecutara en el momento
//que se invoque la instrucción "new", es decir, cuando sea creada una
//instancia de esta clase

function Persona() {
//El uso del apuntador "this" indica que nos estamos refiriendo a los
//elementos de la clase; en este caso, modificaremos la variable "nombre"
//mencionada arriba

this.nombre = "";
//Esto simplemente para avisar en la ventana del output que la clase fue creada
trace("Una nueva Persona ha nacido");
}
}
Ahora guarden este archivo como "Persona.as" en una carpeta que usaremos para guardarlo todo; por el momento
IMPORTANTE: El nombre del archivo .as que contenga el codigo de las clases no es trivial; siempre el nombre del archivo debe ser el mismo nombre de la clase; por eso, en este caso, la clase se llama "Persona" y el archivo "Persona.as".
Solamente puede ser declarada UNA clase por archivo, si vas a crear 7 clases, entonces necesitaras 7 archivos
Ahora, crea una nueva pelicula, guardala con cualquier nombre en la misma carpeta donde colocaste el "Persona.as" y colocale este codigo en el primer keyFrame (Atención a los comentarios)
//Palabra clave que trae a nuestro codigo la clase que creamos; notese que no he colocado la
//extensión ".as"
import Persona;
//Creo una nueva variable llamada "freddie" de tipo "Persona"
var freddie:Persona;
//Asigno memoria a la variable "freddie" y la convierto en una instancia de la clase "Persona"
freddie = new Persona();

Prueba la pelicula con CONTROL+ENTER y notaras que en la ventana del Output aparecera el mensaje "Una nueva Persona ha nacido", demostrandonos que se ejecuto la función "Persona" al momento de contruirse el objeto; esto es a lo que se llaman "Constructores"

Asi hemos iniciado la programación orientada a objetos con nuestra primera clase; Persona

2o Movimiento: Miembros y Abstracción

Ahora definiremos los miembros de la clase; que no son mas que las funciones (metodos) y variables (propiedades) que integraran a nuestra clase.

Si enumeramos funciones basicas de una persona; esta debe

  1. Hablar
  2. Oir
  3. Tocar
  4. Mover

Y si hablamos de sus propiedades basicas

  1. Nombre
  2. Color de Ojos
  3. Color de Piel

Se que dejo muchisimas por fuera; pero esto es en pro de hacer mas sencillo el ejemplo.
Asi que, las funciones basicas seran metodos de nuestra clase y las propiedades ... lo mismo.

Vamos a modificar de esta manera nuestro codigo

//Inicio declaración de la clase
class Persona {

/* PROPIEDADES */
//Variable nombre, miembro de la clase
var nombre:String;

var colorOjos:String;
var colorPiel:String;
//Función constructora; se llama asi porque se ejecutara en el momento
//que se invoque la instrucción "new", es decir, cuando sea creada una
//instancia de esta clase
function Persona() {
//El uso del apuntador "this" indica que nos estamos refiriendo a los
//elementos de la clase; en este caso, modificaremos la variable "nombre"
//mencionada arriba
this.nombre = "";
//Esto simplemente para avisar en la ventana del output que la clase fue creada
trace("Una nueva Persona ha nacido");
}

/* METODOS */
//Metodo "hablar", recibe por parametro la frase que dira
//devuelve una frase procesada

function hablar(frase:String):String {
//La variable mensaje guardara "procesada" la frase que se dira
var mensaje:String = this.nombre+" dice: "+frase;
//Esta frase aparecera en el Output
trace(mensaje);
//Y asi mismo, la función la retornara
return mensaje;
}
//Metodo "ver"
function ver():Void {
trace(this.nombre+" esta mirando alrededor");
}
//Metodo "tocar"; recibe por parametro, otra persona para tocar
function tocar(personaTocada:Persona):Void {
trace(this.nombre+" ha tocado a "+personaTocada.nombre);
}
//Metodo "mover"; recibe por parametro el lugar a moverse
function mover(lugar:String):Void {
trace(this.nombre+" se mueve a "+lugar);
}
}
Y empezemos a hacerlo divertido; hagamos que dos "Personas" interactuen; modifiquen el codigo de la pelicula .FLA a esto:
//Trae a nuestro codigo la clase que creamos; notese que no he colocado la extensión ".as"
import Persona;
//Creo una nueva variable llamada "freddie" de tipo "Persona"
var freddie:Persona;
//Asigno memoria a la variable "freddie" y la convierto en una instancia de la clase "Persona"
freddie = new Persona();

//Creo otra persona
var sandra:Persona = new Persona();
//Les asigno nombres
freddie.nombre = "Freddie®";
sandra.nombre = "Shala";
//Empezamos a llamar a sus metodos :D
freddie.mover("donde esta la otra persona");
sandra.ver();
freddie.hablar("Hola, ¿como te llamas?");
sandra.hablar(sandra.nombre+" y tu?");
freddie.hablar("Yo soy "+freddie.nombre);
freddie.ver();
freddie.tocar(sandra);
sandra.hablar("Go to fuck");
freddie.hablar(":(");
Lo que mostrara la siguiente salida en la ventana del trace:
Una nueva Persona ha nacido
Una nueva Persona ha nacido
Freddie® se mueve a donde esta la otra persona
Shala esta mirando alrededor
Freddie® dice: Hola, ¿como te llamas?
Shala dice: Shala y tu?
Freddie® dice: Yo soy Freddie®
Freddie® esta mirando alrededor
Freddie® ha tocado a Shala
Shala dice: Go to fuck
Freddie® dice: :(
Bueno; aqui empiezo a ver que estas clases podrian ser utiles (aparte de por diversión) en algun tipo de chat hecho en Flash; pero en esta ocasión seran simplemente creadas con motivos "Educativos".
Nota: Ninguna de las situaciones interpretadas en este tutorial pertenecen o se relacionan a la vida real,

3r Movimiento: Encapsulación, getters y setters

En nuestro movimiento anterior; creamos propiedades y metodos "miembro" de la clase; como un color de ojos, hablar, ver etc. Ahora vamos a encapsular todos estos datos; algo escencial en la programación.

Como menciona antes en la teoria; la encapsulación es necesaria para crear una verdadera programación orientada a objetos.
La encapsulación nos permitira esconder del "mundo exterior" de la clase las variables y funciones internas que no llamaremos desde una instancia. De hecho, la teoria dice que nosotros NO DEBEMOS manipular directamente las propiedades (variables) de una clase; para ello usaremos un tipo de funciones llamadas getters y setters.

Nota: Las funciones getters y setters son funciones que nos permiten manipular la asignación y llamado de variables dentro de nuestro programa; como su nombre lo indica son funciones para asignar un dato a una variable set, o para obtener el dato de una variable get. Una vez creadas, cada vez que asignemos un dato a una variable sera llamada su función set y cuando pidamos el dato de una variable veremos su get.

Asi que a la orden del dia tenemos

  1. Hacer publicas las funciones o propiedades a las que accederemos desde el exterior
  2. Hacer privadas las funciones o miembros que no queremos/debemos acceder desde el exterior
  3. Crear funciones getter/setter para las propiedades que ahora son privadas y queremos modificar

Manos a la obra; modifiquen el codigo de la clase asi:

//Inicio declaración de la clase
class Persona {
/* PROPIEDADES */
//Variable nombre, miembro de la clase
public var nombre:String;
private var colorOjos:String;
private var colorPiel:String;
//Función constructora; se llama asi porque se ejecutara en el momento
//que se invoque la instrucción "new", es decir, cuando sea creada una
//instancia de esta clase
function Persona() {
//El uso del apuntador "this" indica que nos estamos refiriendo a los
//elementos de la clase; en este caso, modificaremos la variable "nombre"
//mencionada arriba
this.nombre = "";
//Esto simplemente para avisar en la ventana del output que la clase fue creada
trace("Una nueva Persona ha nacido");
}
/* METODOS */
//Metodo "hablar", recibe por parametro la frase que dira
//devuelve una frase procesada
public function hablar(frase:String):String {
//La variable mensaje guardara "procesada" la frase que se dira
var mensaje:String = this.nombre+" dice: "+frase;
//Esta frase aparecera en el Output
trace(mensaje);
//Y asi mismo, la función la retornara
return mensaje;
}
//Metodo "ver"
public function ver():Void {
trace(this.nombre+" esta mirando alrededor");
}
//Metodo "tocar"; recibe por parametro, otra persona para tocar
public function tocar(personaTocada:Persona):Void {
trace(this.nombre+" ha tocado a "+personaTocada.nombre);
}
//Metodo "mover"; recibe por parametro el lugar a moverse
public function mover(lugar:String):Void {
trace(this.nombre+" se mueve a "+lugar);
}

//GETTERS Y SETTERS //Funciones "get" y "set" para el color de ojos; funcionaran en el codigo //como una variable llamada "ojos" y sera llamado su set cada vez que se //le asigne algo; y su get cada vez que se solicite su valor
public function set ojos(color:String):Void {
trace(this.nombre+" tiene ojos de color "+color);
this.colorOjos = color;
}
public function get ojos():String {
return this.colorOjos;
} //Funciones "get" y "set" para el color de piel
public function set piel(color:String):Void {
trace(this.nombre+" tiene piel "+color);
this.colorPiel = color;
}
public function get piel():String {
return this.colorPiel; }
}

Como ven; he usado las palabras clave public y privatedel lenguaje ActionScript 2.0 para declarar algunas funciones y variables publicas y otras privadas. Las privadas solo podran ser llamadas desde el codigo dentro de la clase; mientras que las publicas se podran llamar desde cualquier lugar del codigo.

NOTA: toda función set debe asignarle algo a alguna variable miembro de la clase y toda función get debe retornar algun valor

Para ver un poco mas la utilidad de lo que acabamos de hacer y hacer uso de los setters y getters vamos a modificar y reescribir algunas partes del codigo en la pelicula .FLA:

//Trae a nuestro codigo la clase que creamos; notese que no he colocado la extensión ".as"
import Persona;
//Creo una nueva variable llamada "freddie" de tipo "Persona"
var freddie:Persona;
//Asigno memoria a la variable "freddie" y la convierto en una instancia de la clase "Persona"
freddie = new Persona();
//Creo otra persona
var sandra:Persona = new Persona();
//Les asigno nombres
freddie.nombre = "Freddie®";
sandra.nombre = "Shala";

//Les asigno color de ojos y piel
freddie.ojos = "negro";
sandra.ojos = "azul";
freddie.piel = "blanca";
sandra.piel = "morena";
//Empezamos a llamar a sus metodos :D
freddie.mover("donde esta la otra persona");
sandra.ver();
freddie.hablar("Hola, ¿como te llamas?");
sandra.hablar(sandra.nombre+" y tu?");
freddie.hablar("Yo soy "+freddie.nombre);
freddie.ver();

freddie.hablar("Me gustan tus ojos color "+sandra.ojos+" y tu piel "+sandra.piel);
sandra.hablar("Gracias :D");
freddie.tocar(sandra);
sandra.hablar("...");
freddie.hablar("...");
Lo que nos dara tambien un cambio en la ventana del trace:
Una nueva Persona ha nacido
Una nueva Persona ha nacido

Freddie® tiene ojos de color negro
Shala tiene ojos de color azul
Freddie® tiene piel blanca
Shala tiene piel morena
Freddie® se mueve a donde esta la otra persona
Shala esta mirando alrededor
Freddie® dice: Hola, ¿como te llamas?
Shala dice: Shala y tu?
Freddie® dice: Yo soy Freddie®
Freddie® esta mirando alrededor

Freddie® dice: Me gustan tus ojos color azul y tu piel morena
Shala dice: Gracias :D
Freddie® ha tocado a Shala
Shala dice: ...
Freddie® dice: ...

4o movimiento: Clases abstractas, Herencia y super

Repasemos los objetos de la vida real; todos los que estan leyendo esto tienen en frente un computador (O a los pies, no se); entonces tenemos la clase Computador de la que instanciamos objetos que son los que usamos; todos los objetos de la clase Computador hacen mas o menos lo mismo; tienen metodos para calcular, prender, apagar, escribir, borrar ... pero pensandolo bien; esas son las funciones generales de la clase Computador, porque en si, la clase es una clase abstracta; tu no tienes un Computador como el resto, tu Pc es especial, vamos a dividirlo en dos clases (Injusto, hay mas, pero estas son las mas comunes); PC y Mac, asi, a los PC puedes instalarles Windows y Linux y puedes usar procesadores Intel, Transmeta o AMD; esas son propiedades y metodos exclusivos de la clase "PC"; en los computadores que sean instancias de la clase "Mac", puedes instalar el MacOsX o Linux tambien, usas procesadores Motorola o PowerPC ... pero en ambos tienes las mismas funciones comunes de la clase Computador ... ¿como hacer que las igualdades prevalezcan y sin embargo podamos diferenciar una clase de la otra?; ah facil, creamos dos clases que tengan un pedazo del mismo codigo y el resto distinto ... y si tenemos 5000 clases con cosas en comun y quiero cambiar un detalle de lo "comun", tendria que cambiarlo en las 5000 clases ... la solución !Herencia¡

Con Herencia, podemos hacer que Computador sea una clase abstracta (Entiendase por clase abstracta una clase que no se puede instanciar, solo heredar) y crear dos nuevas clases, Mac y PC, que hereden de Computador todas sus propiedades y metodos e implementen ellas mismas sus propios. ¿Por que es importante que Computador sea una clase abstracta? Dado que Computador tiene los metodos y propiedades genericos, pero no los especificos, si un programador crea una instancia de una clase Computador aparte de que seria un poco inutil saltaria toda la teoria de la encapsulación del codigo

¿Y como hago lo que dicen las mil palabras de arriba en ActionScript?, bueno, implementemos las tres clases; una clase "Computador", en un archivo Computador.as, una "PC" en PC.as y una Mac en un archivo Mac.as; todas en la misma carpeta junto a un archivo FLA de cualquier nombre donde instanciaremos los objetos; iniciemos con el archivo Computador.as

//Esta sera nuestra clase Computador, de la que heredaran las otras dos
class Computador {
//Función constructora; este constructor se ejecutara primero que el
//constructor de la clase heredada

function Computador() {
trace("Creado un nuevo computador");
}
//Todos los computadores prenden ¿no?
public function encender():Void {
trace("El computador esta iniciando");
}
//Y todos se apagan ... en teoria
public function apagar():Void {
trace("El computador ha sido apagado");
}
}
Ahora el archivo PC.as
//La palabra clave "extends" es la que le indica a la clase que
//herede todas sus propiedades y metodos de una superclase, en
//este caso "Computador"

class PC extends Computador {
//Esta propiedad nos devolvera el sistema operativo
private var SO:String;
//Constructor del PC
function PC () {
trace("Has creado un PC");
}
//Función setter para colocar un sistema operativo
public function set sistema(SSOO:String):Void {
this.SO = SSOO;
}
//Función que me dira que sistema tengo instalado
public function sistemaInstalado(){
if(this.SO == "windows"){
trace("Tienes instalado Windows X_X");
} else if (this.SO == "linux"){
trace("Tienes instalado Linux ^_^");
} else {
trace("No se que tienes instalado O_o");
}
}
}
Luego nuestra clase Mac en Mac.as
//Aqui es lo mismo, solo que en la clase Mac
class Mac extends Computador {
//Constructor del PC
function Mac() {
trace("Has creado una Mac :-)");
}
//Como diferencia al PC, aqui instalamos Mac
public function instalarMac():Void {
trace("Has instalado MacOSX");
}
//Las Mac tienen "Rendezvous" que les permite configurarse solas
//en cualquier entorno de red; demosle esa capacidad

public function rendezvous():Void {
trace("Detectando redes cercanas ...");
trace("Red configurada ^^");
}
//Y una funcioncilla para navegar con Safari alguna web
public function safari(URL:String):Void {
trace("Estas navegando "+URL);
}
}
Por ultimo, en el archivo FLA vamos a "jugar" creando una Mac y una PC, haciendo cosas que haces ambas (por medio de la herencia de la clase Computador) y haciendo cosas que solo estan implementadas y son exclusivas de cada clase
//Importo las clases PC y Mac, estsa al heredar de la clase Computador
//importan automaticamente la misma

import PC;
import Mac;
//Inciemos con el PC
trace("**** SUNNY *****");
//Le asigno memoria,
var Sunny:PC = new PC();
//Llamo a una función de la clase Computador que hereda la clase PC
Sunny.encender();
//Llamo a un setter miembro de la clase PC nada mas
Sunny.sistema = "linux";
//Llamo a un metodo propio de la clase PC
Sunny.sistemaInstalado();
//Llamo al metodo apagar, de la clase heredada Computador
Sunny.apagar();
/**/
//Sigamos con el Mac

trace("**** BLUESHOCK *****");
//Le asigno el tipo "Mac" y creo la instancia de la clase con new
var Blueshock:Mac = new Mac();
//Llamo a un metodo de la clase Computador, heredado a Mac, por ende
//aparece en la clase Mac y PC

Blueshock.encender();
//Llamo al metodo propio de Mac "instalarMac", este no aparece en la
//clase PC

Blueshock.instalarMac();
//Otro metodo miembro de la clase Mac
Blueshock.rendezvous();
//Llamo al metodo Apagar, heredado de "Computador"
Blueshock.apagar();
Al darle CONTROL+ENTER a nuestra pelicula encontraremos que el Output nos muestra el proceso, donde se evidencia que cada vez que hacemos un new Mac() o un new PC() se ejecuta primero el constructor de la clase Computador, y luego el de la clase que lo heredo; vean y analizenlo ustedes mismos
**** SUNNY *****
Creado un nuevo computador
Has creado un PC
El computador esta iniciando
Tienes instalado Linux ^_^
El computador ha sido apagado
**** BLUESHOCK *****
Creado un nuevo computador
Has creado una Mac :-)
El computador esta iniciando
Has instalado MacOSX
Detectando redes cercanas ...
Red configurada ^^
El computador ha sido apagado

Asi de una manera sencilla hemos implementado herencia en nuestras clases de Flash.

Y bueno, como ya puedo verlos preguntandose ¿Y esto a mi de que me sirve aparte de complicarme la vida?; vamos a analizar un ejemplo practico, los componentes de Flash MX 2004.
Estos componentes, como pueden ver, tienen similitudes muy comunes; por ejemplo, casi todos tienen el evento change o click y en todos hace lo mismo y se implementa de la misma manera; todos tienen el evento setStyle, que permite cambiar el estilo del componente y asi la mayoria tiene cosas similares entre uno y otro; esto es porque todos los componentes heredan de una superclase llamada UIObject, que contiene las propiedaes y metodos basicos para todos los componentes; asi no tenemos que duplicar esfuerzos recreando cada propiedad o metodo comun, solo heredamos e incluimos las que marquen la diferencia.

En entornos profesionales de desarrollo esto es extremadamente util, ya que si perteneces a un equipo de programación y necesitas que X parte del proyecto este desarrollada antes de hacer la tuya, no es necesario; digamos que estamos haciendo un videojuego y tu tienes encargada la función de hacer los movimientos de los enemigos y otro compañero tuyo los movimientos del personaje principal; se puede crear una superclase llamada Persona, que contenga las bases fisicas comunes entre el movimiento de los enemigos y el de los personajes (Por ejemplo, la gravedad siempre es la misma) y despues de que se pongan de acuerdo que metodos tendra una Persona en comun, cada uno se pone a desarrollar su parte mientras otro termina la clase Persona.

Nota: Una SuperClase es el nombre comun que se le da a las clases abstractas o clases que son heredadas por otras; en este ejemplo, las clases normales eran PC y Mac y la SuperClase era Computador

5o Movimiento: Interfaces

Una interfaz basicamente es una declaración de propiedades y metodos de una clase sin codigo!!, es decir, una clase que solo tiene los nombres, los tipos y los parametros de los metodos y las propiedades, pero no las implementa; es muy util para pautar reglas en equipos de trabajo y algo similar a la herencia

Esta vez usaremos animales para nuestro ejemplo, un pato y un gato (No pregunten por que los escoji ); todos los animales comen, pero el gato come con el hocico y el pato con el pico, al ser procesos de igual nombre pero distinto proceso, una interface que implemente el metodo comer y luego ellos "implementen esa interface" y le pongan codigo respectivo seria lo ideal; asi mismo ambos caminan, pero uno lo hacen con dos patas y otro lo hace con 4

Lo primero que haremos entonces sera crear la interface de Animal; asi que creen un archivo Animal.as y coloquenle este codigo

//Declaramos nuestra interface "Animal"
interface Animal {
//Como ven, se declara la "comer", con un parametro
//"comida" de tipo "String" y es una función "Void" que no retorna nada, pero
//No se coloca codigo alguno en la función, solo se declara

function comer(comida:String):Void;
function caminar(destino:String):Void;
}
Ahora creemos las clases que implementaran esa interface, iniciando por Gato.as
//La palabra clave "implements" es la que me permite asignarle una interface
//a una clase

class Gato implements Animal {
//El constructor de toda la vida ;-)
function Gato() {
trace("miau");
}
//Ahora la implementación de las funciones de la interface
//Debe escribirse exactamente igual a como esta en la interface

public function comer(comida:String):Void {
trace("El gato, con su hocico esta comiendo "+comida);
}
//Igual la de caminar
public function caminar(destino:String):Void {
trace("El gato, camina en sus cuatro patas a "+destino);
}
}
Pasemos a la clase Pato, en Pato.as
class Pato implements Animal {
//Lo mismo, un constructor para el pato
function Pato() {
trace("quack!");
}
//De nuevo implementamos los metodos descritos en la interface
//Aqui con un codigo distinto

public function comer(comida:String):Void {
trace("El pato come "+comida+" usando su pico");
}
//Igual la de caminar
public function caminar(destino:String):Void {
trace("Hacia "+destino+" camino en dos patas el pato; lol");
}
}
Para terminar como siempre, creamos un FLA en la misma carpeta de los .AS; que es donde crearemos las variables y el codigo que le da utilidad a nuestras clases; en el colocamos (Primer keyFrame):
//Importo las clases Gato y Pato, que implementan la interface Animal
import Gato;
import Pato;
//Les asigno tipo de objeto y memoria
var garfield:Gato = new Gato();
var lucas:Pato = new Pato();
//Llamo a la función comer, declarada en la interface y escrita en la clase
garfield.comer("lasaña");
//Igual con la de caminar
garfield.caminar("el sofa");
//Si notan, se llama igual, pero su codigo y función es diferente
lucas.comer("maiz");
lucas.caminar("el fin del mundo");
Y si le damos CONTROL+ENTER, podemos ver su comportamiento reflejado el el Output, las funciones fueron implementadas con mismo nombre, tipo y argumentos, pero con distinto codigo que genera resultados diferentes
miau
quack!
El gato, con su hocico esta comiendo lasaña
El gato, camina en sus cuatro patas a el sofa
El pato come maiz usando su pico
Hacia el fin del mundo camino en dos patas el pato; lol

Asi hemos implementado un sistema simple de interfaces entre dos clases.

Conclusiones

La programación orientada a objetos es un mundo increible de posibilidades sin fin, que no puede ser cubierto en un solo tutorial y, por su naturaleza de composición mas artistica que cientifica, depende de la experiencia y del programador la buena implementación de la misma.
Algunos temas que recomendaria consultaras por tu cuenta serian clases, propiedades y metodos estaticos y paquetes; interesantes para el orden de una aplicación.
En Cristalab tenemos un ejemplo util del uso de Clases en ActionScript 2.0 y es la Galeria de fotos clab_Gallery; un interesante proyecto de nuestra web que implementa muchos de los conceptos vistos aqui :D, asi mismo, todos los componentes de Flash MX 2004 estan programados usando clases intensivamente, asi como proyectos independientes de la web de Macromedia, como el software Breeze.

Espero sea muy util este tutorial en el proceso de aprendizaje de Actionscript 2.0; en caso de tener cualquier duda o pregunta no dudes dirigirla a nuestros foros; si encuentras algun error en el tutorial por favor avisame a webmaster@cristalab.com

¿Sabes SQL? ¿No-SQL? Aprende MySQL, PostgreSQL, MongoDB, Redis y más con el Curso Profesional de Bases de Datos que empieza el martes, en vivo.

Descargar Archivo

Publica tu comentario

El autor de este artículo ha cerrado los comentarios. Si tienes preguntas o comentarios, puedes hacerlos en el foro

Entra al foro y participa en la discusión

o puedes...

¿Estás registrado en Cristalab y quieres
publicar tu URL y avatar?

¿No estás registrado aún pero quieres hacerlo antes de publicar tu comentario?

Registrate