Sınıflar

ActionScript 3.0, bir sınıf içinde tanımlanmış özelliklere erişimi denetleyen dört özel nitelik sağlar: public , private , protected ve internal .

public niteliği, bir özelliği komut dosyanızın her yerinde görülebilir duruma getirir. Örneğin, bir yöntemi kendi paketinin dışındaki kodlar için kullanılabilir duruma getirmek üzere, yöntemi public niteliğiyle bildirmeniz gerekir. var , const veya function anahtar sözcükleriyle bildirilmiş tüm özellikler için bu geçerlidir.

private niteliği, bir özelliğin yalnızca özelliğin tanımlayan sınıfı içindeki çağıranlar tarafından görülebilmesini sağlar. Bu davranış, alt sınıfın bir üst sınıftaki özel özelliğine erişmesine olanak sağlayan, ActionScript 2.0'daki private niteliğinin davranışından farklıdır. Davranıştaki başka bir önemli değişiklik de çalışma zamanı erişimiyle ilgilidir. ActionScript 2.0'da, private anahtar sözcüğü yalnızca derleme zamanında erişimi yasaklarken çalışma zamanında kolayca atlatılabilirdi. ActionScript 3.0'da ise artık bu durum geçerli değildir. private olarak işaretlenmiş özellikler, derleme zamanında da çalışma zamanında da kullanılamaz.

Örneğin, aşağıdaki kod, tek bir değişkenle PrivateExample adında basit bir sınıf oluşturur ve sonra sınıfın dışından özel değişkene erişmeyi dener.

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. 

ActionScript 3.0'da ise, katı mod kullanıyorsanız, nokta operatörü ( myExample.privVar ) kullanılarak bir özel özelliğe erişme girişimi, derleme zamanı hatasına yol açar. Aksi takdirde, özellik erişimi operatörü ( myExample["privVar"] ) kullandığınızda olduğu gibi, çalışma zamanında hata bildirilir.

Aşağıdaki tabloda, mühürlenmiş (dinamik olmayan) bir sınıfa ait özel özelliğe erişme girişiminin sonuçları özetlenmektedir:

dynamic niteliğiyle bildirilen sınıflarda, özel bir değişkene erişme girişimi, çalışma zamanı hatasına yol açmaz. Bunun yerine, değişken görünür değildir, bu yüzden undefined değeri geri döndürülür. Ancak katı modda nokta operatörünü kullanırsanız derleme zamanı hatası oluşur. Aşağıdaki örnek, önceki örnekle aynıdır; tek farkı, PrivateExample sınıfının bir dinamik sınıf olarak bildirilmesidir:

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

Dinamik sınıflar genellikle, bir sınıf için harici olan bir kod, özel bir özelliğe erişme girişiminde bulunduğunda hata oluşturmak yerine undefined değerini döndürür. Aşağıdaki tabloda, yalnızca katı modda özel bir özelliğe erişmek için nokta operatörü kullanıldığında bir hata oluşturulduğu gösterilir:

ActionScript 3.0'da ilk defa sunulan protected niteliği, bir özelliği kendi sınıfı veya alt sınıfı içindeki çağıranlar tarafından görülebilir duruma getirir. Başka bir deyişle, protected özelliği kendi sınıfı içinde kullanılabilir veya miras hiyerarşisinde kendisinin aşağısında bulunan sınıflar için kullanılabilir durumdadır. Alt sınıf aynı pakette veya farklı bir pakette de olsa bu durum geçerlidir.

ActionSctipt 2.0'ı bilenler için bu işlevsellik, ActionScript 2.0'daki private niteliğine benzerdir. ActionScript 3.0 protected niteliği de Java'daki protected niteliğine benzerdir. Java sürümünün ayrıca aynı paket içindeki çağıranlara izin vermesi açısından fark gösterir. protected niteliği, alt sınıfınız için gerekli olan ancak miras zincirinin dışındaki kodlardan gizlemek istediğiniz bir değişken veya yönteminiz olduğunda kullanışlıdır.

ActionScript 3.0'da yeni olan internal niteliği, bir özelliğin kendi paketi içindeki çağıranlar tarafından görülebilir olmasını sağlar. Bu, bir paket içindeki kod için varsayılan nitelik olup aşağıdaki niteliklerden herhangi birine sahip olmayan tüm özellikler için geçerlidir:

• public

• private

• protected

• kullanıcı tanımlı bir ad alanı

Java'da bu erişim düzeyi için açıkça bir ad olmayıp yalnızca başka bir erişim değiştiricisinin çıkarılmasıyla bu erişim düzeyi elde edilebilse de, internal niteliği, Java'daki varsayılan erişim denetimine benzer. internal niteliği, özelliği yalnızca kendi paketi içindeki çağıranlar tarafından görülebilir duruma getirme amacınızı açıkça belirtme seçeneğini size sunar.

var , const veya function anahtar sözcükleriyle bildirilmiş özelliklerle kullanılabilen static niteliği, bir özelliği sınıfın örneklerine değil, sınıfa eklemenize olanak sağlar. Sınıf için harici olan kodun, örnek adı yerine sınıf adını kullanarak statik özellikleri çağırması gerekir.

Statik özellikler alt sınıflar tarafından miras alınmaz ancak özellikler, alt sınıfın kapsam zincirinin parçasıdır. Başka bir deyişle, alt sınıfın gövdesi içinde, statik bir değişken veya yöntem tanımlanmış olduğu sınıfa başvurulmadan kullanılabilir.

Önceden tanımlanmış erişim denetimi niteliklerine alternatif olarak, bir nitelik olarak kullanılmak üzere özel bir ad alanı oluşturabilirsiniz. Her tanım için yalnızca bir ad alanı niteliği kullanılabilir ve ad alanı niteliğini, erişim denetimi niteliklerinden herhangi biriyle ( public , private , protected , internal ) birlikte kullanamazsınız.

Bazen yapıcılar olarak da adlandırılan yapıcı yöntemleri, tanımlandıkları sınıfla aynı adı paylaşan işlevlerdir. new anahtar sözcüğüyle sınıfın bir örneği her oluşturulduğunda, yapıcı yöntemine dahil ettiğiniz kodlar çalıştırılır. Örneğin, aşağıdaki kod, status adında tek bir özellik içeren Example adında basit bir sınıfı tanımlar. status değişkeninin başlangıç değeri, yapıcı işlevinin içinde ayarlanır.

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

Yapıcı yöntemleri yalnızca genel olabilir ancak public niteliğinin kullanılması isteğe bağlıdır Bir yapıcıda private , protected veya internal gibi diğer erişim denetimi belirticilerinden herhangi birini kullanamazsınız. Ayrıca yapıcı yöntemiyle kullanıcı tanımlı bir ad alanı da kullanamazsınız.

Yapıcı, super() deyimini kullanarak doğrudan üst sınıfının yapıcısına açıkça bir çağrı yapabilir. Üst sınıf yapıcısı açıkça çağrılmazsa, derleyici otomatik olarak yapıcı gövdesindeki birinci deyimin önüne bir çağrı ekler. Üst sınıfın başvurusu olarak super önekini kullanarak da üst sınıf yöntemlerini çağırabilirsiniz. Aynı yapıcı gövdesinde hem super() hem de super öğesini kullanmaya karar verirseniz, ilk olarak super() öğesini çağırdığınızdan emin olun. Aksi takdirde, super başvurusu beklendiği gibi davranmaz. super() yapıcısının ayrıca throw veya return deyiminden önce çağrılması gerekir.

Aşağıdaki örnek, super() yapıcısını çağırmadan önce super başvurusunu kullanmaya çalışmanız durumunda ne olacağını gösterir. Yeni bir sınıf olan ExampleEx, Example sınıfını genişletir. ExampleEx yapıcısı, üst sınıfında tanımlanmış durum değişkenine erişmeye çalışır ancak bunu super() öğesini çağırmadan önce yapar. super() yapıcısı çalıştırılıncaya kadar status değişkeni kullanılamadığından, ExampleEx yapıcısının içindeki trace() deyimi, null değerini üretir.

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

Yapıcı içinde return deyiminin kullanılması geçerli bir durum olsa da, bir değer döndürülmesine izin verilmez. Başka bir deyişle, return deyimlerinin ilişkilendirilmiş ifadeler veya değerler içermemesi gerekir. Aynı şekilde, yapıcı yöntemlerinin değer döndürmesine izin verilmez, başka bir deyişle, herhangi bir döndürme türü belirtilemez.

Sınıfınızda bir yapıcı yöntemi tanımlamazsanız, derleyici otomatik olarak sizin için boş bir yapıcı oluşturur. Sınıfınız başka bir sınıfı genişletirse, derleyici oluşturduğu yapıcıya bir super() çağrısı ekler.

Sınıf yöntemleri olarak da adlandırılan statik yöntemler, static anahtar sözcüğüyle bildirilen yöntemlerdir. Sınıfın örneğine değil, sınıfa eklenen statik yöntemler, tek bir örneğin durumu dışındaki şeyleri etkileyen işlevlerin kapsüllenmesinde kullanışlıdır. Statik yöntemler bir bütün olarak sınıfa eklendiğinden, statik yöntemlere sınıfın örneği üzerinden değil yalnızca sınıf üzerinden erişilebilir.

Statik yöntemler, sınıf örneklerinin durumunu etkilemekle sınırlı olmayan işlevlerin kapsüllenmesinde kullanışlıdır. Başka bir deyişle, bir yöntem sınıf örneğinin değerini doğrudan etkilemeyen işlevler sağlıyorsa statik olmalıdır. Örneğin, Date sınıfı, bir dizeyi alıp sayıya dönüştüren parse() adındaki bir statik yönteme sahiptir. Bu yöntem sınıfın tek bir örneğini etkilemediğinden statiktir. parse() yöntemi bir tarih değerini temsil eden dizeyi alır, dizeyi ayrıştırır ve Date nesnesinin dahili temsiliyle uyumlu bir biçimde sayıyı döndürür. Date sınıfının bir örneğine yöntemin uygulanması mantıklı olmadığından, bu yöntem bir örnek yöntemi değildir.

Statik parse() yöntemini, getMonth() gibi Date sınıfının örnek yöntemlerinden biriyle karşılaştırın. getMonth() yöntemi, Date örneğinin belirli bir bileşenini (ay) alarak doğrudan örneğin değeri üzerinde çalıştığından, bir örnek yöntemidir.

Statik yöntemler tek tek örneklere bağımlı olmadığından, statik yöntemin gövdesinde this veya super anahtar sözcüklerini kullanamazsınız. this başvurusu ve super başvurusu yalnızca bir örnek yönteminin bağlamında anlam içerir.

Bazı sınıf tabanlı programlama dillerinin aksine, ActionScript 3.0'da statik yöntemler miras alınmaz.

Örnek yöntemleri, static anahtar sözcüğü olmadan bildirilen yöntemlerdir. Bütün olarak sınıfa değil, sınıfın örneklerine eklenen örnek yöntemleri, sınıfın tek tek örneklerini etkileyen işlevlerin uygulanmasında kullanışlıdır. Örneğin, Array sınıfı, doğrudan Array örneklerinde çalışan sort() adında bir örnek yöntemi içerir.

Örnek yönteminin gövdesinde statik değişkenler ve örnek değişkenleri kapsam içinde bulunur, başka bir deyişle, aynı sınıfta tanımlanmış değişkenlere, basit bir tanımlayıcı kullanılarak başvurulabilir. Örneğin, şu sınıf (CustomArray) Array sınıfını genişletir. CustomArray sınıfı, sınıf örneklerinin toplam sayısını izlemek için arrayCountTotal adındaki bir statik değişkeni, örneklerin oluşturulma sırasını izleyen arrayNumber adındaki bir örnek değişkenini ve bu değişkenlerin değerlerini döndüren getPosition() adındaki bir örnek yöntemini tanımlar.

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

Sınıfa harici olan kodun CustomArray.arrayCountTotal öğesini kullanarak sınıf nesnesi üzerinden arrayCountTotal statik değişkenine erişmesi gerekse de, getPosition() yönteminin gövdesinde bulunan kod, doğrudan arrayCountTotal değişkenini ifade edebilir. Üst sınıflardaki statik değişkenler için de bu geçerlidir. Statik özellikler ActionScript 3.0'da miras alınmasa da, üst sınıflardaki statik özellikler kapsam içindedir. Örneğin, Array sınıfı, bir tanesi DESCENDING olarak adlandırılan birkaç statik değişkene sahiptir. Array alt sınıfında bulunan kod, basit bir tanımlayıcı kullanarak DESCENDING statik sabitine erişebilir:

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

Bir örnek yönteminin gövdesindeki this başvurusunun değeri, yöntemin eklendiği örneğin başvurusudur. Aşağıdaki kod, this başvurusunun yöntemi içeren örneği işaret ettiğini gösterir:

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

Örnek yöntemlerinin mirası, override ve final anahtar sözcükleriyle denetlenebilir. Miras alınan bir yöntemi yeniden tanımlamak için override niteliğini ve alt sınıfların bir yöntemi geçersiz kılmasını önlemek için final niteliğini kullanabilirsiniz.

Alıcılar ve ayarlayıcılar olarak da adlandırılan alma ve ayarlama erişimci işlevleri, oluşturduğunuz sınıflar için kullanımı kolay bir programlama arabirimi sağlarken, bilgi gizleme ve kapsüllemeye yönelik programlama ilkelerine da bağlı kalmanıza olanak sağlar. Alma ve ayarlama işlevleri, sınıf özelliklerinizin sınıf için özel olmasını sürdürmenizi ancak sınıfınızın kullanıcılarının bir sınıf yöntemi çağırmak yerine bir sınıf değişkenine erişiyormuş gibi bu özelliklere erişmesine olanak sağlar.

Bu yaklaşımın avantajı, getPropertyName() ve setPropertyName() gibi kullanılması güç adlara sahip geleneksel erişimci işlevlerinden kaçınmanıza olanak sağlamasıdır. Alıcı ve ayarlayıcıların başka bir avantajı da, hem okuma hem de yazma erişimine izin veren her özellik için genele açık iki işlevden kaçınabilmenizi sağlamasıdır.

GetSet adındaki şu örnek sınıf, privateProperty adındaki özel değişkene erişim sağlayan publicAccess() adında alma ve ayarlama erişimci işlevlerini içerir:

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

privateProperty özelliğine doğrudan erişmeyi denerseniz, aşağıdaki gibi bir hata oluşur:

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

Bunun yerine, GetSet sınıfının kullanıcısı, publicAccess adında bir özellik olarak görünen ancak gerçekte privateProperty adındaki özel özellikte çalışan bir alma ve ayarlama erişimcisi işlevleri çifti olan bir öğeyi kullanır. Aşağıdaki örnek, GetSet sınıfını başlatır ve sonra publicAccess adındaki genel erişimciyi kullanarak privateProperty değerini ayarlar:

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

Alıcı ve ayarlayıcı işlevleri, normal sınıf üyesi değişkenleri kullandığınız zaman mümkün olmayacak şekilde, bir üst sınıftan miras alınan özellikleri geçersiz kılmanıza olanak sağlar. var anahtar sözcüğü kullanılarak bildirilen sınıf üyesi değişkenleri, bir alt sınıfta geçersiz kılınamaz. Alıcı ve ayarlayıcı işlevleri kullanılarak oluşturulan özelliklerse bu kısıtlamaya sahip değildir. Bir üst sınıftan miras alınan alıcı ve ayarlayıcı işlevlerinde override niteliğini kullanabilirsiniz.

Bazen yöntem kapanışı olarak da adlandırılan bir bağımlı yöntem, yalnızca örneğinden ayıklanmış bir yöntemdir. Bağımlı yöntem örnekleri arasında, bir işleve argüman olarak iletilen veya bir işlevden değer olarak döndürülen yöntemler yer alır. ActionScript 3.0'da yeni bir özellik olan bağımlı yöntem, kendi örneğinden ayıklandığında da sözlü ortamını koruduğundan bir işlev kapanışına benzer. Bağımlı yöntem ile işlev kapanışı arasındaki en önemli fark, bağımlı yöntemin this başvurusunun, yöntemi uygulayan örneğe bağlı veya bağımlı kalmaya devam etmesidir. Başka bir deyişle, bağımlı yöntemdeki this başvurusu her zaman yöntemi uygulayan orijinal nesneyi işaret eder. İşlev kapanışları için, this başvurusu geneldir, başka bir deyişle, çağrıldığı zaman işlevin ilişkilendirilmiş olduğu nesneyi işaret eder.

this anahtar sözcüğünü kullanıyorsanız, bağımlı yöntemleri anlamanız önemlidir. this anahtar sözcüğünün yöntemin üst nesnesine bir başvuru sağladığını unutmayın. ActionScript programcılarının çoğu, this anahtar sözcüğünün her zaman yöntemin tanımını içeren nesneyi veya sınıfı temsil etmesini bekler. Ancak yöntem bağlama olmadan bu her zaman geçerli olmayabilir. Örneğin, önceki ActionScript sürümlerinde this başvurusu her zaman yöntemi uygulayan örneği ifade etmiyordu. ActionScript 2.0'da bir örnekten yöntemler ayıklandığında, this başvurusu orijinal örneğe bağımlı olmamakla kalmaz aynı zamanda örneğin sınıfının üye değişkenleri ve yöntemleri de kullanılamaz. Bir yöntemi parametre olarak ilettiğinizde bağımlı yöntemler otomatik olarak oluşturulduğundan ActionScript 3.0'da bu bir sorun yaratmaz. Bağımlı yöntemler, this anahtar sözcüğünün her zaman yöntemin tanımlanmış olduğu nesne veya sınıfa başvurmasını sağlar.

Aşağıdaki kod, bağımlı yöntemi tanımlayan foo() adındaki bir yöntemi ve bağımlı yöntemi döndüren bar() adındaki bir yöntemi içeren ThisTest adındaki bir sınıfı tanımlar. Sınıfa harici olan kod, ThisTest sınıfının bir örneğini oluşturur, bar() yöntemini çağırır ve döndürme değerini myFunc adındaki bir değişkende saklar.

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 */

Kodun son iki satırı, kendisinden bir önceki satırsa bulunan this başvurusu genel nesneyi işaret etse de, foo() bağımlı yöntemindeki this başvurusunun halen ThisTest sınıfının bir örneğini işaret ettiğini gösterir. Üstelik, myFunc değişkeninde saklanan bağımlı yöntem, ThisTest sınıfının üye değişkenlerine erişmeye devam eder. Bu kodun aynısı ActionScript 2.0'da çalıştırılsa, this başvuruları eşleşir ve num değişkeni undefined olurdu.

addEventListener() yöntemi, argüman olarak bir işlev veya yöntem iletmenizi gerektirdiğinden, bağımlı yöntemlerin eklenmesinin en belirgin olduğu alanlardan biri olay işleyicileridir.

Bir varlığı gömmek için, ilk olarak varlığı bir FLA dosyasının kütüphanesine yerleştirin. Ardından varlığın gömülü varlık sınıfı için bir ad sağlamak üzere varlığın bağlantı özelliğini kullanın. Sınıf yolunda bu ada sahip bir sınıf bulunmazsa, sizin için otomatik olarak bir sınıf oluşturulur. Daha sonra, gömülü varlık sınıfının bir örneğini oluşturabilir ve o sınıf tarafından tanımlanmış veya miras alınmış özellikleri ve yöntemleri kullanabilirsiniz. Örneğin, aşağıdaki kod, PianoMusic adındaki gömülü bir varlık sınıfına bağlı gömülü bir sesi çalmak için kullanılabilir:

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

Alternatif olarak, [Embed] meta veri etiketini bir sonraki bölümde açıklandığı gibi, Flash Professional projesinde varlık gömmek için kullanabilirsiniz. [Embed] meta veri etiketini kodunuzda kullanırsanız, Flash Professional, projenizi derlemek için Flash Professional derleyicisi yerine Flex derleyicisi kullanır.

Kodunuzu Flex derleyicisi kullanarak derliyorsanız, ActionScript kodunda bir varlık gömmek için [Embed] meta veri etiketini kullanın. Varlığı ana kaynak klasörüne veya projenizin oluşturma yolundaki başka bir klasöre yerleştirin. Flex derleyicisi bir Embed meta veri etiketiyle karşılaşırsa, sizin için gömülü varlık sınıfını oluşturur. [Embed] meta veri etiketinden hemen sonra bildirdiğiniz bir Class veri türündeki değişken üzerinden sınıfa erişebilirsiniz. Örneğin, aşağıdaki kod, sound1.mp3 adındaki bir sesi gömer ve o sesle ilişkilendirilmiş gömülü varlık sınıfının bir başvurusunu saklamak için soundCls adındaki bir değişkeni kullanır. Daha sonra örnek, gömülü varlık sınıfının bir örneğini oluşturur ve bu örnekte play() yöntemini çağırır:

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