I ActionScript 3.0 finns det fyra speciella attribut som styr åtkomsten till egenskaper som definierats inuti en klass: public, private, protected och internal.

Med attributet public blir en egenskap synlig överallt i skriptet. Om du vill att en metod ska vara tillgänglig för kod utanför paketet, måste du deklarera metoden med attributet public. Detta gäller för alla egenskaper, vare sig de deklarerats med nyckelordet var, const eller function.

Med attributet private blir en egenskap synlig bara för anropare i egenskapens definitionsklass. Detta skiljer sig från attributet private i ActionScript 2.0, som ger en underklass åtkomst till en privat egenskap i en superklass. En annan viktig skillnad gäller körningsåtkomst. I ActionScript 2.0 förhindrar nyckelordet private åtkomst bara vid kompileringen och kan lätt kringgås vid körningen. I ActionScript 3.0 gäller detta inte längre. Egenskaper som har markerats som privata är otillgängliga både vid kompilering och vid körning.

I följande kod skapas den enkla klassen PrivateExample med en privat variabel och därefter testas åtkomsten till den privata variabeln från klassens utsida.

class PrivateExample 
{ 
    private var privVar:String = "private variable"; 
} 
 
var myExample:PrivateExample = new PrivateExample(); 
trace(myExample.privVar);// compile-time error in strict mode 
trace(myExample["privVar"]); // ActionScript 2.0 allows access, but in ActionScript 3.0, this is a run-time error. 

I ActionScript 3.0 skapar ett försök att få åtkomst till en privat egenskap med hjälp av punktoperatorn (myExample.privVar) ett kompileringsfel om du använder strikt läge. I annat fall rapporteras felet vid körningen, på samma sätt som när du använder egenskapsåtkomstoperatorn (myExample["privVar"]).

I följande tabell sammanfattas resultatet av åtkomstförsök till en privat egenskap som hör till en fast (och inte en dynamisk) klass:

I klasser som deklarerats med attributet dynamic resulterar försök att komma åt en privat variabel inte i ett körningsfel. I stället är variabeln inte synlig, varför värdet undefined returneras. Ett kompileringsfel inträffar emellertid om du använder punktoperatorn i strikt läge. Följande exempel är detsamma som föregående exempel förutom att klassen PrivateExample deklarerats som en dynamisk klass:

dynamic class PrivateExample 
{ 
    private var privVar:String = "private variable"; 
} 
 
var myExample:PrivateExample = new PrivateExample(); 
trace(myExample.privVar);// compile-time error in strict mode 
trace(myExample["privVar"]); // output: undefined

Dynamiska klasser returnerar vanligtvis värdet undefined i stället för att generera ett fel när extern kod försöker komma åt en privat egenskap. I följande tabell visas att ett fel genereras bara när punktoperatorn används för att komma åt en privat egenskap i strikt läge:

Attributet protected, som är nytt för ActionScript 3.0, gör att en egenskap blir synlig för anropare i dess egen klass eller i en underklass. En skyddad egenskap är därför tillgänglig i sin egen klass eller i klasser som ligger någonstans under den i arvshierarkin. Detta gäller oavsett om underklassen är i samma paket eller i ett annat paket.

Om du är bekant med ActionScript 2.0 ser du att den här funktionen påminner om attributet private i ActionScript 2.0. Attributet protected i ActionScript 3.0 liknar även attributet protected i Java. Skillnaden är att Java-versionen även tillåter åtkomst till anropare inom samma paket. Använd attributet protected när du har en variabel eller metod som underklasserna behöver men som du vill dölja för kod som ligger utanför arvskedjan.

Attributet internal, som är nytt för ActionScript 3.0, gör att en egenskap blir synlig för anropare i dess eget paket. Det här är standardattributet för kod inuti ett paket och det tillämpas på alla egenskaper som inte har något av följande attribut:

• public

• private

• protected

• användardefinierat namnutrymme

Attributet internal liknar standardåtkomstkontrollen i Java, men i Java finns det inget explicit namn för den här åtkomstnivån och den kan bara uppnås om man utesluter alla andra åtkomstmodifierare. Attributet internal är tillgängligt i ActionScript 3.0 för att du ska kunna bekräfta att du vill att en egenskap bara ska vara synlig för anropare i egenskapens eget paket.

Med attributet static, som du använder med egenskaper som deklarerats med nyckelorden var, const eller function, kan du bifoga en egenskap till klassen i stället för till instanser av klassen. Kod som ligger utanför klassen måste anropa statiska egenskaper med hjälp av klassnamnet och inte med ett instansnamn.

Statiska egenskaper ärvs inte av underklasser, men egenskaperna är en del av underklassens omfångskedja. Detta betyder att en statisk variabel eller metod, i brödtexten till en underklass, kan användas utan att referera till klassen i vilken den har definierats.

Som ett alternativ till de fördefinierade åtkomstkontrollsattributen kan du skapa ett anpassat namnutrymme och använda det som ett attribut. Du kan bara använda ett namnutrymmesattribut per definition och du kan inte använda det i kombination med något av åtkomstkontrollsattributen (public, private, protected, internal).

Konstruktormetoder, som ibland kallas konstruktorer, är funktioner som har samma namn som den klass i vilken de har definierats. All kod som du inkluderar i en konstruktormetod körs när en instans av klassen skapas med nyckelordet new. I följande kod definieras en enkel klass som heter Example och som innehåller en enda egenskap som heter status. Det initiala värdet för variabeln status anges inuti konstruktorfunktionen.

class Example 
{ 
    public var status:String; 
    public function Example() 
    { 
        status = "initialized"; 
    } 
} 
 
var myExample:Example = new Example(); 
trace(myExample.status); // output: initialized

Konstruktormetoder kan bara vara allmänna, men användningen av attributet public är valfri. Du kan inte använda någon av de andra åtkomstkontrollsspecifikationerna, däribland private, protected och internal, på en konstruktor. Du kan inte heller använda ett användardefinierat namnutrymme med en konstruktormetod.

En konstruktor kan anropa konstruktorn för sin direkta superklass med hjälp av programsatsen super(). Om superklasskonstruktorn inte explicit anropas infogar kompilatorn automatiskt ett anrop före den första programsatsen i konstruktorbrödtexten. Du kan också anropa superklassens metoder med hjälp av prefixet super som en referens till superklassen. Om du använder både super() och super i samma konstruktorbrödtext måste du först anropa super(). Annars beter referensen super sig på ett oväntat sätt. Konstruktorn super() måste också anropas före en throw- eller return-programsats.

I följande exempel visas vad som händer om du försöker använda referensen super innan du anropar konstruktorn super(). Den nya klassen ExampleEx utökar klassen Example. Konstruktorn ExampleEx försöker komma åt statusvariabeln som definierats i superklassen, men detta sker innan den anropar super(). Programsatsen trace() i konstruktorn ExampleEx skapar värdet null eftersom variabeln status inte är tillgänglig förrän konstruktorn super() körs.

class ExampleEx extends Example 
{ 
    public function ExampleEx() 
    { 
        trace(super.status); 
        super(); 
    } 
} 
 
var mySample:ExampleEx = new ExampleEx(); // output: null

Även om det är tillåtet att använda programsatsen return inuti en konstruktor är det inte tillåtet att returnera ett värde. return-programsatser får alltså inte ha kopplade uttryck eller värden. Konstruktormetoder kan följaktligen inte ha returvärden, vilket betyder att ingen returtyp kan anges.

Om du inte definierar en konstruktormetod i klassen skapas en tom konstruktor automatiskt. Om klassen utökar en annan klass infogas ett super()-anrop i den konstruktor som genereras.

Statiska metoder, som också kallas klassmetoder, är metoder som deklareras med nyckelordet static. Använd statiska metoder, som bifogas till en klass och inte till en instans av en klass, när du kapslar in funktioner som påverkar något annat än en individuell instans läge. Eftersom statiska metoder bifogas till en klass som en helhet, kan de bara nås via en klass och inte via en instans av klassen.

Använd statiska metoder för att kapsla in funktioner som inte begränsas till att påverka läget för en klassinstans. En metod måste alltså vara statisk om den tillhandahåller funktioner som inte direkt påverkar värdet för en klassinstans. Klassen Date har till exempel en statisk metod som heter parse(), som tar en sträng och konverterar den till ett tal. Metoden är statisk eftersom den inte påverkar en individuell instans av klassen. I stället tar metoden parse() en sträng som representerar ett datumvärde, tolkar strängen och returnerar ett tal i ett format som är kompatibelt med den interna representationen av ett Date-objekt. Metoden är inte en instansmetod eftersom det inte är lämpligt att använda metoden på en instans av klassen Date.

Jämför metoden parse() med en av instansmetoderna för klassen Date, till exempel getMonth(). Metoden getMonth() är en instansmetod eftersom den arbetar direkt på värdet för en instans genom att hämta en speciell komponent, månaden, för en Date-instans.

Eftersom statiska metoder inte är bundna till individuella instanser, kan du inte använda nyckelorden this och super i brödtexten för en statisk metod. Referenserna this och super är bara meningsfulla i samband med en instansmetod.

Statiska metoder i ActionScript 3.0 ärvs inte till skillnad från vissa andra klassbaserade programmeringsspråk.

Instansmetoder är metoder som deklareras utan nyckelordet static. Du kan använda instansmetoder som bifogas till instanser av en klass i stället för till klassen som helhet för att implementera funktioner som påverkar individuella instanser av en klass. Klassen Array innehåller till exempel en instansmetod som heter sort() som arbetar direkt på Array-instanser.

I en instansmetods brödtext finns både statiska variabler och instansvariabler i omfång, vilket betyder att variabler som definierats i samma klass kan refereras med en enkel identifierare. Klassen CustomArray utökar till exempel klassen Array. Klassen CustomArray definierar en statisk variabel som heter arrayCountTotal som spårar antalet klassinstanser, en instansvariabel som heter arrayNumber som spårar den ordning i vilken instanserna skapats samt en instansmetod som heter getPosition() som returnerar värdena för dessa variabler.

public class CustomArray extends Array 
{ 
    public static var arrayCountTotal:int = 0; 
    public var arrayNumber:int; 
 
    public function CustomArray() 
    { 
        arrayNumber = ++arrayCountTotal; 
    } 
     
    public function getArrayPosition():String 
    { 
         return ("Array " + arrayNumber + " of " + arrayCountTotal); 
    } 
}

Även om kod som ligger utanför klassen måste komma åt den statiska variabeln arrayCountTotal via klassobjektet med hjälp av CustomArray.arrayCountTotal, så kan kod som ligger i brödtexten för metoden getPosition() referera direkt till den statiska variabeln arrayCountTotal. Detta gäller även för statiska variabler i superklasser. Trots att statiska egenskaper inte ärvs i ActionScript 3.0, placeras statiska egenskaper i superklasser i omfång. Klassen Array har till exempel några få statiska variabler, varav en är en konstant som heter DESCENDING. Kod som finns i en Array-underklass kan komma åt den statiska konstanten DESCENDING med hjälp av en enkel identifierare:

public class CustomArray extends Array 
{ 
    public function testStatic():void 
    { 
        trace(DESCENDING); // output: 2 
    } 
}

Värdet för referensen this i brödtexten för en instansmetod är en referens till instansen som metoden är bifogad till. I följande kod visas att referensen this pekar på instansen som innehåller metoden:

class ThisTest 
{ 
    function thisValue():ThisTest 
    { 
        return this; 
    } 
} 
 
var myTest:ThisTest = new ThisTest(); 
trace(myTest.thisValue() == myTest); // output: true

Arv av instansmetoder kan kontrolleras med nyckelorden override och final. Du kan använda attributet override för att omdefiniera en ärvd metod och attributet final för att förhindra att underklasser åsidosätter en metod.

Med åtkomstfunktionerna get och set, som också kallas get- och set-metoder, kan du anpassa dig till programmeringsprinciperna för dold och kapslad information medan du samtidigt tillhandahåller ett enkelt programmeringsgränssnitt för de klasser du skapar. Med get- och set-metoderna blir klassegenskaperna privata för klassen, men användarna av klassen kan komma åt dessa egenskaper på samma sätt som om de kommer åt en klassvariabel i stället för att anropa en klassmetod.

Fördelen med detta är att du slipper de traditionella åtkomstfunktionerna med otympliga namn, till exempel getPropertyName() och setPropertyName(). En annan fördel med get och set är att du slipper ha två allmänna funktioner för varje egenskap som tillåter både läs- och skrivåtkomst.

Följande exempelklass GetSet innehåller get- och set-åtkomstfunktionerna som heter publicAccess() som ger åtkomst till den privata variabeln privateProperty:

class GetSet 
{ 
    private var privateProperty:String; 
     
    public function get publicAccess():String 
    { 
        return privateProperty; 
    } 
     
    public function set publicAccess(setValue:String):void 
    { 
        privateProperty = setValue; 
    } 
}

Om du försöker komma åt egenskapen privateProperty direkt returneras ett fel:

var myGetSet:GetSet = new GetSet(); 
trace(myGetSet.privateProperty); // error occurs

I stället får användaren av klassen GetSet använda något som ser ut att vara egenskapen publicAccess, men som i själva verket är ett par get- och set-åtkomstfunktioner för den privata egenskapen privateProperty. I följande exempel instansieras klassen GetSet och här anges värdet för privateProperty med hjälp av den allmänna åtkomstfunktionen publicAccess:

var myGetSet:GetSet = new GetSet(); 
trace(myGetSet.publicAccess); // output: null 
myGetSet.publicAccess = "hello"; 
trace(myGetSet.publicAccess); // output: hello

Med get- och set-funktionerna kan du också åsidosätta egenskaper som ärvs från en superklass, vilket inte är möjligt när du använder vanliga klassmedlemsvariabler. Klassmedlemsvariabler som deklarerats med nyckelordet var kan inte åsidosättas i en underklass. Egenskaper som har skapats med get- och set-funktioner har inte den här begränsningen. Du kan använda attributet override på get- och set-funktioner som ärvts från en superklass.

En bunden metod, som ibland kallas ett metodslut, är en metod som extraheras från sin instans. Bundna metoder är metoder som skickats som argument till en funktion eller som returnerats som värden från en funktion. Bundna metoder är en nyhet i ActionScript 3.0 och funktionen liknar ett funktionsslut på det sättet att den sparar sin lexikala miljö även när den extraheras från sin instans. Den största skillnaden mellan en bunden metod och ett funktionsslut är att referensen this för en bunden metod förblir länkad, eller bunden, till instansen som implementerar metoden. Referensen this i en bunden metod pekar alltså alltid på det ursprungliga objektet som implementerat metoden. När det gäller funktionsslut är referensen this generisk, vilket betyder att den pekar på det objekt som funktionen är kopplad till vid den tidpunkt den anropas.

Om du använder nyckelordet this måste du veta hur bundna metoder fungerar. Kom ihåg att nyckelordet this skapar en referens till en metods överordnade objekt. De flesta ActionScript-programmerare förväntar sig att nyckelordet this alltid representerar det objekt eller den klass som innehåller definitionen för en metod. Utan metodbindning stämmer det här inte alltid. I tidigare versioner av ActionScript refererar referensen this inte alltid till instansen som implementerat metoden. Om metoder extraheras från en instans i ActionScript 2.0 är referensen this inte bunden till ursprungsinstansen och medlemsvariablerna och metoderna för instansens klass är dessutom inte tillgängliga. Detta är inget problem i ActionScript 3.0 eftersom bundna metoder automatiskt skapas när du skickar en metod som parameter. Med bundna metoder kommer nyckelordet this alltid att referera till det objekt eller den klass som en metod är definierad i.

I följande kod definieras klassen ThisTest som innehåller metoden foo() som definierar den bundna metoden, och metoden bar() som returnerar den bundna metoden. Kod som ligger utanför klassen skapar en instans av klassen ThisTest, anropar metoden bar() och lagrar returvärdet i variabeln myFunc.

class ThisTest 
{ 
    private var num:Number = 3; 
    function foo():void // bound method defined 
    { 
        trace("foo's this: " + this); 
        trace("num: " + num); 
    } 
    function bar():Function 
    { 
        return foo; // bound method returned 
    } 
} 
 
var myTest:ThisTest = new ThisTest(); 
var myFunc:Function = myTest.bar(); 
trace(this); // output: [object global] 
myFunc(); 
/* output:  
foo's this: [object ThisTest] 
output: num: 3 */

De sista två kodraderna visar att referensen this i den bundna metoden foo() fortfarande pekar på en instans av klassen ThisTest, även om referensen this på raden före pekar på det globala objektet. Den bundna metoden som lagrats i variabeln myFunc har dessutom fortfarande åtkomst till medlemsvariablerna i klassen ThisTest. Om samma kod körs i ActionScript 2.0 kommer referensen this att matcha och variabeln num kommer att bli undefined.

Om du lägger till bundna metoder med händelsehanterare märks det mest eftersom metoden addEventListener() kräver att du skickar en funktion eller metod som ett argument.

Om du vill bädda in en resurs placerar du först resursen i en FLA-fils bibliotek. Därefter använder du resursens länkningsegenskap för att ge resursens inbäddade klass ett namn. Om det inte finns någon klass med detta namn i klassökvägen genereras en klass automatiskt. Därefter kan du skapa en instans av den inbäddade resursklassen och använda alla egenskaperna och metoderna som definierats eller ärvts av denna klass. Följande kod kan till exempel användas för att spela upp ett inbäddat ljud som är länkat till en inbäddad resursklass som heter PianoMusic:

var piano:PianoMusic = new PianoMusic(); 
var sndChannel:SoundChannel = piano.play();

Du kan också använda metadatataggen [Embed] för att bädda in resurser i ett Flash Professional-projekt, vilket beskrivs nedan. Om du använder metadatataggen [Embed] i koden används Flex-kompilatorn för att kompilera projektet i stället för Flash Professional-kompilatorn.

Om du kompilerar koden med Flex-kompilatorn och vill bädda in en resurs i ActionScript-koden använder du metadatataggen [Embed]. Placera resursen i huvudkällmappen eller i en annan mapp som finns i projektets byggsökväg. När Flex-kompilatorn påträffar en Embed-metadatatagg skapas den inbäddade resursklassen. Du får tillgång till klassen via en variabel av datatypen Class som du deklarerar omedelbart efter [Embed]-metadatataggen. I följande kod bäddas ett ljud med namnet sound1.mp3 in och en variabel med namnet soundCls används för att lagra en referens till den inbäddade resursklassen som hör till ljudet. I exemplet skapas sedan en instans av den inbäddade resursklassen och metoden play() anropas för den instansen:

package 
{ 
    import flash.display.Sprite; 
    import flash.media.SoundChannel; 
    import mx.core.SoundAsset; 
 
    public class SoundAssetExample extends Sprite 
    { 
        [Embed(source="sound1.mp3")] 
        public var soundCls:Class; 
         
        public function SoundAssetExample() 
        { 
            var mySound:SoundAsset = new soundCls() as SoundAsset; 
            var sndChannel:SoundChannel = mySound.play(); 
        } 
    } 
}