Herencia múltiple en ActionScript 3

Question

Herencia múltiple en ActionScript 3? ¿Es posible? He leído en alguna parte que es posible en as3.

Si sí, entonces, ¿cómo?

este es mi Doucument Clase A.as

package 
{ 
    import flash.display.MovieClip; 

    public class A extends MovieClip implements B 
    {  
     public var value1:Number=10; 

     public function A() 
     { 
      trace("A Class Constructor"); 
     } 
     public function hit():void 
     { 
      trace(value1+' from hit'); 
     } 
    } 
} 

Otra es interfaz B.as

package 
    { 
     public interface B 
     { 
      trace(' interface '); 
      function hit():void; 
     } 
    } 

Gracias de antemano.

Answer 1

La herencia múltiple no es posible en AS. Pero con las interfaces puede imitar algunas de las funciones de herencia múltiple. MI tiene defectos importantes, más notablemente el problema de diamantes: http://en.wikipedia.org/wiki/Diamond_problem Es por eso que muchas lenguas no son compatibles con MI, pero sólo herencia simple. El uso de interfaces "parece" que aplica MI, pero en realidad ese no es el caso dado que las interfaces no proporcionan una implementación, sino solo una promesa de funcionalidad.

interface BadAss{ 
    function doSomethingBadAss():void; 
} 

interface Preacher{ 
    function quoteBible():void; 
} 

class CrazyGangsta implements BadAss, Preacher{ 
    function quoteBible():void{ 
     trace("The path of the righteous man is beset on all sides by the inequities of the selfish and the tyranny of evil men."); 
    } 
    function doSomethingBadAss():void{ 
     //do something badass 
    } 
} 

var julesWinnfield : CrazyGangsta = new CrazyGangsta(); 
julesWinnfield.doSomethingBadAss(); 
julesWinnfield.quoteBible(); 

//however, it mimics MI, since you can do: 

var mofo : BadAss = julesWinnfield; 
mofo.doSomethingBadAss(); 
//but not mofo.quoteBible(); 

var holyMan : Preacher = julesWinnfield; 
holyMan.quoteBible(); 
//but not holyMan.doSomethingBadAss(); 

P.S .: En caso de que uno se pregunta: no hay ningún problema de diamante con interfaces desde un implementador de las interfaces debe proporcionar exactamente una aplicación de cada miembro se define en las interfaces. Por lo tanto, incluso si ambas interfaces definirían el mismo miembro (con una firma idéntica, por supuesto), todavía habrá una sola implementación.

Answer 2

Usted puede hacer la herencia múltiple utilizando la interfaz.

1. Defina las clases A, B y C. y defina la interfaz para la clase B y C respectivamente iB e iC.
2. Simplemente extiende la Clase C a la Clase A usando la palabra clave "extender" - Herencia directa de la clase
3. extiende su interfaz iC a la interfaz iB.

Just check code as per your requirement: 

package 
{ 
    import flash.display.MovieClip; 
    public class A extends MovieClip implements B 
    { 
     public var value1:Number=10; 
     public function A() 
     { 
      trace("A Class Constructor"); 
     } 
     public function hit():void 
     { 
      trace(value1+' from hit'); 
     } 
     public function print():void 
     { 
      trace("Print Method Called"); 
     } 
    } 
} 

package 
{ 
    public interface B extends D 
    { 
     function hit():void; 
    } 
} 

package 
{ 
    public class C implements D 
    { 
     pulic function C() 
     { 
      trace("C Class Constructor"); 
     } 
     public function print():void 
     { 
      trace("Print Method Called"); 
     } 
    } 
} 

package 
{ 
    public interface D 
    { 
     function print():void; 
    } 
} 

Answer 3

bien no hay posibilidad de herencia múltiple directamente en AS3 como muchos de otros lenguajes de POO.

programación orientada a objetos se trata de la reutilización de código y como la mayoría de nosotros queremos volver a utilizar el código escrito en varias clases. Así que si usted realmente quiere decir volver a utilizar el código (lógica) en lugar de sólo las firmas es posible que desee considerar composición o deligation enfoques y probablemente esto es lo que ha leído en alguna parte, como usted ha dicho.

En la composición de lo que haces es en lugar de heredar una clase base en la subclase, tendrá una instancia de la clase base en una subclase y tienen todos los métodos

package 
{ 
    public class BaseClass1 
    { 
     public function someMethod() 
     { 
      trace("This is from the BaseClass1"); 
     } 
    } 
} 

package 
{ 
    public class BaseClass2 
    { 
     public function anotherMethod() 
     { 
      trace("This is from the BaseClass2"); 
     } 
    } 
} 
package 
{ 
    //Composition 
    public class HasBase 
    { 
     private var baseClass1:BaseClass1; 
     private var baseClass2:BaseClass2; 
     public function HasBase() 
     { 
      baseClass1=new BaseClass1(); 
      baseClass2=new BaseClass2(); 
     } 
     public function someMethod() 
     { 
      baseClass1.someMethod(); 
     } 
     public function anotherMethod(){ 
      baseClass2.anotherMethod(); 
     } 
    } 
} 

Esto no es un truco, pero en realidad un verdadero y la implementación práctica adoptada por desarrolladores experimentados en muchos patrones de diseño.

Espero que esto ayude

Answer 4

Umm, chicos!

que usted puede mostrar dos formas diferentes de "imitar" la herencia múltiple:

1. Uso de la característica import: http://archive.darronschall.com/weblog/2006/10/multiple-inheritance-in-actionscript-3.html

2. no se olvide de que ActionScript es EcmaScript. Es todavía un lenguaje basado en prototipos: http://jolierouge.net/2010/01/as3-multiple-inheritancemixins/

sé ... no es "real" MI, pero look like a duck, speak like a duck...