Wiele dziedziczenia w ActionScript 3

Question

Wiele dziedziczenia w ActionScript 3? Czy to możliwe? Czytałem gdzieś, że jest to możliwe w as3.

Jeśli tak, to w jaki sposób?

to moja Doucument Klasa 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'); 
     } 
    } 
} 

Innym jest sprzęgowi B.as

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

góry dzięki.

Answer 1

Wielokrotne dziedziczenie nie jest możliwe w systemie AS. Ale dzięki interfejsom można naśladować niektóre funkcje dziedziczenia wielokrotnego. MI ma poważne wady, w szczególności problem z diamentem: http://en.wikipedia.org/wiki/Diamond_problem Dlatego wiele języków nie obsługuje MI, ale tylko pojedyncze dziedziczenie. Używając interfejsów "pojawia się", stosujesz MI, ale w rzeczywistości tak nie jest, ponieważ interfejsy nie zapewniają implementacji, ale tylko obietnicę funkcjonalności.

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 .: W przypadku chcesz się zastanawiać: Nie ma problemu romb z interfejsów Ponieważ implementor interfejsów musi dostarczyć dokładnie jedną realizację każdego członka określonej w interfejsach. Tak więc, nawet jeśli oba interfejsy będą definiować tego samego członka (z identycznym podpisem oczywiście), nadal będzie tylko jedna implementacja.

Answer 2

Możesz dokonać dziedziczenia wielokrotnego za pomocą interfejsu.

1. Należy zdefiniować klasy A, B i C. oraz zdefiniować interfejs dla klasy B i C odpowiednio iB i iC.
2. Po prostu rozszerza klasę C na klasę A za pomocą słowa kluczowego "extend" - Direct Inheritance klasy
3. rozszerza interfejs iC na interfejs 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

Więc nie ma możliwości wielokrotnego dziedziczenia bezpośrednio w AS3 podobnie jak wiele innych języków OOP.

OOP polega na ponownym użyciu kodu i podobnie jak większość z nas chce ponownie użyć kodu napisanego w wielu klasach. Więc jeśli naprawdę chcesz ponownie użyć kodu (logiki) zamiast tylko podpisów, możesz rozważyć podejście składanie lub deligowanie i prawdopodobnie to jest to, co gdzieś przeczytałeś, tak jak powiedziałeś.

W składzie co musisz zrobić, to zamiast dziedziczy klasy bazowej do podklasy, trzeba będzie instancją klasy bazowej w podklasie i mają wszystkie metody

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

To nie jest hack ale faktycznie prawdziwa i praktyczną implementację przyjętą przez doświadczonych programistów w wielu wzorcach projektowych.

Mam nadzieję, że to pomoże

Answer 4

Umm, chłopaki!

mogę pokazać dwa różne sposoby "naśladować" wielokrotne dziedziczenie:

1. użyciu funkcji #import: http://archive.darronschall.com/weblog/2006/10/multiple-inheritance-in-actionscript-3.html

2. nie zapominaj, że ActionScript jest ECMAScript. To wciąż język oparty prototype: http://jolierouge.net/2010/01/as3-multiple-inheritancemixins/

... nie wiem „prawdziwy” MI, ale look like a duck, speak like a duck...