Documentación de Flash CS3

Aprendizaje de ActionScript 2.0 en Adobe Flash > Interfaces > Ejemplo: Creación de una interfaz compleja

Ejemplo: Creación de una interfaz compleja

En el siguiente ejemplo se muestran diversas formas de definir e implementar interfaces. En este tutorial, aprenderá a crear un archivo de interfaz sencillo, a escribir una clase que implemente varias interfaces y a hacer que varias interfaces amplíen otras interfaces para crear estructuras de datos más complejas.

Para crear una interfaz compleja:

1. Cree un nuevo documento ActionScript y guárdelo como InterfaceA.as.
2. Cree una nueva carpeta llamada complexInterface y guarde en ella InterfaceA.as.

   Debe guardar en este directorio todos los archivos que cree para este tutorial.

3. En Interface.as, escriba el siguiente código ActionScript en la ventana Script:

   // nombre de archivo: InterfaceA.as
   interface InterfaceA {
       public function k():Number;
       public function n(z:Number):Number;
   }
   

4. Guarde el documento ActionScript, cree un nuevo documento ActionScript denominado ClassB.as y guárdelo en el directorio complexInterface.

   ClassB.as implementa la interfaz InterfaceA creada anteriormente.

5. En ClassB.as, escriba el siguiente código ActionScript en la ventana Script:

   // nombre de archivo: ClassB.as
   class ClassB implements InterfaceA {
       public function k():Number {
           return 25;
       }
       public function n(z:Number):Number {
           return (z + 5);
       }
   }
   

6. Guarde los cambios en el documento ClassB.as, cree un nuevo documento de Flash y guárdelo como classbTest.fla en el directorio complexInterface.

   Este archivo de clase prueba la clase ClassB creada anteriormente.

7. In classbTest.fla, escriba el siguiente código ActionScript en el fotograma 1 de la línea de tiempo:

   // nombre de archivo: classbTest.fla
   import ClassB;
   var myB:ClassB = new ClassB();
   trace(myB.k()); // 25
   trace(myB.n(7)); // 12
   

8. Guarde los cambios en el documento de Flash y luego seleccione Control > Probar película para probar el documento de Flash.

   El panel Salida muestra dos números, 25 y 12, que son los resultados de los métodos k() y n() de la clase ClassB.

9. Cree un nuevo archivo ActionScript y guárdelo como ClassC.as en el directorio complexInterface.

   Este archivo de clase implementa la interfaz InterfaceA creada en el paso 1.

10. En ClassC.as, escriba el siguiente código ActionScript en la ventana Script:

    // nombre de archivo: ClassC.as
    class ClassC implements InterfaceA {
        public function k():Number {
            return 25;
        }
        // **Error** La clase debe también implementar el método 'n' de la interfaz 'InterfaceA'.
    }
    

    Si hace clic en el botón Revisar sintaxis para el archivo de clase ClassC, Flash muestra un mensaje de error en el panel Salida que indica que la clase actual debe implementar el método n() en la interfaz InterfaceA. Al crear clases que implementen una interfaz, es importante definir métodos para cada entrada de la interfaz.

11. Cree un nuevo documento ActionScript y guárdelo como InterfaceB.as en el directorio complexInterface.
12. En InterfaceB.as, escriba el siguiente código ActionScript en la ventana Script:

    // nombre de archivo: InterfaceB.as
    interface InterfaceB {
        public function o():Void;
    }
    

13. Guarde los cambios en el documento InterfaceB.as, cree un nuevo documento ActionScript y guárdelo en el directorio complexInterface con el nombre ClassD.as.

    Esta clase implementa la interfaz InterfaceA y la interfaz InterfaceB creadas en pasos anteriores. La clase ClassD debe incluir implementaciones de método por cada uno de los métodos enumerados en cada uno de los archivos de interfaz.

14. En ClassD.as, escriba el siguiente código ActionScript en la ventana Script:

    // nombre de archivo: ClassD.as
    class ClassD implements InterfaceA, InterfaceB {
        public function k():Number {
            return 15;
        }
        public function n(z:Number):Number {
            return (z * z);
        }
        public function o():Void {
            trace("o");
        }
    }
    

15. Guarde los cambios en el archivo ClassD.as, cree un nuevo documento de Flash y guárdelo como classdTest.fla.

    El documento de Flash probará la clase ClassD creada anteriormente.

16. In classdTest.fla, añada el siguiente código ActionScript en el fotograma 1 de la línea de tiempo:

    // nombre de archivo: classdTest.fla
    import ClassD;
    var myD:ClassD = new ClassD();
    trace(myD.k()); // 15
    trace(myD.n(7)); // 49
    myD.o(); // o
    

17. Guarde los cambios en el archivo classdTest.fla y luego seleccione Control > Probar película para probar el archivo.

    Deberán aparecer los valores 15, 49 y la letra en el panel Salida. Estos valores son el resultado del método ClassD.k(), los métodos ClassD.n() y ClassD.o(), respectivamente.

18. Cree un nuevo documento ActionScript y guárdelo como InterfaceC.as.

    Esta interface amplía la interfaz InterfaceA creada anteriormente y añade una nueva definición de método.

19. En InterfaceC.as, escriba el siguiente código ActionScript en la ventana Script:

    // nombre de archivo: InterfaceC.as
    interface InterfaceC extends InterfaceA {
        public function p():Void;
    }
    

20. Guarde los cambios en el archivo ActionScript, cree un nuevo archivo ActionScript y guárdelo como ClassE.as en el directorio complexInterface.

    Esta clase implementa dos interfaces, InterfaceB e InterfaceC.

21. En ClassE.as, escriba el siguiente código ActionScript en la ventana Script:

    // nombre de archivo: ClassE.as
    class ClassE implements InterfaceB, InterfaceC {
        public function k():Number {
            return 15;
        }
        public function n(z:Number):Number {
            return (z + 5);
        }
        public function o():Void {
            trace("o");
        }
        public function p():Void {
            trace("p");
        }
    }
    

22. Guarde los cambios en el documento ActionScript, cree un nuevo documento de Flash y guárdelo como classeTest.fla en el directorio complexInterface.
23. En classeTest.fla, escriba el siguiente código ActionScript en el fotograma 1 de la línea de tiempo:

    // nombre de archivo: classeTest.fla
    import ClassE;
    var myE:ClassE = new ClassE();
    trace(myE.k()); // 15
    trace(myE.n(7)); // 12
    myE.o(); // o
    myE.p(); // p
    

24. Guarde el documento de Flash y luego seleccione Control > Probar película para probar el archivo SWF.

    Aparecerán los valores 15, 12, o y p en el panel Salida. Estos son los valores devueltos por los métodos ClassE.k(), ClassE.n(), ClassE.o() y ClassE.p(). Dado que la clase ClassE implementa las interfaces InterfaceB e InterfaceC, deberá definirse cada método de los dos archivos de interfaz. Aunque las interfaces InterfaceB y InterfaceC sólo definen los métodos o() y p(), InterfaceC amplía InterfaceA. Esto significa que todos los métodos definidos que incluye, k() y n(), también deben implementarse.

Flash CS3

Enviarme un mensaje de correo electrónico cuando se añadan comentarios a esta página | Informe de comentarios

Página actual: http://livedocs.adobe.com/flash/9.0_es/main/00000834.html

Añadir comentario