Apoyo en la \"Te acerca al conocimiento\" 0 Aprenda a programar Aprenda a programar

ActionScript 3.0

Arce

Francisco Javier Arce Anguiano

“Estoy seguro que Dios programa con ActionScript y no con Java, como aseguran algunos”. En este libro encontrará una introducción amena y paulatina al lenguaje, con un enfoque hacia la creación de juegos, que es donde confluyen de manera directa los profesionales. Los capítulos se encuentran estructurados con exposición de conceptos teóricos, ejercicios cortos y un ejemplo integrador, lo que le permitirá realizar sus propios desarrollos. Ventajas competitivas: En la web se encuentran todos los programas fuentes del libro ordenados por capítulo, así como referencias y ligas a los tutoriales desarrollados por el autor. Aprenda: Las características fundamentales del lenguaje ActionScript 3.0 A trabajar con los elementos del lenguaje ActionScript 3.0 A programar y desarrollar aplicaciones con ActionScript 3.0 Realice: Aplicaciones, juegos y animaciones, mediante numerosos ejemplos. Nivel: Básico - Intermedio. Francisco Javier Arce Anguiano es licenciado en Matemáticas Aplicadas y Computación (MAC) por la UNAM, instructor certificado en Flash y Dreamweaver, también certificado como diseñador y desarrollador en Flash y ActionScript. Autor de los libros ActionScript (2005), Programación en ActionScript 2.0 (2008), publicados por esta editorial. Desarrolla y publica tanto tutoriales en páginas especializadas como aplicaciones educativas multimedia en Flash. Asimismo es catedrático en universidades y centros certificados.

Apoyo en la

Computación

ISBN 978-607-707-161-7

Lenguajes y Técnicas de Programación 9 786077 0 71617

“Te acerca al conocimiento”

ActionScript 3.0 Aprenda a programar

Aprenda a programar

ActionScript 3.0 Aprenda a programar

Apoyo en la

ActionScript 3.0 Aprenda a programar

Francisco Javier Arce Anguiano

ActionScript 3.0 Aprenda a programar

Francisco Javier Arce Anguiano

Buenos Aires • Bogotá • México, D.F. • Santiago de Chile

Edición: Alejandro Herrera Corrección: Roberto Alfaro M. Revisión: David Moisés Terán Pérez Gerente editorial: Marcelo Grillo

Datos catalográficos Arce, Francisco Javier ActionScript 3.0. Aprenda a programar Primera Edición Alfaomega Grupo Editor, S.A. de C.V., México ISBN: 978-607-707-161-7 Formato: 17 x 23 cm

Páginas: 312

ActionScript 3.0. Aprenda a programar Francisco Javier Arce Anguiano Derechos reservados © 2011, por Alfaomega Grupo Editor, S.A. de C.V. México. Primera edición: Alfaomega Grupo Editor, México, febrero 2011 © 2011 Alfaomega Grupo Editor, S.A. de C.V. Pitágoras 1139, Col. Del Valle, 03100, México D.F. Miembro de la Cámara Nacional de la Industria Editorial Mexicana Registro No. 2317 Pág. Web: http://www.alfaomega.com.mx E-mail: [email protected] ISBN: 978-607-707-161-7 Derechos reservados: Esta obra es propiedad intelectual de su autor y los derechos de publicación en lengua española han sido legalmente transferidos al editor. Prohibida su reproducción parcial o total por cualquier medio sin permiso por escrito del propietario de los derechos del copyright. Nota importante: La información contenida en esta obra tiene un fin exclusivamente didáctico y, por lo tanto, no está previsto su aprovechamiento a nivel profesional o industrial. Las indicaciones técnicas y programas incluidos, han sido elaborados con gran cuidado por el autor y reproducidos bajo estrictas normas de control. ALFAOMEGA GRUPO EDITOR, S.A. de C.V. no será jurídicamente responsable por: errores u omisiones; daños y perjuicios que se pudieran atribuir al uso de la información comprendida en este libro, ni por la utilización indebida que pudiera dársele. Los nombres comerciales que aparecen en este libro son marcas registradas de sus propietarios y se mencionan únicamente con fines didácticos, por lo que Alfaomega Grupo Editor, S.A. de C.V., México no asume ninguna responsabilidad por el uso que se de a esta información, ya que no infringe ningún derecho de registro de marca. Los datos de los ejemplos y pantallas son ficticios, a no ser que se especifique lo contrario. Impreso en México. Printed in Mexico. Empresas del grupo: México: Alfaomega Grupo Editor, S.A. de C.V. – Pitágoras 1139, Col. Del Valle, México, D.F. – C.P. 03100. Tel.: (52-55) 5575-5022 – Fax: (52-55) 5575-2420 / 2490. Sin costo: 01-800-020-4396 E-mail: [email protected] Colombia: Alfaomega Colombiana S.A. – Carrera 15 No. 64 A 29, Bogotá, Colombia, Tel.: (57-1) 2100122 – Fax: (57-1) 6068648 – E-mail: [email protected] Chile: Alfaomega Grupo Editor, S.A. – Dr. La Sierra 1437, Providencia, Santiago, Chile Tel.: (56-2) 235-4248 – Fax: (56-2) 235-5786 – E-mail: [email protected] Argentina: Alfaomega Grupo Editor Argentino, S.A. – Paraguay 1307 P.B. Of. 11, C.P. 1057, Buenos Aires, Argentina, – Tel./Fax: (54-11) 4811-8352, 4811 7183 y 4811 0887 – E-mail: [email protected]

Dedicatoria

Quiero dedicar este libro: A mi esposa y a mis hijos que son el soporte de mi vida. A mi padre. A mi madre, que se nos adelantó con el Creador (estoy seguro que Dios programa con ActionScript y no con Java, como aseguran algunos). A todos mis exalumnos, de los cuales he aprendido mucho, y espero que ellos también hayan aprendido algo.

Francisco Javier Arce Anguiano

Agradecimientos A todo el personal de Alfaomega por su apoyo y profesionalismo prestado para que este libro sea, nuevamente, realidad. A mis exalumnos que los he visto sufrir con el lenguaje y me han enseñado mucho y aumentado mi entusiasmo por aprender más. A Alejandro Herrera y Roberto Alfaro, quienes con su trabajo y esfuerzo impulsaron la publicación de ActionScript 3.0, Aprenda a programar. Gracias. Francisco Javier Arce Anguiano

Mensaje del editor Los conocimientos son esenciales en el desempeño profesional, sin ellos es imposible lograr las habilidades para competir laboralmente. La universidad o las instituciones de formación para el trabajo ofrecen la oportunidad de adquirir conocimientos que serán aprovechados más adelante en beneficio propio y de la sociedad; el avance de la ciencia y de la técnica hace necesario actualizar continuamente esos conocimientos. Cuando se toma la decisión de embarcarse en una vida profesional, se adquiere un compromiso de por vida: mantenerse al día en los conocimientos del área u oficio que se ha decidido desempeñar. Alfaomega tiene por misión ofrecerles a estudiantes y profesionales conocimientos actualizados dentro de lineamientos pedagógicos que faciliten su utilización y permitan desarrollar las competencias requeridas por una profesión determinada. Alfaomega espera ser su compañera profesional en este viaje de por vida por el mundo del conocimiento. Alfaomega hace uso de los medios impresos tradicionales en combinación con las tecnologías de la información y las comunicaciones (IT) para facilitar el aprendizaje. Libros como éste tienen su complemento en una página Web, en donde el alumno y su profesor encontrarán materiales adicionales. Esta obra contiene numerosos gráficos, cuadros y otros recursos para despertar el interés del estudiante, y facilitarle la comprensión y apropiación del conocimiento. Cada capítulo se desarrolla con argumentos presentados en forma sencilla y estructurada claramente hacia los objetivos y metas propuestas. Los libros de Alfaomega están diseñados para ser utilizados dentro de los procesos de enseñanza-aprendizaje, y pueden ser usados como textos para diversos cursos o como apoyo para reforzar el desarrollo profesional. Alfaomega espera contribuir así a la formación y el desarrollo de profesionales exitosos para beneficio de la sociedad.

El autor Francisco Javier Arce Anguiano Estudió Matemáticas Aplicadas y Computación en la UNAM. En 1998 conoció Flash, cuando quería hacer animaciones sencillas para páginas de Internet y ésa fue su perdición. En 1999 y 2000 realizó juegos en Flash utilizando ActionScript (la primera versión). Publicó tutoriales en páginas especializadas. Desde 2003 se dedicó exclusivamente a Flash y ActionScript. Obtuvo la certificación como diseñador y desarrollador en 2004. Publicó su primer libro de ActionScript con esta editorial en 2005. En 2006 obtuvo la certificación como Instructor Certificado en Flash y Dreamweaver Publicó el libro de programación en ActionScript 2.0 en 2008. Actualmente trabaja de tiempo completo desarrollando aplicaciones educativas multimedia en Flash y enseñando ActionScript en universidades y centros certificados.

ActionScript 3.0, 3.0, Aprenda a programar Este libro está dirigido tanto a personas que tienen conocimientos de las versiones anteriores de ActionScript como a aquellas personas que no tienen conocimientos previos sobre el lenguaje. Se ha procurado que este libro sea de utilidad tanto a las personas de desarrollo como a los diseñadores interesados en aprender este maravilloso lenguaje. Los capítulos se encuentran estructurados con exposición de conceptos teóricos, luego ejercicios cortos en relación con lo anterior y por último un ejemplo integrador de todo el capítulo. Este libro no es una referencia del lenguaje ni un manual para migrar aplicaciones de las versiones anteriores a ActionScript 3.0. Intentamos que sea un libro que introduzca poco a poco al lector, en forma amable y amena, desde la comprensión de las variables y sentencias condicionales, a temas más ambiciosos como el XML y animación con código. No importa si usted es un artista gráfico o un programador compulsivo, esperemos que este libro sea una excelente introducción al planeta ActionScript. Bienvenido.

Acceso al material material complementario Para tener acceso al material complementario del libro ActionScript 3.0, Aprenda a programar, es necesario: 1. Ir a la página: http://virtual.alfaomega.com.mx/ 2. Registrarse como usuario y guarde en un lugar seguro su nombre de usuario y clave de acceso para emplearla para futuros ingresos. 3. Ingrese con su usuario a la sección de libros. 4. Busque y seleccione la imagen correspondiente a este libro para descargar su material complementario como: • • •

Ejemplos. Los archivos necesarios para realizar sus ejemplos y prácticas. Ligas a Videotutoriales con numerosos ejemplos prácticos desarrollados paso a paso.

Es necesario que el usuario cuente instalado en su computadora el software: ActionScript 3.0. La descarga de software desde el sitio de Autodesk® no genera ninguna responsabilidad para el autor o la editorial. NOTAS 1. Se recomienda respaldar los archivos descargados de las páginas web en un soporte físico (CD, USB, disco duro o cualquier otro medio de almacenamiento). 2. En adelante se referirá al material complementario como el material que se descargó del sitio web.

Contenido

Capítulo 1 ActionScript 3.0. Evolucionar o morir................................ Nueva AVM y nuevo Render....................... Programación orientada a objetos: cuestión de gatos ....................................... Las clases: gatos.................................. Cuestión de sintaxis............................. ¿Dónde iniciar? .................................... El cascarón........................................... Nota ...................................................... Los elementos de la clase ................... La función constructora....................... Llamar a la clase.................................. Class Path............................................. Sentencia import.................................. Propiedades y métodos ....................... Herencia ............................................... Override ................................................ Ejemplo práctico ........................................... Una subclase de MovieClip/Sprite............. Clase de documento o document class .... A manera de conclusión ..............................

1 1 2 2 4 5 6 7 8 9 10 11 13 13 15 16 17 19 20 22

Capítulo 2 Algo más sobre programación orientada a objetos ............................... 23 Introducción ................................................ Paquetes (packages) ........................... Importar paquetes ............................... Nombres de espacios o namespaces . Modo estricto y modo estándar de compilación .......................................... Variables .....................................................

Alfaomega

23 23 24 24 25 27

Ejercicio................................................ Ámbito o alcance de las variables ...... Ejercicio................................................ Variables por su alcance ..................... Parámetros de la función constructora Ejercicio................................................ Tipo de datos ....................................... Ejercicio................................................ Saber los tipos de variable: operadores is y as................................ Ejemplo ................................................ Conversión de tipos ............................. Constantes........................................... Ejercicio................................................ Operadores ................................................. Operadores principales ....................... Operadores de sufijo ........................... Operadores de prefijo.......................... Operadores unarios ............................. Operadores de multiplicación ............. Operadores aditivos............................. Operadores relacionales ..................... Operadores de igualdad ...................... Operadores lógicos.............................. Operador condicional .......................... Operadores de asignación .................. Ejemplo ................................................ A manera de conclusión......................

28 29 30 32 33 34 35 37 38 38 40 40 40 42 43 43 44 44 44 45 45 46 46 46 47 47 52

Capítulo 3 Sentencias condicionales y ciclos.... 53 Sentencias condicionales .......................... Sentencia if .......................................... Sentencia if... else if ............................ Sentencia switch() ...............................

53 53 54 55

ActionScript 3.0 – Francisco Arce

XII

Ejercicio ................................................ Bucles o ciclos ............................................ Sentencia for........................................ Sentencia for..in................................... Sentencia for each..in.......................... Ejercicio ................................................ Nota ...................................................... Sentencia while.................................... Sentencia do..while.............................. Funciones.................................................... Funciones globales .............................. Métodos................................................ Funciones personalizadas ................... Llamado o invocación de una función Funciones de usuario........................... Función tipo sentencia......................... Funciones tipo expresiones................. Nota ...................................................... Funciones que regresan valores ......... Funciones anidadas............................. Ejercicio ................................................ Pasar parámetros por valor o por referencia....................................... Ejercicio ................................................ Valores predeterminados en las funciones.............................................. El objeto arguments............................. Ejercicio ................................................ El parámetro …(rest) ............................ Ejercicio ................................................ Nota ...................................................... Ejemplo práctico: uso de condicionales.... Ejemplo práctico: uso de los ciclos............ A manera de conclusión ......................

Contenido

56 58 58 58 59 58 61 62 62 63 63 63 63 64 64 64 65 65 65 66 66 67 67 70 70 70 71 71 72 72 74 77

Capítulo 4 La lista de visualización ....................... 79 Introducción ................................................ Nota ...................................................... Añadir un elemento a la lista de visualización .................................................. Ejercicio ................................................ Ejercicio ................................................ Lista de visualización dentro de un contenedor .................................................. Nota ...................................................... Ejercicio ................................................ Nota ...................................................... Cómo reparentar (reparent) objetos en la lista de visualización .........................

ActionScript 3.0 – Francisco Arce

79 82 82 83 85 86 87 88 90 90

Ejercicio................................................ 91 Eliminar un objeto de la lista de visualización ............................................... 92 Ejercicio................................................ 92 Cómo borrar un elemento sin la referencia.................................................... 94 Ejercicio................................................ 94 Nota...................................................... 96 Cómo eliminar a todos los hijos de un contenedor ................................................... 96 Ejercicio................................................ 97 Cómo mover a los hijos de profundidad: setChildIndex() ............................................. 98 Ejemplo ................................................ 99 Ejemplo ................................................ 101 Ejemplo ................................................ 104 Cómo manipular un objeto que ya existe en el escenario ............................................. 106 Ejemplo ................................................ 106 Cómo llamar a un objeto gráfico de la librería ......................................... 107 Nota...................................................... 108 Ejemplo ................................................ 108 Nota...................................................... 109 Cómo escribir código dentro del objeto ......... 110 A manera de conclusión...................... 112

Capítulo 5 Manejo de eventos ................................ 113 Manejo de eventos..................................... 113 ¿Qué son los eventos? ........................ 113 Nota...................................................... 114 Elementos del manejo de eventos...... 114 Ejemplo con gatos ............................... 115 Determinar el evento y su identificador ......................................... 116 Nota...................................................... 116 Determinar el tipo de objeto del evento (Event object)..................... 117 Nota...................................................... 117 Crea un listener para el evento........... 118 Nota...................................................... 119 Suscribir el objeto destino (target object) al listener .................... 119 Nota...................................................... 119 Esperar a que las cosas sucedan ....... 119 Crear interacciones del mouse ........... 120 Ejercicio................................................ 121 Nota...................................................... 122 Ejercicio................................................ 124

Alfaomega

Contenido

Ejercicio ................................................ 125 Arrastrar y soltar objetos con el apuntador del mouse........................... 127 Ejercicio ................................................ 128 Gestionar el evento enterFrame.......... 134 Notas .................................................... 135 Ejercicio ................................................ 136 Responder a eventos del mouse......... 137 Ejercicio ................................................ 138 Responder a eventos del teclado........ 140 Ejercicio ................................................ 141 Juego de memoria...................................... 142 Estados de las cartas........................... 146 Codificar la función del listener........... 146 A manera de conclusión ...................... 148

Capítulo 6 Crear clases visuales personalizadas ........................................149 Introducción ................................................ 149 Ejercicio ................................................ 150 Nota ...................................................... 151 Ejercicio ................................................ 151 Nota ...................................................... 152 Crear botones sencillos .............................. 153 Nota ...................................................... 153 Ejemplo.................................................153 Nota ...................................................... 156 Cargar imágenes externas en tiempo de ejecución, la clase Loader........ 156 Ejemplo.................................................157 Ejemplo: escuchar a diferentes eventos del progreso de descarga de una imagen ..................................... 159 Nota ...................................................... 160 Ejemplo: progreso de descarga de una imagen en campo texto...........161 Nota ......................................................162 Cargar e interactuar con películas externas.......................................................... 163 Ejemplo.................................................163 Ejemplo.................................................165 Nota ......................................................167 ¿Y los mapas de bits?..........................168 La clase flash.geom.Rectangle............170 La clase flash.geom.Point....................170 Nota ......................................................170 Creación de un rompecabezas ................... 170 Ejemplo: rompecabezas tipo caja de números ..................................175 Modificar el algoritmo de cortado

Alfaomega

XIII

para crear un arreglo y no generar el último cuadro....................................... 175 Generar el algoritmo para “barajar” los cuadros de la figura ....................... 180 ¿Cómo sabemos si un movimiento es válido? ............................................. 182 Mover las piezas .................................. 186 A manera de conclusión...................... 188

Capítulo 7 Texto .......................................................... 189 Introducción................................................ 189 Formato de un texto................................... 190 Formateo con la clase TextField ......... 191 Ejercicio................................................ 192 Formato con TextFormat Class ........... 194 Nota...................................................... 195 Ejemplo ................................................ 196 Formato con HTML....................................... 199 Ejercicio................................................ 199 Formato con CSS.......................................... 201 Nota...................................................... 203 Ejercicio: formato con CSS internos.... 203 Ejercicio: formato con CSS externos... 205 Textos de entrada......................................... 207 Ejercicio................................................ 208 Eventos de las cajas de texto.............. 209 Ejercicio................................................ 209 A manera de conclusión...................... 212

Capítulo 8 Texto .......................................................... 213 Introducción................................................ 213 Las bases ............................................. 214 Crear objetos XML con AS ......................... 217 Nota...................................................... 219 Añadir nodos XML con AS.................... 220 Añadir atributos XML con AS............... 224 Borrar y modificar nodos y atributos... 228 Lectura de un archivo XML.................. 230 Ejemplo: desarrollo de un juego de trivia ................................................ 233 A manera de conclusión...................... 238

Capítulo 9 Texto .......................................................... 239 Introducción................................................ 239 Método lineStyle()................................ 239 Nota...................................................... 240 Método moveTo()................................. 240 Método lineTo().................................... 240

ActionScript 3.0 – Francisco Arce

XIV

Ejercicio: dibujar dos triángulos................. 241 Métodos beginFill() y endFill().............. 242 Ejemplo: contornear y rellenar dos triángulos....................................... 243 Métodos beginGradientFill() y endFill()................................................ 244 Ejercicio: cuadro con colores desvanecidos .............................................. 245 Método drawRect................................. 247 Ejercicio: definir línea de contorno y tipo de relleno........................................................... 247 Método curveTo() ................................. 249 Ejercicio: dibujar una curva a partir de tres puntos .................................................... 249 Ejercicio: círculo a partir de cuatro curvas . 251 Ejercicio: círculo realizado con ocho segmentos.................................................... 252 Ejercicio ................................................ 254 Nota ......................................................255 Método drawCircle()............................. 256 Ejercicio: círculo con el método drawCircle()..... 256 Método lineGradientStyle().................. 257 Ejercicio: cuadro con degradados.................... 258 Método drawElipse() ............................ 259 Ejercicio: dibujar una elipse............................. 259 Método beginBitmapFill() .................... 260 Ejercicio ................................................ 260 Movimiento de shapes con dibujos..... 261 Ejercicio: dibujo de una función senoidal.......... 261 Método clear()......................................263 Ejercicio ................................................263 Ejemplo: trazo de una gráfica de líneas ...........265 A manera de conclusión ............................268

Contenido

Aceleración ................................................. 279 Ejemplo ................................................ 279 Otros movimientos..................................... 281 Ejemplo: movimiento en forma circular ................................................. 281 Ejemplo: movimiento en forma senoidal................................................ 282 Ejemplo: movimiento oval ................... 283 Ejemplo: movimiento aleatorio ........... 284 Ejemplo: movimiento al compás del cursor ............................................. 286 Juego con un tanque que utiliza movimientos angulados.............................. 287 El motor del tanque ............................. 290 La función teclaAbajo .......................... 290 La función teclaArriba.......................... 291 Mover el tanque................................... 291 Avanzar el tanque ................................ 292 Ejemplo: tanque estático..................... 292 Moverse a una posición ...................... 293 El arco tangente................................... 293 A manera de conclusión ............................ 295

Capítulo 10 Animación con ActionScript ...............269 Introducción ................................................ 269 Ejercicio ................................................269 Ejercicio ................................................271 Mover un objeto a una coordenada específica ................................................... 272 Ejercicio ................................................273 Mover un objeto a una dirección determinada ..............................................274 Ejemplo.................................................275 Mover un objeto en forma circular ............276 Ejemplo.................................................276 Easing..........................................................277 Ejemplo.................................................278

ActionScript 3.0 – Francisco Arce

Alfaomega

Introducción ActionScript ha evolucionado de una forma asombrosa. De ser un conjunto de instrucciones sencillas, pero que fueron una maravilla en su momento (¿recuerda los comandos fscommand?) hasta nuestros días que contamos con una plataforma Flash, la cual está basada en ActionScript 3.0. Parte del reto al que se ha enfrentado Flash es el de servir a dos amos: por un lado a los artistas de diseño, que nos han sorprendido con su ingenio, y por el otro a los desarrolladores, que desde un principio veían a Flash como un mero entretenimiento y a ActionScript como un lenguaje “menor” (y en muchos casos ni lo consideraban un lenguaje, sólo un script). Creo que no cabe duda de que Flash no es el mejor paquete para edición de video, ni para la edición de mapas de bits, ni para el dibujo vectorial, pero considero que es el mejor integrador de medios y que posee un excelente lenguaje para la programación multimedia: ActionScript. Esto plantea nuevos dilemas: ¿puede existir un diseñador multimedia que no sepa de programación? Según Adobe, los diseñadores que se dediquen a la multimedia deberán poseer conocimientos de programación. ¿Ha visto solicitudes de trabajo donde piden diseñadores con conocimientos de JavaScript, PHP, MySQL y ActionScript? Así que si usted es diseñador y quiere aprender ActionScript, va por buen camino. Una característica que he visto en mi actividad docente es que ActionScript da miedo…, y ActionScript 3.0 da pavor. Nada más erróneo. Todo el tiempo que invierta en aprender esta tecnología le será de enorme utilidad en su vida profesional. Es cierto que Macromedia y ahora Adobe tomaron decisiones arriesgadas hasta convertir a Flash en una plataforma de desarrollo, video y multimedia. Muchos, cuando salió la primera versión de ActionScript, en Flash 5, decían que era “ilógico” un programa formal para un paquete de animación. El tiempo demostró que se equivocaban. Luego se agregaron componentes (Flash MX y Flash MX 2004) y nuevas voces dijeron que era “ilógico” agregarle a Flash herramientas de desarrollo: Flash era para animadores. Ahora, con este nuevo cambio, ActionScript 3.0, hemos escuchado voces que dicen que es “ilógico” un lenguaje con clases, polimorfismo, herencias y encapsulación. Desde mi punto de vista, nuevamente el tiempo le dará la razón a Flash. Por eso el primer capítulo de este libro se llama evolucionar o morir, y de esas voces que auguran el fin de Flash, seguramente les ocurrirá lo mismo que a los dinosaurios. Aprender ActionScript 3.0 no sólo le será de utilidad para hacer aplicaciones multimedia, sino también utilizar Flex, Air y desarrollo en plataformas móviles con Flash Lite 4.0. El cambio implica una nueva forma de pensar. Es un reto que valdrá la pena realizar. Este libro intenta que ese salto evolutivo sea lo más sencillo (e indoloro) posible. Como dice un refrán oriental: Para poder aprender, es necesario primero Alfaomega

ActionScript 3.0 – Francisco Arce

“desaprender.” Está evolución se debe en parte a que la comunidad de desarrollo en ActionScript ha madurado. Los desarrollos multimedia han evolucionado de “intros” en Internet a sistemas sofisticados, juegos y verdaderas experiencias para el usuario, no sólo en computadoras, sino también en teléfonos celulares y tabletas. Desarrollo en sistemas operativos como Android o Symbian 3 abrirán nuevas oportunidades y nuevos retos. Una de las cosas que me gusta de las introducciones a los libros de Flash y ActionScript es el entusiasmo. Espero haber colaborado con mi granito de arena para que usted, amable lector, aumente su entusiasmo por esta tecnología y que le ayude a perder el miedo a la programación orientada a objetos: así como los pokemones necesitan evolucionar para continuar luchando, nosotros necesitamos aprender para lo mismo, luchar en la arena, cada vez más competida, de la multimedia.

Francisco Javier Arce Anguiano

ActionScript 3.0 – Francisco Arce

Alfaomega

ActionScript 3.0. Evolucionar o morir

1

Nueva AVM y nuevo Render Los cambios en ActionScript son importantes. En general, puede decirse que el reproductor de Flash, el Flash Player, consta de un motor que interpreta al ActionScript (ActionScript Virtual Machine o AVM) y de otro que lo hace con los objetos en la pantalla (Render). Ambos elementos han cambiado, y si a esto se le añade el hecho de que hay un nuevo modelo de eventos. Debido a que la forma de desarrollar (y de pensar) en Flash cambia constantemente, es un problema “enseñar” este tipo de lenguaje. En este libro se ha decidido iniciar con la explicación de la nueva estructura del lenguaje (programación orientada a objetos) para posteriormente abordar la nueva manera de reinterpretar los objetos. Antes de iniciar con el tema se hará un breve repaso de la historia de ActionScript. ActionScript 0: La patineta. Aparece con Flash 4. Era un conjunto relativamente reducido de comandos que se manejaban con listas y parámetros. Resultó una maravilla en sus tiempos. Los usuarios “empujaron” al límite estos comandos. ActionScript 1: Un auto compacto. Apareció en Flash 5. Compatible con el estándar ECMA 264. En comparación con el lenguaje anterior, se veía como un enorme avance (lo fue). Los usuarios “empujaron” al límite este lenguaje.

Alfaomega

ActionScript 3.0 – Francisco Arce

Programación orientada a objetos: cuestión de gatos

2

ActionScript ActionScript 2: Un auto deportivo. En esta versión ya se contaba con herramientas más sólidas de programación orientadas a objetos, además de que el lenguaje mismo fue reescrito para hacerlo más rápido y potente. Nuevamente los usuarios “empujaron” al límite este lenguaje. ActionScript 3: Un potente tráiler. Adobe entrega ahora un lenguaje completamente orientado a objetos, listo para soportar toda especie de carga, hacer largos recorridos y, bajo ciertos casos, mucho más rápido que el anterior. La pregunta es: ¿cuánto tiempo tardarán los usuarios en llevar al límite este lenguaje? ActionScript más allá de Flash. Si bien es cierto que ActionScript inició en el lejano Flash 4, ahora existen varios paquetes donde se puede programar con este lenguaje: Flex, Flash Lite y Air. ActionScript ha salido de su caja para convertirse en un estándar de desarrollo.

Programación orientada a objetos: cuestión de gatos La programación orientada a objetos (OOP: Oriented Objects Programming) no es nueva, de hecho es muy vieja, pues data de 1964 y no pasó de ser un experimento de laboratorio. Posteriormente sus autores, Ole Johan Dahl y Kristen Nygaard (noruegos), lanzaron SIMULA67. Si se recuerda, los lenguajes que se utilizaban en las computadoras de pantallas verdes eran “procedurales”, es decir, estaban basados en procedimientos. A partir del surgimiento de las interfaces gráficas para usuarios (GUI), la necesidad de lenguajes orientados a objetos, no ha procedimientos, fue cada vez mayor. Finalmente el destino nos alcanzó. Ahora la programación en Flash tiene que orientarse a objetos. Así que, como dijo Pikachú, “evolucionar o morir”. Para que no sea tan duro el tránsito a este lenguaje, se iniciará con una analogía: los gatos.

Las clases: gatos Un concepto que todos conocemos es la existencia del reino animal. A los animales se les agrupa en especies y subespecies. Tómese por ejemplo a los gatos comunes, a quienes se les pondrá la etiqueta “Clase”. Ahora se tiene una clase que se llama Gatos, otra Perros, Hámsteres, etc. Los gatos tienen características diferentes a las demás clases, por eso se sabe que un animal pertenece a cierto género (o clase). También tienen acciones que los demás animales no pueden hacer, como maullar o ActionScript 3.0 – Francisco Arce

Alfaomega

1. ActionScript 3.0. Evolucionar o morir

3

ronronear. Asimismo, hay cosas a que los gatos reaccionan y en cambio los otros animales no. Una clase no es otra cosa que un concepto abstracto, con características únicas, que indica que un individuo pertenece a cierta “clase” de animales. Ahora piénsese en un animal en concreto: Gatito. Él es bajito, su pelo es color blanco, es regordete, tiene una voz un poco chillona y le gusta mucho dormir.

Otro espécimen del grupo de los gatos es Chucho: él es más alto que Gatito, tiene el pelo gris y es muy ocurrente.

Así se podría seguir describiendo a cada elemento del grupo gatos, ahora piense en la pandilla de Don Gato. El punto importante es que cada minino tiene sus características únicas que los hace diferentes. En OOP se les llama a las

Alfaomega

ActionScript 3.0 – Francisco Arce

Programación orientada a objetos: cuestión de gatos

4

características de cada individuo propiedades; a las acciones (que son verbos) se les conoce como métodos. Además, a las maneras de reaccionar ante un problema se les denomina eventos, mientras que a los individuos se les identifica como instancias. Poniendo lo anterior en ActionScript, se escriben así: var gatito:Gato = new Gato(); gatito.pelo = “blanco”; gatito.voz = “Chillona”; gatito.maullar() En resumen, una clase es una representación abstracta que contiene propiedades, métodos y manejadores de eventos (alguno de estos tres) para crear objetos o instancias, los cuales heredan las propiedades, métodos y manejadores de eventos de la clase. Obviamente el tema de la programación orientada a objetos (y a los gatos) es mucho más complejo que lo que aquí se describió. Se trata solamente de una analogía de trabajo con la cual se pretende ejemplificar términos abstractos. Antes de empezar a realizar obras de arte en Flash y en ActionScript, se deberá conocer una serie importante de conceptos. Es necesario pedir al lector que no se desespere, ya que todo el conocimiento que adquiera valdrá la pena.

Cuestión de sintaxis Antes de abordar algunos aspectos de la programación orientada a objetos, deben revisarse algunos puntos relacionados con la sintaxis del lenguaje: 1. AS3.0 distingue entre mayúsculas y minúsculas. 2. El operador punto (.) permite acceder a las propiedades y métodos de los objetos. 3. En AS3.0 ya no se acepta la sintaxis de diagonales. 4. Una literal es un valor que aparece en el código, por ejemplo 3.0, “Hola”, true. 5. El punto y coma (;) indica que se termina una sentencia. 6. Los comentarios de línea (doble diagonal) y de bloque (/*...*/) se mantienen. 7. Las palabras reservadas en AS3.0 son:

ActionScript 3.0 – Francisco Arce

Alfaomega

1. ActionScript 3.0. Evolucionar o morir

5

as

break

case

catch

class

const

continue

default

delete

do

else

extends

false

finally

for

function

if

implements

import

in

instanceof

interface

internal

is

native

new

null

package

private

protected

public

return

super

switch

this

throw

to

true

try

typeof

use

var

void

while

with

TIP DE CERTIFICACIÓN Pregunta: ¿Case-Sensitive es una característica de AS3.0? Respuesta: ActionScript 3.0 es Case-Sensitive, es decir, distingue entre mayúsculas y minúsculas.

¿Dónde iniciar? Primero, las clases se escriben en archivos de texto externos. Para ello se puede utilizar la herramienta de Flash, un procesador tipo Dreamweaver, Flex o un procesador de texto que no deje caracteres especiales, por lo que aquí se asume que el usuario lo hará por medio del IDE de Flash. Así que siguiendo la tradición de Kernighan & Ritchie (The C Programming Language, 1974), se realiza el tradicional “Hello World”. TIP DE CERTIFICACIÓN Pregunta: ¿En AS3.0 se permite capturar código en los clips de película o Movie Clips? Respuesta: En esta versión ya no se puede.

Alfaomega

ActionScript 3.0 – Francisco Arce

6

Programación orientada a objetos: cuestión de gatos

El cascarón La programación orientada a objetos de ActionScript tendrá en la versión 3 un nuevo cascarón que agrupará las clases: la sentencia package o un paquete. En AS2 los paquetes eran carpetas donde se guardaban las clases, es decir, espacios físicos en nuestro disco duro. En AS3 los paquetes (package) serán entidades lógicas que agrupan diferentes clases. Su sintaxis básica es: package { … aquí van las diferentes clases }

Este bloque de código será conocido como paquete por omisión (default package). Se puede decir que un paquete servirá para organizar y agrupar clases. Los paquetes permitirán compartir código y evitar los conflictos en las nomenclaturas de clases, métodos y propiedades. El manejo de los paquetes puede ser más complejo. En este momento sólo se le considerará como una agrupación de clases. TIP DE CERTIFICACIÓN Pregunta: ¿Cuál es el contenedor que nos sirve para almacenar las clases? Respuesta: Un paquete (package). Un paquete está relacionado con un namespace (algunos textos lo traducen como “espacios de nombres”, pero aquí se seguirá conservando el término en inglés), concepto que se explicará más adelante. Así que se abre Flash y se selecciona un archivo nuevo, tipo AS3.0, al cual se le nombra jelou.fla. En este archivo se le llama la clase Jelou para el saludo. Ahora se abre un archivo nuevo tipo AS con FileFile->New>New->ActionScript File, File al cual se le graba con el nombre Jelou.as. Jelou.as En el panel de acciones se escribe la definición del paquete: package { }

ActionScript 3.0 – Francisco Arce

Alfaomega

1. ActionScript 3.0. Evolucionar o morir

7

Nota En CS5 se tienen nuevas opciones en la ventana Nuevos documentos: Crear una clase y Crear una interface, como se ve en la Fig. 1.1.

Figura 1.1 Nuevas opciones en Flash Professional CS5. Un archivo de tipo ActionScript 3.0 Class escribirá por nosotros la estructura de la clase, como se observa en la Fig. 1.2.

Figura 1.2 Archivo de clase en Flash Professional CS5. En otras versiones, bastará con escribir el código. De momento, ambos archivos, tanto el .fla como el .as, deberán residir en la misma carpeta. Nótese que no se le ha puesto nombre al paquete. A continuación se elabora la clase.

Alfaomega

ActionScript 3.0 – Francisco Arce

8

Programación orientada a objetos: cuestión de gatos

Los elementos de la clase Dentro del cascarón del paquete se escribe la estructura de la clase de la siguiente manera: package { public class Jelou { } Se observará que al inicio se tiene reservada la palabra “public”. A estas palabras claves se les conoce como modificadores de acceso o access modifiers. Los modificadores son palabras para determinar si el código que se escribe puede ser accesado (utilizado) por otro código, o si no se tendrá el acceso. En este caso, public permitirá el acceso de cualquier código externo a la clase, es decir, cualquier código podrá utilizar sus métodos, eventos y propiedades. Este modificador de acceso, al igual que private, se utilizaron en AS2.0. En la nueva versión se tienen dos modificadores más. La Tabla 1.1 describe los cuatro modificadores de acceso: Tabla 1.1 Modificadores de acceso. MODIFICADOR DE ACCESO public

Se puede acceder a este código desde cualquier otro.

private

Sólo se puede acceder al código dentro de la clase.

internal

El atributo internal es similar al control de acceso predeterminado en Java, aunque en Java no hay ningún nombre explícito para este nivel de acceso y sólo se puede alcanzar mediante la omisión de cualquier otro modificador de acceso. El atributo internal está disponible en ActionScript 3.0 para ofrecer la opción de indicar, de manera explícita, la intención de hacer que una propiedad sólo sea visible para orígenes de llamada de su propio paquete. Hace que una propiedad esté visible para los orígenes de llamada en su propia clase o en una subclase. Es decir, una propiedad protegida está disponible en su propia clase o para clases de nivel inferior en la jerarquía de herencia. Esto se cumple tanto si la subclase está en el mismo paquete como si está en un paquete diferente.

protected

DESCRIPCIÓN

Pero no hay motivos para angustiarse, pues de momento sólo se utilizará el modificador de acceso “public”, mientras que los demás modificadores se explicarán más adelante.

ActionScript 3.0 – Francisco Arce

Alfaomega

1. ActionScript 3.0. Evolucionar o morir

9

La segunda parte de la sentencia es class, class la cual indica al compilador que se está escribiendo una clase. Por último se escribe el nombre de la clase. Obsérvese que la palabra inicia con mayúscula, lo cual es obligatorio para definir clases, pues de lo contrario el compilador no encontrará la definición de la clase y marcará un error. Nótese también que la definición de la clase no termina con paréntesis, como en el caso de las funciones. Si se compila en este momento el documento, Flash no debe marcar ningún error, pero tampoco efectuar algo. Para ello se necesita un poco más de código.

La función constructora Si se tiene experiencia en el uso de AS2.0, se estará familiarizado con el uso de los constructores. Por ejemplo: var nombres_array:Array = new Array(); var libro:Object = new Object(); Después de la palabra reservada new se utiliza el nombre de la clase seguida de los paréntesis. Ésta es la función constructora. Las funciones constructoras deben tener exactamente el mismo nombre que la clase (incluyendo la primera letra en mayúsculas). También es necesario escribir su modificador de acceso, en este caso public. package { public class Jelou { public function Jelou(){ } } En AS3.0 las funciones constructoras (o constructores) por omisión son públicas y no pueden tener otro modificador de acceso. Sin embargo, no está por demás ser explícito y escribirla con el modificador public. En este punto se ha realizado una función que servirá para que nuestros usuarios creen un objeto de nuestra clase. En caso de que se omita escribir la clase constructora, el compilador creará una función vacía (parecida a la que se acaba de hacer).

Alfaomega

ActionScript 3.0 – Francisco Arce

10

Programación orientada a objetos: cuestión de gatos

La función constructora puede recibir parámetros o disparar ciertas acciones. Estos parámetros se disparan en el momento en que se elaboran los objetos. De momento sólo se escribirá la siguiente sentencia:

package { public class Jelou { public function Jelou(){ trace(“Constructora de Jelou”); } } } Obsérvese que en este caso, el nombre de la función sí lleva los paréntesis. La clase está lista para utilizarse, aunque en realidad hace muy poca cosa.

Llamar a la clase Si se compila el documento, Flash no deberá mandar ningún mensaje de error, pero no hace absolutamente nada. Para ello se debe crear un objeto de la clase Jelou. Cámbiese al panel de acciones de la película jelou.fla, primer fotograma clave. En él escríbase el siguiente código: var saludo:Jelou = new Jelou(); Publíquese el documento. En la ventana de salida que se muestra en la Fig. 1.3 debe aparecer:

Figura 1.3 Ventana de salida. Si no se importó la clase, y tampoco es una clase interna, ¿cómo funcionó?

ActionScript 3.0 – Francisco Arce

Alfaomega

1. ActionScript 3.0. Evolucionar o morir

11

Class Path El ejemplo anterior funcionó porque en la ventana de diálogo Class Path se le había indicado a Flash que buscara las clases en el mismo directorio donde reside el documento fla. Esto puede observarse en EditEdit->Preferences>Preferences->ActionScript (PCs) o en FlashFlash->Preferences>Preferences->ActionScript (Macs). En la parte baja de la ventana de la Fig. 1.4 hay un botón para entrar al Class Path:

Figura 1.4 1.4 Ventana de diálogo Preferences. Púlsese este botón y se abrirá la ventana de diálogo correspondiente como se aprecia en la Fig. 1.5.

Alfaomega

ActionScript 3.0 – Francisco Arce

12

Programación orientada a objetos: cuestión de gatos

Figura 1.5 1.5 Ventana de diálogo ActionScript 3.0 Settings. En ella se observan dos líneas. La primera es un punto, el cual indica que el primer lugar donde el compilador buscará los archivos de las clases es el mismo directorio donde reside la película (eso significa el puntito). La segunda línea es donde Flash guarda los archivos de clase. Esta ruta está representada por $(AppConfig). El valor de la ruta variará si está en PC (c:/archivos de programa/Adobe/Adobe Flash CS3/en/Configuration) o en Mac (). A partir de este punto buscarían la carpeta ActionScript 3.0, y dentro de ésta la carpeta Classes. ¿Qué pasaría si se cambia la clase de carpeta sin avisarle a Flash? Dentro del directorio de su película, se crea una carpeta que se llame misClases. misClases Asegúrese que el archivo Jelou.as se encuentre cerrado y muévase el archivo as a esta carpeta. Se vuelve a compilar el programa y deberá aparecer en el panel de errores, mensajes similares a los que se muestran en la Fig. 1.6.

Figura 1.6 1.6 Mensajes de error. ActionScript 3.0 – Francisco Arce

Alfaomega

1. ActionScript 3.0. Evolucionar o morir

13

Para notificarle a Flash que la clase se movió (o que no se encuentra en el ClassPath) se necesita una sentencia import. import

Sentencia import Primero, como la ubicación del archivo de clases se cambió de las carpetas del ClassPath, se debe escribir en la sentencia package la ubicación, es decir, abrir el archivo Jelou.as y añadir la ubicación del archivo como se indica:

package misClases { public class Jelou { public function Jelou() { trace("Constructor Jelou"); } } }

La palabra misClases se refiere a la carpeta y será ahora el nombre de la clase. Nótese que los nombres de los paquetes, así como de los directorios, se escriben con la primera letra en minúscula. Por su parte, las clases se escriben con la primera letra en mayúscula. Ahora se necesita utilizar la sentencia import, import ya que la clase no se encuentra en el ClassPath, es decir, en el archivo fla se añade la siguiente sentencia:

import misClases.Jelou; var saludo:Jelou = new Jelou();

Se ejecuta el documento Flash. El resultado debe ser el mismo.

Propiedades y métodos Hasta el momento la clase creada no hace nada. Sólo manda un mensaje trace cuando se crea el objeto. Para que las cosas sucedan se necesitan los métodos y las propiedades. Como se mencionó anteriormente, una propiedad es una variable asociada a un objeto. Asimismo, un método es una función asociada a un objeto, es decir, dentro de la clase no son otra cosa que variables y funciones, pero cuando se Alfaomega

ActionScript 3.0 – Francisco Arce

Programación orientada a objetos: cuestión de gatos

14

llaman desde afuera, se convierten en propiedades y métodos, respectivamente. En el archivo Jelou.as se modifica el código para que quede de la siguiente forma: package misClases { public class Jelou { public var saludo:String; public function Jelou(arg1:String) { saludo=arg1; } public function hola(arg1:String){ return saludo+", "+arg1; } } }

En la tercera línea se crea una variable pública llamada saludo de tipo cadena. Obsérvese que no se le ha inicializado, sólo se le ha creado. En la función constructora se está recibiendo una cadena, la misma que se vació en la variable anterior. Por último se crea una función pública que se llama (de manera muy original) hola. hola Ésta, a su vez, recibe un argumento de tipo cadena. Lo único que hace esta función es concatenar las cadenas de saludo con el argumento, más una coma con un espacio. Dentro del IDE de Flash ahora se hacen unos pequeños cambios: import misClases.Jelou; var saludo:Jelou = new Jelou("Buenos días"); trace(saludo.hola("Paco"));

La primera línea es el import para la clase. No hay cambio. En la segunda línea se crea el objeto, pero se le está pasando un argumento que se guarda en el parámetro saludo. saludo En la línea tres se le llama al método saludo(), saludo con el parámetro “Paco”, con lo cual se obtiene el resultado que se muestra en la Fig. 1.7:

Figura 1.7 1.7 Saludo. ActionScript 3.0 – Francisco Arce

Alfaomega

1. ActionScript 3.0. Evolucionar o morir

15

Son muchas líneas de código para un simple saludo, ¿no? Poco a poco se irá encontrando los beneficios de AS3.0, sobre todo cuando se realicen proyectos más complejos. Para terminar con esta introducción al lenguaje se abordarán dos temas también muy importantes: la herencia y las subclases.

Herencia Imagínese que un día alguien amanece con el don de hacer lo que desee con las especies del reino animal, así que decide crear a los “gatos voladores”. Aunque cuenta con poderes ilimitados, no va a hacer a los gatos voladores a partir de cero, ya que cuenta con una especie de “gatos”, por lo que sólo hay que agregarles las propiedades (características) y acciones (métodos) a dicha clase para crear una nueva clase animal. Entre las nuevas características y acciones de los gatos voladores podrían destacar (cada ser con el don de transformación de los animales puede seleccionar sus propios cambios): NUEVAS CARACTERÍSTICAS (PROPIEDADES)

NUEVAS ACCIONES (MÉTODOS)

Tamaño de las alas

Volar()

Color de las alas

Aterrizar()

Velocidad

Planear()

Además esa persona no sólo tiene el poder de cambiar a las especies animales a su antojo, sino que tiene también acceso a su código, así que puede ver la clase Gatos como la siguiente (tomando en cuenta que este poderoso Programador utilizó AS3.0): package { public class Gatos{ public var vidas:Number = 8; public var colorPelo:String; public function maullar(){ //… } public function ronronear(){ //.. } } }

Alfaomega

ActionScript 3.0 – Francisco Arce

Programación orientada a objetos: cuestión de gatos

16

Ahora tiene que escribir la nueva clase de la siguiente manera: package { public class public public public

GatosVoladores extends Gatos{ var alas:String = “grandes”; var colorAlas:String = “negras”; var velocidad:Number = 1000;

public function volar(){ //… } public function planear(){ //.. } public function aterrizar(){ //.. } } } Obsérvese que la clave para que los gatos voladores hereden las propiedades y métodos de los gatos ordinarios fue la palabra extends, extends es decir, extendió a la clase GatosVoladores a la clase Gatos. Una vez concluida su obra, los mortales pueden utilizar la nueva clase de la siguiente forma: var gatito:GatosVoladores = new GatosVoladores(); benito.volar() benito.ronronear() benito.maullar() //etc. Nótese que la instancia gatito podrá hacer tanto las acciones de los Gatos Ordinarios como de los Gatos Voladores. A esto se le llama Herencia.

Override Supóngase ahora que los gatos voladores ronronean de un modo diferente y podría decirse que tienen un agudísimo sonido, pero los gatos ordinarios ronronean de la misma forma en que lo han hecho por siglos, de manera que no se puede modificar la rutina del programador original, así que se tendrá que sobreescribirla en la nueva clase. Para ello se utiliza el modificador override, override el cual reescribe la forma de

ActionScript 3.0 – Francisco Arce

Alfaomega

1. ActionScript 3.0. Evolucionar o morir

17

ronronear de los Gatos Voladores sin afectar a los Gatos Ordinarios. La sentencia sería aproximadamente la siguiente:

package { public class GatosVoladores extends Gatos{ //... override public ronronear(){ //... } } } TIP DE CERTIFICACIÓN En el examen de certificación ACE también te preguntarán sobre el override en la relación clase-súper clase.

Ejemplo práctico Volviendo al primer ejemplo, el de Hello World, se abre un archivo ActionScript nuevo, se le nombra como Godbay y se guarda en la carpeta misClases. misClases En el panel de acciones se escribe el siguiente código:

package misClases { public class Godbay extends Jelou{ public function adios() { return “Adios desde Godbay”; } } } Igual que en el ejemplo de los gatos, la clave en este ejercicio se encuentra en el extends, extends el cual hará que la propiedad hola de la clase Jelou sea heredada a los objetos de la clase Godbay.

Alfaomega

ActionScript 3.0 – Francisco Arce

18

Ejemplo práctico

Obsérvese que, aunque las clases radican en archivos diferentes, tienen el mismo nombre de paquete, pero deben de radicar en la misma carpeta (misClases). Un paquete puede tener varios archivos, pero una clase sólo puede tener uno. También se habrá notado que no se utiliza ninguna sentencia import, import ya que ambas clases residen en el mismo paquete. Ahora, desde el archivo jelou.fla se modifica el código por el siguiente: import misClases.*; // var saludo:Jelou = new Jelou(); trace(saludo.hola()); // var despedida:Godbay = new Godbay(); trace("//"); trace(despedida.hola()) trace(despedida.adios()); Obsérvese que en la primera línea se utiliza el asterisco, con el cual se importan todas las clases públicas del paquete, en este caso las clases Jelou y Godbay que se encuentran en misClases. Posteriormente se hace una instancia de la clase Jelou. Jelou En la siguiente línea se llama al método hola(). hola() Nótese que se utiliza la notación punto para ello (dot syntax), es decir, primero el nombre del objeto o instancia, posteriormente un punto y luego el método. En las siguientes líneas se crea una instancia de la clase Godbay. Godbay Nótese que se está llamando al mismo método hola que fue creado en la clase Jelou, Jelou es decir, fue heredado de una clase a otra. Si se ejecuta el documento de Flash jelou.fla, se deberá tener en el panel de salida el resultado que se observa en la Fig. 1.8:

Figura 1.8 Herencia. Obviamente este ejemplo es muy sencillo. Enseguida se verá cómo heredar las propiedades y métodos de una clase ya establecida dentro de Flash. .

ActionScript 3.0 – Francisco Arce

Alfaomega

1. ActionScript 3.0. Evolucionar o morir

19

Una subclase de MovieClip/Sprite En AS3.0 se tiene una nueva clase: Sprite, que es un MovieClip pero sin línea de tiempo, la cual tiene la mayoría de las características ya conocidas, pero más ligera. No tiene equivalente en el IDE de Flash. Si se escribe una clase y se le “extiende” a una clase MovieClip o Sprite, heredará todos los métodos y propiedades de las mismas. Es decir, si se está desarrollando un juego de gatos, se puede determinar que las propiedades son: vidas, colorPelo, velocidad, salto y valor. Las acciones que puede realizar en el juego son: saltar, correr, atraparRaton, morir. Los gatitos tendrán su parte visual y no se necesitará línea de tiempo, así que la clase Sprite resulta excelente. El esqueleto de esta clase gatos podría ser:

package { import flash.display.Sprite; public class Gato private var private var private var private var private var

extend Sprite{ vidas:Number = 8; colorPelo:String = “Negro”; velocidad:Number = 100; salto:Number = 3; valor:Number = 10;

public function saltar():void{ } public function correr():void{ } public function atraparRaton():void{ } public function morir():void{ } } } Nótese que es necesario importar la clase antes de la definición de la clase propia. Lo mismo procedería si la clase Gato se extendiera a la clase MovieClip.

Alfaomega

ActionScript 3.0 – Francisco Arce

Clase de documento o document class

20 TIP DE CERTIFICACIÓN

Pregunta: ¿A cuáles clases se debe extender un Document Class? Respuesta: MovieClip o Sprite. Ahora se explicará un nuevo y fundamental concepto en AS3.0: la clase de documento.

Clase de documento o document class En este punto ya tenemos la información necesaria para incorporar el Documento de clase (este término es como está traducido en el IDE en español). Este tipo de documento es una clase que está extendida a la clase Sprite o MovieClip. Esta clase debe ser pública. Las restantes pueden ser públicas, privadas o internas. A esta clase se le conocerá como clase principal (main class). Cuando se reproduce el SWF, el constructor de la clase principal será ejecutado. Es decir, servirá como punto de partida para nuestra aplicación. TIP DE CERTIFICACIÓN El concepto de Document Class tiene mucho peso en el examen de certificación ACE. Hay al menos tres preguntas relacionadas. Es importante que lo domines.

En el IDE de Flash CS3 esta clase es opcional, de hecho ya se ha compilado SWF sin definir la clase principal. Sin embargo, es una buena práctica siempre partir del constructor de la clase principal. Véase el siguiente ejemplo. Se abre un nuevo documento Flash AS3.0 y se le nombra jelou2.fla. Se abre un archivo de ActionScript y se guarda con el nombre de Jelou2.as en la carpeta misClases (la letra en mayúscula del archivo es necesaria). En el archivo Jelou2.as se escribe el siguiente código:

package misClases { import flash.display.Sprite; public class Jelou2 extends Sprite{ public function Jelou2 ():void { inicio(); }

ActionScript 3.0 – Francisco Arce

Alfaomega

1. ActionScript 3.0. Evolucionar o morir

21

private function inicio():void { trace("Hello World"); } } } Primero se define el paquete dentro de misClases (el archivo debe de ir en esa carpeta). En la siguiente línea se importa a la clase Sprite. Obsérvese que está dentro del paquete, pero fuera de la definición de la clase. La clase Jelou2, por ser la clase principal, debe ser pública y extendida a Sprite o MovieClip. Después de esto, se encuentra la función constructora (con el mismo nombre que la clase y con la primera letra en mayúscula). Esta función sólo llama a la rutina inicio. Obsérvese que la rutina inicio solamente tiene una línea (en este ejemplo). No es una buena práctica introducir mucho código en la función constructora. La función inicio, inicio como se puede ver, está marcada como privada, privada es decir, el usuario no puede acceder a ella más que por la función constructora. Al ejecutar el documento Jelou2.fla se observará que en la pantalla de salida aparecerá el legendario Hello World. Con este ejemplo concluye el primer acercamiento a la programación orientada a objetos, aunque el camino es aún largo, vale la pena recorrerlo. Por ello se profundizará más en la programación orientada a objetos, antes de abordar el nuevo modelo de eventos y el Display List.

Alfaomega

ActionScript 3.0 – Francisco Arce

22

A manera de conclusión

A manera de conclusión Una clase es una representación abstracta que contiene propiedades, métodos y manejadores de eventos (alguno de estos tres) para crear objetos o instancias, los cuales heredan las propiedades, métodos y manejadores de eventos de la clase. Es fundamental que se aprenda la estructura básica de las clases, ya que eso nos permitirá aprovechar ActionScript 3.0 a su máximo. En el próximo capítulo analizaremos un poco más de la programación orientada a objetos y las variables, un concepto fundamental en la programación. Las clases se escriben en archivos de texto externos, por lo que es recomendable emplear un procesador de texto que no deje caracteres especiales. Las características básicas de la sintaxis del lenguaje son: 1. AS3.0 distingue entre mayúsculas y minúsculas. 2. El operador punto (.) permite acceder a las propiedades y métodos de los objetos. 3. En AS3.0 ya no se acepta la sintaxis de diagonales. 4. Una literal es un valor que aparece en el código, por ejemplo 3.0, “Hola”, true. 5. El punto y coma (;) indica que se termina una sentencia. 6. Los comentarios de línea (doble diagonal) y de bloque (/*...*/) se mantienen.

ActionScript 3.0 – Francisco Arce

Alfaomega

Algo más sobre programación orientada a objetos

2

Introducción Debido a que el tema de la programación orientada a objetos es muy extenso, en este capítulo se explica con más detalle, para luego pasar al tema fundamental de las variables y los operadores.

Paquetes (packages) • • • • • • •

Un archivo puede contener varias clases, pero sólo una es pública. Las demás clases dentro del paquete no deberán ser públicas, lo que no las hace accesibles para código fuera de ese archivo. El nombre de la clase pública del paquete debe coincidir con el nombre del archivo. Las demás clases obviamente no. Los paquetes pueden contener algo más que clases: se puede declarar variables, funciones y namespaces (incluso sentencias ejecutables) en el “nivel superior” del paquete. Si se declaran funciones, variables o namespaces, los únicos modificadores de acceso son public e internal. Sólo uno de los elementos, incluyendo las clases, puede tener el modificador public. Los paquetes se pueden anidar.

Alfaomega

ActionScript 3.0 – Francisco Arce

24

Introducción

No se debe confundir el término de herencia con un paquete. Aunque existan varias clases en un mismo archivo físico, eso no implica que sus métodos, propiedades y manejadores de eventos se compartan (hereden). Lo mismo aplica a los paquetes anidados: no hay ninguna relación de herencia entre ellos.

Importar paquetes Si se desea utilizar una clase que no se encuentre en el mismo directorio que la película fla, se debe importar. En la medida de lo posible debe evitarse el uso del asterisco (*) para importar clases, ya que eso sólo eleva la posibilidad de conflictos en las nomenclaturas. Hay que ser lo más específico posible. Es una buena práctica incluir la ruta de los paquetes en el ClassPath para que la compilación sea más rápida. TIP DE CERTIFICACIÓN Pregunta: ¿Cuál es la forma de compartir diferentes paquetes en diferentes proyectos? Respuesta: Creando un class path desde los proyectos hacia los paquetes.

Por default, el modificador de acceso de una clase dentro de un paquete es internal. Para hacerla pública hay que utilizar explícitamente el modificador de acceso public. No se puede declarar un paquete como public. TIP DE CERTIFICACIÓN Pregunta: ¿Cuál es modificador por default de una clase? Respuesta: Es internal y no public, como en otros lenguajes.

La directiva del compilador #include, a diferencia que en C++, no funciona para importar clases. En AS3.0 sólo la sentencia import funciona para ese propósito.

Nombres de espacios o namespaces Los namespaces controlan la visibilidad de las clases, métodos y propiedades. Los modificadores de acceso que se han revisado hasta el momento: public, internal, private y protected, son namespaces ya incorporados al lenguaje. Si estos modificadores de acceso no se adaptan a las necesidades de programación, se pueden crear namespaces propios.

ActionScript 3.0 – Francisco Arce

Alfaomega

2. Algo más sobre programación orientada a objetos

25

Por ejemplo, las propiedades y los métodos siempre tienen un namespace, aunque no se vean o no se hayan escrito. En AS3.0, dentro de las clases, si no está especificado el nombre de espacio, se adoptará por default el valor internal. Para el uso de los nombres de espacios se deben seguir los siguientes tres pasos: 1. Definir el namespace con la palabra reservada namespace. Por ejemplo, el siguiente código define un nombre de espacio nombre1: namespace nombre1: 2. Puede utilizarse el nuevo namespace en lugar del modificador de acceso en una declaración de propiedad o de método. Por ejemplo: nombre1: function miFuncion(){ } 3. Por último, una vez aplicado el namespace se puede hacer referencia al mismo con la palabra reservada use o calificando el nombre de un identificador con un namespace. Por ejemplo: use namespace nombre1: miFuncion(): Otra forma de llamarlo es por medio del nombre completo, por ejemplo: nombre1::miFuncion();

Modo estricto y modo estándar de compilación En lo que a AS3.0 se refiere, en Flash CS3 existen diferentes modos de compilación como se muestra a continuación. Se entra a FileFile->Publish Settings. Settings En la pestaña de Flash, si está seleccionada la opción de ActionScript 3.0, se pulsa el botón del lado derecho “Settings…” y enseguida se despliega la siguiente ventana emergente:

Alfaomega

ActionScript 3.0 – Francisco Arce

26

Introducción

Figura 2.1 Configuración del ActionScript 3.0. La primera opción es el Documento de clase, clase el cual es igual al del Panel de propiedades. Si se pulsa el símbolo de verificación (la palomita), Flash verificará la existencia de la clase. Con el botón de lápiz, Flash abrirá (si es que no está ya abierta) la clase del documento. El campo de Export classes in frame tendrá como predeterminado el primer fotograma, pero puede modificarse. Dentro de la categoría de errores se tienen el modo de compilación estricta (Strict Mode) y el modo de mensajes de alerta (Warnings Mode). En el modo estricto no permitirá generar el SWF si existe(n) algún(os) mensaje(s) de alerta, pues los tomará como errores. En modo de alerta (Warning mode) generará algunos mensajes de alerta sobre la compatibilidad entre AS2 y AS3. Siempre es recomendable trabajar en modo estricto y con los mensajes de advertencia (Warnings) activos.

ActionScript 3.0 – Francisco Arce

Alfaomega

2. Algo más sobre programación orientada a objetos

27

Variables Las variables son contenedores donde se puede almacenar o recuperar información. En AS2.0 el uso de la palabra clave var era una buena práctica y opcional, pero obligatorio si quiere tipificar a la variable. En cambio, en AS3.0 es obligatorio utilizar la sentencia var. Si se omite la sentencia var para la creación de una variable, el compilador enviará un mensaje de error (si se encuentra en modo estricto) y un error cuando ejecute su película. También se debe indicar el tipo de datos que almacenará la variable al momento de declararla. Se puede hacer la declaración sin indicar el tipo de dato, pero el compilador enviará un error si se encuentra en modo estricto. Para asignar el tipo de variable son necesarios los dos puntos después del nombre de la misma, por ejemplo: var nombreGato:String; var numVidas:Number; var gatoVolador:Bolean; La asignación de valores se puede hacer en forma simultánea a la declaración, con el operador igual “=” o hacer la asignación posteriormente a la declaración, es decir: var nombreGato:String = “Benito Bodoque” var numVidas:Number = 8; var gatoVolador:Bolean; // gatoVolador = false; O se puede declarar más de una variable a la vez: var x:Number, y:Number, alpha:Number; Asimismo, se puede asignar valores en la misma sentencia var, por ejemplo: var x:Number=0, y:Number=100, alpha:Number=0;

Pero no se podrán hacer asignaciones simultáneas de ninguna de las siguientes formas: var x:Number = y:Number = 0; var x = y = 0;

Alfaomega

ActionScript 3.0 – Francisco Arce

28

Variables

Aunque agrupar varias declaraciones no marca error de compilación, no es una práctica recomendable, pues hace el código más complejo y difícil de mantener.

Ejercicio •

Se abre un archivo Flash AS3.0 y se guarda en la carpeta de trabajo como variables.fla.

•

En el panel de Publish Settings, en el botón de Settings de AS3.0 se verifica que estén seleccionadas las opciones de compilación en modo estricto y de mensajes de alerta.

•

Se abre un archivo ActionScript y se guarda con el nombre de Variables.as en la carpeta misClases.

•

En el archivo de ActionScript se escribe el siguiente código de una clase vacía (sin función constructora):

package misClases { public class Variables{ } } Dentro de la clase se escriben las siguientes sentencias: numVidas = 0; •

Se guarda el archivo as y se ejecuta la verificación de sintaxis (la palomita azul). Ésta deberá indicar que no hay errores. La asignación es sintácticamente correcta aunque no tenga la palabra reservada var.

•

Ahora se cambia al archivo fla. En el panel de propiedades se escribe en el campo Document Class la liga a la clase, es decir, misClases.Variables. misClases.Variables.

•

Se ejecuta la película con [Ctrl] + [Enter]. Se observará que el compilador envía un mensaje de error.

•

Ahora se desactiva el modo estricto y se vuelve a compilar. Nótese que el mensaje de error ya no aparece. Aunque a primera vista pudiera pensarse que eso es bueno, es mejor que el compilador indique los errores que se cometen. Se vuelven a encender los parámetros de Modo estricto y de Modo de alerta.

•

ActionScript 3.0 – Francisco Arce

Alfaomega

2. Algo más sobre programación orientada a objetos

29

•

Si se encuentra en la vista del archivo fla, se puede saltar hacia el archivo de la clase con el botoncito con el lápiz que se encuentra a la derecha del campo Document Class (si éste no se encuentra abierto, Flash lo abrirá).

•

Entonces se cambia la línea de asignación por la siguiente: var numVidas;

•

Aunque ya se utilizó la palabra reservada var, aún no se ha definido un tipo de datos. Se guarda el archivo as y se ejecuta la película fla en Modo estricto y sin Modo estricto. A esta variable se le llama “sin tipo”. Aunque se permite en AS3.0, no es una buena práctica hacerlo.

•

Se regresa al archivo as y se sustituye la línea de la variable por la siguiente, en donde se hace la declaración de varias variables en la misma línea: var numVidas:Number =0, colorPelo:String = "negro", gatoVolador:Boolean = false

•

Se guarda el archivo y se regresa al archivo fla. Se compila el archivo en modo estricto. No deberá aparecer mensaje de error. Aunque se permite esta forma de codificación, tampoco es recomendable.

•

Finalmente se regresa al archivo de la clase y se cambia la línea anterior por la siguiente: var numVidas:Number = numGatos:Number = numPerros:Number = 0;

• •

Se salva el archivo as, se regresa a la película fla y se ejecuta. Aunque se permite esta forma de codificar en versiones anteriores de AS, en esta versión el compilador enviará un mensaje de error. Se salvan ambos archivos para ser utilizados en el siguiente ejercicio.

Ámbito o alcance de las variables El ámbito o alcance de la variable es la zona en la que aparece “visible”, es decir, se le puede asignar o recuperar la información, dentro del código. En AS3.0 las variables siempre tienen el ámbito de la función o de la clase en las que fueron declaradas. Se puede definir como una variable global a aquella que está definida fuera de una función. Por lo tanto, una variable local es aquella que se define dentro

Alfaomega

ActionScript 3.0 – Francisco Arce

30

Variables

de una función. Además, una variable local sólo existirá dentro de las llaves de la misma. Si existe una variable global y se define dentro de una función a una variable local con el mismo nombre, la primera no se modificará cuando la función sea llamada. Durante la ejecución de la función se creará una copia temporal de la variable, la cual se destruirá al terminar la misma, sin alterar el valor de la variable global. Si se declara pero no se le asigna ningún valor a la variable, el valor por default será el que se muestra en la Tabla 2.1. TIPO DE DATO

Tabla 2.1 Valores predefinidos. VALOR PREDEFINIDO

Bolean

false

Int

0

Number

NaN

Object

Null

String

Null

Uint

0

Sin declarar

undefined

Todas las demás clases

null

Objetos creados por el usuario

null

Las variables que son definidas dentro de funciones, funciones constructoras, métodos dinámicos o estáticos, se considerarán variables locales, es decir, sólo existirán mientras la función se ejecute. Las variables que sean definidas fuera de las funciones, dentro de una clase, se considerarán variables de instancia y se convertirán en propiedades.

Ejercicio •

Se abren dos archivos, el archivo variables.fla y el archivo de clase Variables.as.

•

Verifíquese que se encuentre en modo estricto de compilación.

•

En el archivo de la clase se captura el siguiente código:

ActionScript 3.0 – Francisco Arce

Alfaomega

2. Algo más sobre programación orientada a objetos

31

package misClases { import flash.display.Sprite; public class Variables extends Sprite{ var total:Number = 100; public function Variables(){ trace(total); suma(10,20); trace(total); } public function suma(num1:Number, num2:Number){ var total:Number = num1 + num2; trace(total) } } } • •

•

Obsérvese que se trata de una variable definida fuera de las funciones con un valor inicial de 100. La función constructora envía a la pantalla de salida el valor de esta variable y deberá mostrarse un valor de 100. Seguido a la función constructora se escribe un método que recibe un par de valores en una variable también llamada total. Nótese que se está definiendo con la palabra reservada var, por lo que se considera una variable local. La función constructora llama al método y posteriormente hace un nuevo trace. Entonces el resultado deberá ser el que muestra la Fig. 2.2.

Figura 2.2 Uso de variables locales. Alfaomega

ActionScript 3.0 – Francisco Arce

32 • •

Variables La variable global, candidata a ser una propiedad, no fue alterada, aunque hay una variable local con el mismo nombre. Ahora modifíquese la variable local de la siguiente forma: total = num1 + num2;

•

Se ejecuta nuevamente la película y se observa que el valor de la variable se modificó como se aprecia en la figura 2.3.

Figura 2.3 Sin el uso de variables locales.

Variables por su alcance También se puede diferenciar a las variables dinámicas y estáticas, las cuales se verán más adelante. Antes de analizar la visibilidad de una variable de instancia, según su modificador de acceso, es útil analizar el cuadro de clases de la Fig. 2.4.

Paquete 1 Clase 1

Clase extendida

Clase 2 dentro del mismo paquete

Paquete 2 Clase 3 fuera del paquete

Figura 2.4 Cuadro de clases. ActionScript 3.0 – Francisco Arce

Alfaomega

2. Algo más sobre programación orientada a objetos

33

Como se muestra en la Fig. 2.4, se tienen las siguientes clases: la clase en sí misma (Clase1), una clase dentro del mismo paquete (Clase2), una fuera del paquete (Clase3) y una extendida a partir de la clase original. Haciendo un cruce entre estos tipos de variables y los modificadores de acceso, resultaría como se ve en la Tabla 2.2. Tabla 2.2 Resultado del cruce de tipos de variables y modificadores de acceso. public

internal

protected

private

Código dentro de la clase (Clase1)

Visible

Visible

Visible

Visible

Código de una clase descendente (Clase4)

Visible

Visible

Visible

No visible

Código en otra clase dentro del mismo paquete (Clase2)

Visible

Visible

No visible

No visible

Código en otra clase, en otro paquete

Visible

No visible

No visible

No visible

Parámetros de la función constructora Los parámetros son una especie de variables locales, las cuales no necesitan la palabra constructora var. Los parámetros pueden recibir valores por omisión dentro de la función constructora, por ejemplo: class Jelou{ function Jelou(arg1=valor1, arg2=valor2, arg3=valor3){ } } Esta característica, nueva en AS3.0, se explicará con detalle en el próximo capítulo cuando se vea el tema de las funciones. Cuando se llama a la función constructora, al crear el objeto de nuestra clase se “pasan” los valores a los argumentos. Por ejemplo, al crear el objeto se puede pasar el valor del argumento: var saludo:Jelou = new Jelou(“Buenos dias”); … public function Jelou(arg1){ trace(arg1); } Alfaomega

ActionScript 3.0 – Francisco Arce

34

Variables

Si se compila en el modo estricto y no “pasa” uno de los valores, Flash enviará un mensaje de error. TIP DE CERTIFICACIÓN Pregunta: ¿Con qué operador puede crear una nueva instancia de clase? Respuesta: Con el operador new.

Ejercicio Se abre un archivo nuevo as y se graba como Variables2.as en la carpeta misClases. Sobre este archivo se escribe la siguiente clase: package misClases { public class Variables2{ public function Variables2(arg:String="Hola"){ trace(arg); } } } Obsérvese que se está haciendo una función constructora con un argumento y un valor por omisión. En la clase Variables.as se sustituye el código anterior por el siguiente: package misClases { import flash.display.Sprite; public class Variables extends Sprite{ public function Variables(){ var saludo:Variables2 = new Variables2(); } } } Nótese que en la función constructora de la clase principal se está creando un objeto de la clase Variables2 y que no se está pasando el objeto. Se graban todos los archivos y se ejecutan. El resultado deberá ser el que muestra la Fig. 2.5.

Figura 2.5 Salida de la función constructora. ActionScript 3.0 – Francisco Arce

Alfaomega

2. Algo más sobre programación orientada a objetos

35

Aunque no se pasó un parámetro, el compilador no envió un mensaje de error porque se tiene un valor por default. Ahora se modifica la llamada a la función constructora de la clase Variables2 por la siguiente línea: var saludo:Variables2 = new Variables2("Buenas tardes"); Se ejecuta la película y se observará en la pantalla de salida la leyenda “Buenas tardes”. Es decir, el valor por default fue sustituido. Ahora se quita el valor por default de la variable constructora de la clase Variables2 para que quede de la siguiente manera: public function Variables2(arg:String){ trace(arg); } De esta forma, el argumento pasó a ser obligatorio. Ahora se modifica la creación del objeto en la clase variables para que mande ningún parámetro: public function Variables(){ var saludo:Variables2 = new Variables2(); } Verifíquese que el compilador esté en forma estricta. Se graban todos los archivos y se ejecuta la película. Deberá aparecer un error 1136: Número incorrecto de argumentos.

Tipo de datos Un tipo de datos es el conjunto de valores admitidos para la variable. En la Tabla 2.3 se exponen los que se consideran valores simples de datos. Tabla 2.3 Valores simples de datos. Tipo de dato simple Boolean

Sólo acepta los valores de true y false. Su valor por default es false.

String

Secuencia de caracteres con 16 bits cada uno. Admite el formato UTF-16. (Continúa)

Alfaomega

ActionScript 3.0 – Francisco Arce

36

Variables

Tabla 2.3. (Continuación.) Tipo de dato simple Number

Son números enteros y de coma flotante de 64 bits. Admite valores entre -9.007.199.254.740.992 (-253) y 9.007.199.254.740.992 (253).

int

Números enteros de 32 bits que van de -2.147.483.648 (-231) a 2.147.483,647 (231 - 1), ambos incluidos. Números enteros sin signo de 32 bits. Sus valores oscilan entre 0 y 4.294.967.295 (232- 1).

uinit

Un tipo de datos complejos está formado por valores de datos simples u otros valores de datos complejos; por ejemplo, como se aprecia en la Tabla 2.4. Tabla 2.4 Tipos de datos complejos. Tipo de dato complejo Array Object XML Error XMLList

Tanto los tipos de datos simples como los complejos son objetos para el compilador, aunque los valores simples tendrán un tratamiento especial. Por ejemplo, para declarar una variable de tipo int son válidas las siguientes dos sentencias: var edad:Number = 10; var peso:Number = new Number(20); En AS3.0 se permite la verificación del tipo en tiempo de ejecución, pero también permite la verificación en tiempos de compilación en el modo estricto. Si no

ActionScript 3.0 – Francisco Arce

Alfaomega

2. Algo más sobre programación orientada a objetos

37

se encuentra en modo estricto, la verificación únicamente se efectuará en tiempo de ejecución. En modo estricto, el compilador enviará mensajes de error si hay una asignación diferente al tipo de datos.

Ejercicio •

Se abre un archivo nuevo de Flash AS3.0 y se guarda como tipos.fla en la carpeta de trabajo. Ahora se abre un archivo as nuevo y se guarda como Tipos.as en la carpeta misClases. Verifíquese que se encuentre en modo estricto de compilación. En el Document Class se escribe misClases.Tipos y se pulsa ENTER. En el archivo de clase se escribe el siguiente esqueleto de clase:

• •

package misClases{ import flash.display.Sprite; public class Tipos extends Sprite{ public function Tipos(){ } } } •

Debajo de la función constructora se escribe la siguiente función: public function prueba(arg1){ if (arg1 is String){ var cadena:String = arg1; trace("Cadena: " + arg1); } else if (arg1 is Number){ var numero:Number = arg1; trace("Número: " + numero); } }

La función de prueba no tiene definido el tipo de su argumento, por lo que se puede recibir un valor con cualquier tipo de dato. Ahora en la función constructora se escriben las siguientes dos líneas en negritas: public function Tipos(){ prueba(100); prueba("Hola"); } Alfaomega

ActionScript 3.0 – Francisco Arce

38 •

Variables Ejecútese la película y se deberá tener una salida como la que muestra la Fig. 2.6.

Figura 2.6 Resultado de los diferentes tipos de variable. •

Ahora se cambia el tipo de dato en el argumento de la función prueba al siguiente: public function prueba(arg1:String){

•

Entonces el compilador deberá mandar un mensaje de error. Para evitarlo se apaga el modo estricto y se vuelve a correr la película. Mandará ahora los mensajes correctos pero podría tener un error en tiempo de ejecución. Por último, se regresa al modo de compilación estricta.

•

Si el compilador se encuentra en modo estándar, se generará el error de tipos únicamente en el tiempo de ejecución.

Saber los tipos de variable: operadores is y as Si se desea saber cuál es el tipo de una variable, en AS3.0 ya no se utiliza el operador instanceof, el cual se sustituye ahora con el operador is. El operador is no sólo determina el tipo de clase a la que pertenece un objeto, sino la jerarquía de herencia del mismo, es decir, cuáles clases heredaron a la clase del objeto. Por ejemplo, si se tiene una instancia de la clase Sprite, la cual hereda de las clases DisplayObject e IEventDispatcher, el resultado sería el que muestra el siguiente ejemplo.

Ejemplo Se abren los archivos tipos.fla y Tipos.as. En el archivo de la clase se sustituye el código existente por el siguiente: package misClases{ import flash.display.*;

ActionScript 3.0 – Francisco Arce

Alfaomega

2. Algo más sobre programación orientada a objetos

39

import flash.events.IEventDispatcher; public class Tipos extends Sprite { public function Tipos() { var miSprite:Sprite = new Sprite(); trace(miSprite is Sprite); trace(miSprite is DisplayObject); trace(miSprite is IEventDispatcher); } } } Verifíquese que el compilador esté en modo estricto. Se ejecuta la película y se deberá tener una salida como la de la Fig. 2.7.

Figura 2.7 Resultado del operador is. •

Otra novedad en AS3.0 es el operador as, el cual regresa el valor de la expresión en lugar de true, y regresa un valor null en lugar de false. Así, en el ejercicio se sustituye o coloca debajo de las sentencias trace el siguiente código: var miSprite:Sprite = new Sprite(); trace(miSprite as Sprite); trace(miSprite as DisplayObject); trace(miSprite as IEventDispatcher); trace(miSprite as Number);

•

La salida deberá ser como se aprecia en la Fig. 2.8.

Figura 2.8 Resultado del operador as. Ahora se guardan los archivos, ya que se requerirán en la próxima sección. Alfaomega

ActionScript 3.0 – Francisco Arce

40

Variables

Conversión de tipos Las conversiones de tipos de datos se dan cuando una variable cambia de un tipo de dato original a otro. Hay dos formas de conversión de tipos: implícita, cuando la hace el compilador en forma automática, y explícita, cuando es el código el que le indica al compilador que cambie el tipo de una variable. Las conversiones implícitas se efectúan en los siguientes casos: En sentencias de asignación Cuando se pasan valores como argumentos de función Cuando se devuelven valores desde funciones En expresiones que utilizan determinados operadores, como el operador suma (+) Las funciones para convertir a valor numérico son: Number(), init() y uinit(). La función para convertir explícitamente una variable a valor booleano es Boolean() y para las cadenas es String().

Constantes En la nueva versión de ActionScript se puede manejar constantes con la palabra reservada const. Se puede asignar valor sólo una vez a una constante. Por convención, las constantes se escriben con todas sus letras en mayúscula, y si tienen más de una palabra, éstas se separan con guiones bajos como se muestra en el siguiente ejemplo.

Ejercicio • • •

Se abren los archivos de tipos.fla y el de su clase Tipos.as. En el archivo fla verifíquese que el modo del compilador NO esté en modo estricto. En el archivo as se añade el código que aparece en negritas: package misClases{ import flash.display.*; public class Tipos extends Sprite { public const MAXIMO_VIDAS:int = 8;

ActionScript 3.0 – Francisco Arce

Alfaomega

2. Algo más sobre programación orientada a objetos

41

public const MARGEN_MINIMO:uint = 10; public function Tipos() { trace(MAXIMO_VIDAS); MAXIMO_VIDAS = 0; trace(MAXIMO_VIDAS); } } } •

Se salvan los cambios del archivo as. Ejecútese la película y obsérvese el resultado. Si no está activo el modo estricto, el compilador no notificará que se modificó una constante, tal como se aprecia en la Fig. 2.9.

Figura 2.9 Resultado de las constantes en modo no estricto del compilador. •

Ahora se regresa al modo estricto. En la Fig. 2.10 se observa que el compilador envía un mensaje de error.

Figura 2.10 Error al intentar modificar una constante en modo estricto del compilador.

Alfaomega

ActionScript 3.0 – Francisco Arce

42

Operadores

Operadores Los operadores son símbolos que se aplican a uno o más operandos para generar un nuevo resultado. Los operadores pueden ser literales, variables o expresiones regulares. En este libro se denomina precedencia al orden en que los operadores serán procesados por el compilador. La precedencia se puede modificar por medio de los paréntesis. Por ejemplo, la multiplicación tiene precedencia sobre la suma y puede cambiarse esta precedencia por medio de los paréntesis, como se ve enseguida: var suma:init = 2 + 3 * 4; //14 var suma:init = (2+3) * 4; //20 La Tabla 2.5 presenta la lista de operadores de mayor a menor precedencia. Tabla 2.5 Lista de operadores. Primario

[] {x:y} () f(x) new x.y x[y] @ :: ..

Sufijo

x++ x--

Unario

++x --x + - ~ ! delete typeof void

Multiplicativo

*/%

Aditivo

+-

Desplazamiento en modo de bit

> >>>

Relacional

< > = as in instanceof is

Igualdad

== != === !==

AND en modo bit

&

XOR en modo bit

^

OR en modo bit

|

AND lógico

&&

OR lógico

||

Condicional

?:

Asignación

= *= /= %= += -= = >>>= &= ^= |=

Coma

,

ActionScript 3.0 – Francisco Arce

Alfaomega

A manera de conclusión

43

Ahora se revisarán los Operadores principales.

Operadores principales Los operadores principales (Tabla 2.6) son aquellos que se utilizan para crear arreglos, objetos, instancias de clase, acceder a propiedades, agrupar expresiones, llamar a funciones y agrupamiento de expresiones. Tabla 2.6 Operadores principales Operador

Operación

[]

Inicializa una matriz

{x:y}

Inicializa un objeto

()

Agrupa expresiones

f(x)

Llama a una función

New

Llama a un constructor

x.y x[y]

Accede a una propiedad



Inicializa un objeto XMLList (E4X)

@

Accede a un atributo (E4X)

::

Califica un nombre (E4X)

..

Accede a un elemento XML descendiente (E4X)

Operadores de sufijo Estos operadores sirven para aumentar o disminuir una variable numérica en una unidad. numVidas++; numVidas--; Aunque son operadores unarios, tienen mayor precedencia que los de esta especie.

Alfaomega

ActionScript 3.0 – Francisco Arce

44

Operadores

Operadores prefijo A estos operadores se les llama unarios, ya que sólo afectan a un operando. Se escriben antes del operador y primero se hace la operación de incremento o decremento. Un ejemplo de ellos es: ++numVidas; --numVidas;

Operadores unarios Tienen la misma precedencia que los operadores prefijos y, por tanto, se aplican a un solo operando. La Tabla 2.7 muestra estos operadores. Tabla 2.7 Operadores unarios. Operador

Operación

++

Incremento (prefijo)

--

Decremento (prefijo)

+

Unario +

-

Unario - (negación)

!

NOT lógico

~

NOT en modo bit

Delete

Elimina una propiedad

Typeof

Devuelve información de tipo

Void Void

Devuelve un valor no definido

Operadores de multiplicación Son los operadores binarios (se aplican a dos operandos) con mayor precedencia. Éstos son la multiplicación, división y módulo, tal como se ve en la Tabla 2.8.

ActionScript 3.0 – Francisco Arce

Alfaomega

2. Algo más sobre programación orientada a objetos

45

Tabla 2.8 Operadores de multiplicación. Operador

Operación

*

Multiplicación

/

División

%

Módulo

Operadores aditivos Como se aprecia en la Tabla 2.9, son operadores binarios que suman o restan dos operandos. Tabla 2.9 Operadores aditivos. Operador

Operación

+

Suma

-

Resta

Operadores relacionales Comparan dos operandos y regresan un valor booleano, verdadero o falso. Los siguientes operadores que muestra la tabla 2.10 tienen la misma precedencia: Tabla 2.10 Operadores relacionales. Operador

Operación

<

Menor que

>

Mayor que

=

Mayor o igual que

As

Comprueba el tipo de datos

In

Comprueba las propiedades de objetos

Instanceof

Comprueba una cadena de prototipos

Is

Comprueba el tipo de datos

Alfaomega

ActionScript 3.0 – Francisco Arce

46

Operadores

Operadores de igualdad Son operadores binarios y regresan un valor booleano. Tienen menor precedencia que los operadores relaciones y se muestran en la Tabla 2.11. Tabla 2.11 Operadores de igualdad. Operador

Operación

==

Igualdad

¡=

Desigualdad

===

Igualdad estricta

¡==

Desigualdad estricta

Operadores lógicos Son operadores binarios y regresan un valor booleano. El operador AND tiene precedencia sobre OR, se muestran en la tabla 2.12. Tabla 2.12 Operadores lógicos. Operador

Operación

&&

AND lógico

||

OR lógico

Operador condicional El operador condicional, de la Tabla 2.13, aplica a tres operandos. Son formas abreviadas del if… else… que se verá en el siguiente capítulo. Tabla 2.13 Operador condicional. Operador

Operación Operación

?:

Operador condicional

ActionScript 3.0 – Francisco Arce

Alfaomega

2. Algo más sobre programación orientada a objetos

47

Operadores de asignación Los operadores de asignación sirven para almacenar un operando en otro. Son los que tienen menor precedencia entre todos los operadores. Todos los siguientes operadores que muestra la Tabla 2.14 tienen la misma precedencia. Tabla 2.14 Operadores de asignación. Operador

Operación

=

Asignación

*=

Asignación de multiplicación

/=

Asignación de división

%=

Asignación de módulo

+=

Asignación de suma

-=

Asignación de resta

=

Asignación de desplazamiento a la derecha en modo bit

>>>=

Asignación de desplazamiento a la derecha en modo bit sin signo

&=

Asignación de AND en modo bit

^=

Asignación de XOR en modo bit

|=

Asignación de OR en modo bit

Ejemplo Para que no se aburra con tanta teoría, haremos un ejemplo sencillo de manejo de cadenas, aunque utilizaremos algunas estructuras que aún no hemos explicado, como son los ciclos y las condicionales. De acuerdo con la numerología, el carácter de una persona puede determinarse sumando las letras (se les asigna un valor A = 1, B = 2, etc.). El resultado es un número de más de un dígito, por ejemplo 26, se suman entre ellos, hasta que dé un dígito del 1 al 9. La siguiente tabla nos indica el carácter de la persona, según su número: Alfaomega

ActionScript 3.0 – Francisco Arce

48

Operadores

1. Voluntad, firmeza, capacidad. 2. Sociabilidad, creatividad, capacidad, inestabilidad emocional. 3. Inteligencia, creatividad, capacidad, interés por el arte. Poder espiritual y sexual. 4. Cautela, detallismo, falta de ambición, temor a lo desconocido, sexualidad. 5. Inclinación hacia la aventura, tendencia al cambio. 6. Tolerancia, estabilidad, orden, optimismo. 7. Tendencia al enigma, carácter poético, erudición, soledad. 8. Negociante, realizador de empresas, éxitos materiales. 9. Éxitos intelectuales, perfección, poder, carácter impulsivo. Por ser éste un ejemplo, faltan algunas validaciones importantes: • • • •

No acepta acentos: Tendríamos que hacer una pequeña función que los reemplazara. No acepta blancos: Habría que hacer otra función para eliminarlos. Si el nombre suma más de 99, tendríamos que validar, separa los tres dígitos. Podemos optimizar el código con un arreglo. Estos pendientes los efectuaremos en su momento.

1. Abra un archivo Flash ActionScript 3.0 y nómbrelo como numerología.fla dentro de su carpeta de trabajo. 2. Abra un archivo ActionScript 3.0 class y nómbrelo como Numerologia. Numerologia Grabe este archivo como Numerologia.as dentro de la carpeta misClases. 3. Escriba el camino de clase (class path) en la clase. El código en el archivo de clase deberá ser el siguiente: package misClases{ public class Numerologia { public function Numerologia() { // codigo de clase } } } 4. No olvide escribir en el Document Class, la carpeta y el nombre de la clase, véase la Fig. 2.11.

Figura 2.11 2.11 Document Class con carpeta y nombre de la clase. ActionScript 3.0 – Francisco Arce

Alfaomega

2. Algo más sobre programación orientada a objetos

49

5. En el archivo de clase, después de la definición del paquete, importe la clase Sprite y extienda a ella la nueva clase, según se marca en negritas en el siguiente código: package misClases{ import flash.display.Sprite; flash.display.Sprite; public class Numerologia extends Sprite{ Sprite 6. Necesitamos ahora una variable para almacenar el nombre por analizar con la numerología. Para ello creamos una variable (parámetro) fuera de la definición de las funciones y la declaramos como pública. 7. Dentro de la función constructora cambiamos la variable a mayúsculas e iniciamos el proceso invocando a la función inicio(). 8. Creamos la función inicio() (que por encontrarse en una clase, la llamaremos método) con el modificador de acceso private, con lo que este método únicamente podrá ser llamado internamente dentro de la clase Numerología. 9. El código dentro de la clase deberá ser el siguiente: package misClases{ import flash.display.Sprite; public class Numerologia extends Sprite{ var nombrePropio:String = "Francisco"; public function Numerologia() { trace("El nombre original es: "+nombrePropio); nombrePropio = nombrePropio.toUpperCase(); trace("El nombre original en mayúsculas es: "+nombrePropio); inicio() } private function inicio() { } } } 10. Ejecute la aplicación con [Ctrl] + [Enter] (Windows) o [Comando] + [Return] (Mac). En la ventana de salida tendrá el nombre en su forma original y también convertida a mayúsculas en el panel de salida.

Alfaomega

ActionScript 3.0 – Francisco Arce

50

Operadores

Figura 2.12 Salida de la ejecución del script. 11. Dentro del método inicio() escriba el siguiente código para obtener la suma de las letras del nombre: private function inicio() { var longitud:uint = nombrePropio.length; var suma:uint; var ascii:uint; var valor:uint; var letra:String; // trace("El número de caracteres es: "+longitud); for(var i:int=0; i9){ digito1 = Math.floor(suma/10); digito2 = suma%10; suma = digito1 + digito2; } trace(suma);

ActionScript 3.0 – Francisco Arce

Alfaomega

2. Algo más sobre programación orientada a objetos

51

Observe que estamos utilizando el operador módulo (%) que lo que hace es regresarnos el residuo entero de una división. El resultado de este ciclo, será un número entre 1 y 9, pues suma consecutivamente la cifra hasta que la cantidad sea menor o igual a 9. 13. Ya con el número deseado, simplemente le indicaremos al usuario, cuál es su carácter, dependiendo de su nombre y de la numerología. El siguiente código deberá ser escrito debajo del ciclo anterior y dentro del método inicio(). inicio() switch (suma) { case 1 : trace("Voluntad, firmeza, capacidad"); break; case 2 : trace("Sociabilidad, creatividad, capacidad, inestabilidad emocional."); break; case 3 : trace("Inteligencia, creatividad, capacidad, interés por el arte."); break; case 4 : trace("Cautela, detallismo, falta de ambición, temor a lo desconocido."); break; case 5 : trace("Inclinación hacia la aventura, tendencia al cambio."); break; case 6 : trace("Tolerancia, estabilidad, orden, optimismo."); break; case 7 : trace("Tendencia al enigma, carácter poético, erudición, soledad."); break; case 8 : trace("Negociante, realizador de empresas, éxitos materiales."); break; case 9 : trace("Éxitos intelectuales, perfección, poder, carácter impulsivo."); break; }

Alfaomega

ActionScript 3.0 – Francisco Arce

52

A manera de conclusión

Estamos utilizando algunas estructuras que no se han explicado, pero si tiene conocimientos de programación en otro lenguaje, no le serán desconocidas. Estas sentencias son: • • • •

Sentencia “for”: Nos permite hacer ciclos por medio de uno o varios índices. Sentencia “while”: Efectúa interacciones validando una condición en la entrada del ciclo. Sentencia “if”: Verifica una condición. Sentencia “switch”: Evalúa una condición con varias opciones. Estas sentencias serán analizadas en el siguiente capítulo.

Lo importante es que observe cómo se estructura un programa en ActionScript. Es un conjunto de variables, operaciones y estructuras que nos permitirán obtener un resultado, en este caso, su carácter según la milenaria numerología. Así que teclee su nombre y vea cuál es su carácter según la numerología. Suerte. Grabe este ejercicio con el nombre “numerología.fla” (lo usaremos más adelante) en una carpeta específica para la lectura de este libro. En ella deberá almacenar los demás ejercicios que vaya haciendo.

A manera de conclusión El manejo de las variables es una piedra angular en cualquier lenguaje. Así como las expresiones regulares, son lo que nos permite modificar la información, recuerde los tópicos revisados en este capítulo. Variables Ámbito de las variables Alcance de las variables Parámetros de la función constructora Tipo de datos Tipos de variable Operadores is y as Conversión de tipos

Operadores Operadores principales Operadores prefijo Operadores unarios Operadores de multiplicación Operadores relacionales Operadores de igualdad Operador condicional Operadores de asignación

En el siguiente capítulo analizaremos las estructuras utilizadas en el ejercicio: los ciclos y las sentencias condicionales.

ActionScript 3.0 – Francisco Arce

Alfaomega

Sentencias condicionales y ciclos

3

Sentencias condicionales AS3.0 tiene tres sentencias condicionales, condicionales las cuales no sufrieron cambios de las versiones anteriores:

Sentencia if La sentencia if efectuará una verificación de una expresión con resultado booleano (true/false). Si la condición resulta verdadera, efectuará un bloque de sentencias. Su sintaxis es: if(condición){ sentencia1… sentencia2… etcétera… }

Opcionalmente se puede tener una sentencia else, la cual agrupa las sentencias que se ejecutarán si la condición da como resultado un valor false. La sentencia else siempre tiene que ir precedida de un if. Su sintaxis es:

Alfaomega

ActionScript 3.0 – Francisco Arce

54

Sentencias condicionales

if(condición){ sentencia1… sentencia2… etcétera… } else { sentencia1… sentencia2… etcétera… }

Sentencia if... else if Si se necesita verificar varias condicionales se puede utilizar la sentencia: if… else if… La última sentencia if puede llevar su contraparte else, la cual se ejecutará si no se cumple ninguna de las anteriores. Por ejemplo, si se desea tomar diferentes decisiones dependiendo de la edad del usuario, su sintaxis es: if(edad