Gränssnitt

Ett gränssnitt är en samling metoddeklarationer som tillåter att objekt som inte har med varandra att göra ändå kommunicerar med varandra. Gränssnittet IEventdispatcher definieras i ActionScript 3.0 och gränssnittet innehåller metoddeklarationer som kan användas av en klass för att hantera händelseobjekt. Med gränssnittet IEventDispatcher kan objekt skicka händelseobjekt mellan varandra på ett standardmässigt sätt. I följande kod visas definitionen av gränssnittet IEventDispatcher: 

public interface IEventDispatcher 
{ 
    function addEventListener(type:String, listener:Function,  
            useCapture:Boolean=false, priority:int=0, 
            useWeakReference:Boolean = false):void; 
    function removeEventListener(type:String, listener:Function,  
            useCapture:Boolean=false):void; 
    function dispatchEvent(event:Event):Boolean; 
    function hasEventListener(type:String):Boolean; 
    function willTrigger(type:String):Boolean; 
}

Gränssnitt baseras på skillnaden mellan en metods gränssnitt och dess implementering. En metods gränssnitt innehåller all information som krävs för att anropa den metoden, däribland metodens namn, parametrar och returtyp. En metods implementering innehåller gränssnittsinformation men också de körbara programsatser som utför metodens beteende. En gränssnittsdefinition innehåller bara metodgränssnitt och alla klasser som implementerar gränssnittet ansvarar för att definiera metodimplementeringarna.

I ActionScript 3.0 implementeras gränssnittet IEventDispatcher av klassen EventDispatcher genom att alla IEventDispatcher-gränssnittsmetoder definieras och metodbrödtexter läggs till i alla metoder. Följande kod är ett utdrag av definitionen för klassen EventDispatcher: 

public class EventDispatcher implements IEventDispatcher 
{ 
    function dispatchEvent(event:Event):Boolean 
    { 
        /* implementation statements */ 
    } 
 
    ... 
}

IEventDispatcher-gränssnittet fungerar som ett protokoll som används av EventDispatcher-förekomster för att bearbeta händelseobjekt och skicka dem till andra objekt som också har implementerat IEventDispatcher-gränssnittet.

Man kan också säga att ett gränssnitt definierar en datatyp på samma sätt som en klass gör. Därför kan ett gränssnitt, på samma sätt som en klass, användas som en typanteckning. Som en datatyp kan gränssnittet också användas med operatorer, till exempel is och as , som kräver en datatyp. I motsats till en klass kan ett gränssnitt inte instansieras. Den här skillnaden har gjort att många programmerare tänker sig gränssnitt som abstrakta datatyper och klasser som konkreta datatyper.

Definiera ett gränssnitt

En gränssnittsdefinitions struktur liknar en klassdefinitions struktur, förutom att gränssnittet bara kan innehålla metoder som saknar metodbrödtext. Gränssnitt kan inte innehålla variabler och konstanter, men kan innehålla get- och set-funktioner. Använd nyckelordet interface när du definierar ett gränssnitt. Gränssnittet IExternalizable är en del av paketet flash.utils i ActionScript 3.0. Med det här gränssnittet definieras ett protokoll som används för serialisering av ett objekt, vilket betyder konvertering av ett objekt till ett format som passar för lagring på en enhet eller för transport över ett nätverk. 

public interface IExternalizable 
{ 
    function writeExternal(output:IDataOutput):void; 
    function readExternal(input:IDataInput):void; 
}

Gränssnittet IExternalizable deklareras med åtkomstkontrollsmodifieringen public . Gränssnittsdefinitioner kan bara ändras med åtkomstkontrollsspecifikationerna public och internal . Metoddeklarationerna i en gränssnittsdefinition får inte ha några åtkomstkontrollsspecifikationer.

I ActionScript 3.0 används en standard där gränssnittsnamn börjar med ett versalt I , men du kan använda vilken tillåten identifierare som helst som gränssnittsnamn. Gränssnittsdefinitioner placeras ofta på den översta paketnivån. Gränssnittsdefinitioner får inte placeras i en klassdefinition eller i en annan gränssnittsdefinition.

Gränssnitt kan utöka ett eller flera andra gränssnitt. Gränssnittet IExample utökar till exempel gränssnittet IExternalizable: 

public interface IExample extends IExternalizable 
{ 
    function extra():void; 
}

Alla klasser som implementerar gränssnittet IExample måste innehålla implementeringar för metoden extra() men också för metoderna writeExternal() och readExternal() som ärvts från gränssnittet IExternalizable.

Implementera ett gränssnitt i en klass

En klass är det enda språkelementet i ActionScript 3.0 som kan implementera ett gränssnitt. Använd nyckelordet implements i en klassdeklaration för att implementera ett eller flera gränssnitt. I följande exempel definieras de två gränssnitten IAlpha och IBeta , samt klassen Alpha, som implementerar båda två: 

interface IAlpha 
{ 
    function foo(str:String):String; 
} 
 
interface IBeta 
{ 
    function bar():void; 
} 
 
class Alpha implements IAlpha, IBeta 
{ 
    public function foo(param:String):String {} 
    public function bar():void {} 
}

I en klass som implementerar ett gränssnitt måste följande göras av de implementerade metoderna:

  • Använda åtkomstkontrollsidentifieraren public .

  • Använda samma namn som gränssnittsmetoden.

  • Ha samma antal parametrar, var och en med datatyper som matchar gränssnittsmetodens parametrars datatyper.

  • Använda samma returtyp. 

    public function foo(param:String):String {}

Du kan vara ganska flexibel när det gäller namnet på parametrarna för de metoder du implementerar. Även om antalet parametrar och datatypen för varje parameter i den implementerade metoden måste matcha gränssnittsmetodens, behöver parameternamnet inte matcha. I föregående exempel har parametern för metoden Alpha.foo() fått namnet param :

Men parametern har namnet str i gränssnittsmetoden IAlpha.foo() : 

function foo(str:String):String;

Du kan också vara flexibel när det gäller standardparametervärden. En gränssnittsdefinition kan innehålla funktionsdeklarationer med standardparametervärden. En metod som implementerar en sådan funktionsdeklaration måste ha ett standardparametervärde som är medlem av samma datatyp som värdet som angetts i gränssnittsdefinitionen, men det verkliga värdet behöver inte matcha. I följande kod definieras ett gränssnitt som innehåller en metod som har standardparametervärdet 3: 

interface IGamma 
{ 
    function doSomething(param:int = 3):void; 
}

Följande klassdefinition implementerar gränssnittet IGamma, men använder ett annat standardparametervärde: 

class Gamma implements IGamma 
{ 
    public function doSomething(param:int = 4):void {} 
}

Orsaken till detta är att reglerna för implementering av ett gränssnitt utformats speciellt för att säkra datatypskompatibiliteten, och det är inte nödvändigt att parameternamn och standardparametervärden är identiska för att detta mål ska uppnås.