Ereditarietà multipla in ActionScript 3

Question

Ereditarietà multipla in ActionScript 3? È possibile? Ho letto da qualche parte che è possibile in as3.

Se sì, allora come?

questo è il mio Doucument Classe 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'); 
     } 
    } 
} 

Un altro è interfaccia B.as

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

Grazie in anticipo.

Answer 1

L'ereditarietà multipla non è possibile in AS. Ma con le interfacce è possibile imitare alcune delle funzionalità di ereditarietà multipla. MI ha grandi difetti, in particolare il problema dei diamanti: http://en.wikipedia.org/wiki/Diamond_problem Ecco perché molte lingue non supportano l'MI, ma solo l'ereditarietà singola. Utilizzando le interfacce "appare" si applica MI, ma in realtà non è il caso poiché le interfacce non forniscono un'implementazione, ma solo una promessa di funzionalità.

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 .: Nel caso in cui ci si domandi: non c'è nessun problema di diamanti con interfacce in quanto un implementor delle interfacce deve fornire esattamente un'implementazione di ciascun membro definito nelle interfacce. Quindi, anche se entrambe le interfacce definissero lo stesso membro (con la stessa firma ovviamente), ci sarà ancora una sola implementazione.

Answer 2

È possibile eseguire l'ereditarietà multipla tramite l'interfaccia.

1. Definire le classi A, B e C. e definire l'interfaccia per la classe B e C rispettivamente iB e iC.
2. Estende semplicemente la classe C alla classe A utilizzando la parola chiave "estendere" - Eredità diretta della classe
3. estende l'interfaccia iC all'interfaccia 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

Beh non v'è alcuna possibilità di ereditarietà multipla direttamente in AS3 come molti altri linguaggi OOP.

OOP riguarda il riutilizzo del codice e come la maggior parte di noi desidera riutilizzare il codice scritto in più classi. Quindi, se vuoi davvero riutilizzare il codice (logica) invece delle sole firme, potresti considerare la composizione composizione o deligation e probabilmente questo è ciò che hai letto da qualche parte, come hai detto tu.

in Composizione quello che fai è invece di ereditare un baseclass nella sottoclasse, si avrà un'istanza dei baseclass in una sottoclasse e hanno tutti i metodi

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(); 
     } 
    } 
} 

Questo non è un trucco, ma in realtà un vero e proprio e implementazione pratica adottata da sviluppatori esperti in molti modelli di progettazione.

Spero che questo aiuti

Answer 4

Umm, ragazzi!

posso mostrarvi due modi diversi di "mimare" l'ereditarietà multipla:

1. Utilizzando la funzione #import: http://archive.darronschall.com/weblog/2006/10/multiple-inheritance-in-actionscript-3.html

2. non dimenticate che ActionScript è EcmaScript. E 'ancora un linguaggio basato prototipo: http://jolierouge.net/2010/01/as3-multiple-inheritancemixins/

lo so ... non è "reale" MI, ma look like a duck, speak like a duck...