. .. : Swf.hu 1.0 archívum : Swf.hu főoldal >>> : .. .




 
 
SEGÉDLETEK ActionScript

Az objektum orientált programozás alapjai Flash-ben
  feltöltve: 2003.08.21 | szerző: tenegri | olvasva: 9794 alkalommal

           
 

Az objektum-orientált programozás napjainkban a legelterjedtebb programozási módszer, a komolyabb programok, alkalmazások fejlesztésére használt nyelvek, de még a scriptnyelvek szinte mindegyike is (C++, Object Pascal, Visual Basic, JavaScript, PHP, Perl, Python, stb.) ismeri és támogatja valamilyen szintig, s vannak, melyekben objektumok nélkül nem is lehet programozni (pl. Java, C#). Az objektum-orientáltság rohamosan terjed minden területen, így természetesen az ActionScript sem kerülhette el (jó) sorsát, s a Flash 5-ös verziótól kezdve objektum-orientált lehetőségekkel bővült, melyek a Flash MX-től még nagyobb hangsúlyt kaptak. Természetesen ezek a lehetőségek nem vetekszenek az olyan általános célú programozási nyelvekével, mint a C++, a Java vagy az Object Pascal, előfordulnak elsőre furcsának tűnő kényszermegoldások, s számos korláttal és hiányossággal fogunk találkozni az ActionScript-ben, melyek az említett nyelvekben nem találhatók meg, így ezek ismerőinek esetleg kényelmetlenségei lehetnek, de mindenesetre rendelkezésre álló eszközeivel az ActionScript nagy lépést tett a hatékony alkalmazásfejlesztés felé, s a jövő Flash verziói talán tovább csiszolgatják tudását.

Jelen segédlet egy sorozat első része. Ebben az első részben az objektum-orientált programozás alapjait tekintjük át, valamint ezek ActionScript-es megvalósítását. A második részben következik a komponensek készítése egyszerű példákkal szemléltetve, a harmadik részben egy gyakorlatban is használható komponenst rakunk össze: egy automatizált letöltés-kijelzőt (preloader), míg az esetleges további részekben teljesebb objektum-orientált alkalmazások elkészítését tervezem.

Az alábbiakban minden fogalmat és jelenséget igyekeztem példákkal is bemutatni, lehetőleg olyanokkal, melyek nem túlságosan elvontak, s a gyakorlati alkalmazhatóságot is szemléltetik. Ez utóbbi miatt a példák esetleg kicsit összetettre és hosszúra sikerültek, de mindenképpen fontosnak tartottam, hogy interaktív, azonnal kipróbálható eredményt nyújtsanak. Akiknek esetleg a forráslisták tanulmányozása kevesebb örömöt jelent, azok nyugodtan ugorják át ezeket a részeket, s csak az alfejezetekhez tartozó magyarázó szöveget olvassák el (úgy talán rövidebb :)).

Az OOP alapjai elméletben

Az objektum-orientált programozásban az alapelképzelés az, hogy az összetartozó adatokat és az azokkal műveleteket végző eljárásokat egy egységbe, objektumba szervezzük. Ezt pl. a Pascal record vagy a C struct típusához hasonlóan lehet elképzelni (ezeket talán többen is ismerik), azzal a különbséggel, hogy nem csak adatmezőket, hanem függvényeket és eljárásokat is lehet definiálni. Egy objektum változóit mezőnek (field; vagy az ActionScript szóhasználatában tulajdonság /property/, de ez kétértelmű lehet, s később erre még visszatérünk) nevezzük, míg a hozzá tartozó függvényeket metódusoknak (method). Egy objektumtípus jellemzőit (milyen adatmezők és metódusok találhatók benne) összefoglalóan objektumosztálynak (class) szokás hívni.

Igen fontos tulajdonsága az objektumoknak az öröklődés (inheritance). Ez azt jelenti, hogy létrehozhatunk olyan új objektumosztályt, mely örökli egy (néhány nyelvben - pl. C++ - akár több) már meglévő osztály tulajdonságait, s csupán kiegészíti azokat vagy némileg megváltoztatja működésüket úgy, hogy ez utóbbiak külső elérési formája lehetőleg nem változik.

Itt hangsúlyozni kell az örökölt metódusok működésének megváltoztatását, ugyanis ez lehetővé teszi, hogy a származtatott vagy gyermekobjektumokat (descendant, child) felhasználjuk az ős- vagy szülőobjektum (ancestor, parent) helyett, azaz minden olyan programkód működőképes maradhat az új objektummal, mely az ősobjektummal működött (ez persze nem mindig teljesül).

Az objektumosztályok öröklődése révén olyan osztályhierarchia jön létre, melyben a legalsó szinten általános célú, sokszor teljesen absztrakt objektumok helyezkednek el, s feljebb haladva egyre jobban szakosodott objektumok következnek. Egy objektumosztály gyakran tartalmaz olyan elemeket, mezőket vagy metódusokat, melyek nem feltétlenül lennének szükségesek a működéséhez, de megkönnyítik az új osztályok származtatását. Az ilyen mezők és esetenként semmit sem csináló metódusok definiálása leginkább a szigorúan típusos nyelvekben (pl. ObjectPascal, C++, stb.) jelent előnyt, míg a laza típusos nyelvekben (mint az ActionScript is) ez kevésbé érvényesül, s leginkább csak a kód és a programszerkezet átláthatóságát könnyíti meg.

Az objuktumok alapvetően olyan zárt egységek, melyeknek belső működése nem tartozik a külvilágra, a belül zajló folyamatok által használt mezők és metódusok nem érhetők el, csak az adott objektumosztály, esetleg annak leszármazottai számára (többféle elérési kör létezhet), s csupán az objektum kívülről történő felhasználásához és működtetéséhez feltétlenül szükséges elemeket használhatják más objektumok vagy egyéb programrészek, így elkerülhető az illetéktelen - akár véletlen - beavatkozás az objektum belső működésébe. És sajnos az objektum-orientáltságnak ez az az alapjellemzője, melyet az ActionScript (legalábbis jelenleg) egyáltalán nem támogat.

Objektumok ActionScript-ben

Az 5-ös verzió óta a Flash-ben szinte minden objektumokból épül fel. Objektum egy movie clip, egy szövegmező, egy nyomógomb, de még a tömbök, a string-ek, sőt a függvények is. Ezek az előre definiált objektumosztályok, melyeknek sok-sok előre definiált tulajdonságuk (pl. movie clip-nl az _x, _y, _alpha, _currentFrame, stb.) és metódusuk van (pl. szintén movie clip-nél play(), stop(), loadMovie(), stb.). Amit a fejlesztőkörnyezetben kézzel (egérrel) kiteszünk a színpadra és instance névvel látunk el, azt ActionScript-ből is elérhetjük mint objektumot.

Ha van egy objektumosztályunk azzal még önmagában nem sokra megyünk, akkor kel életre, ha létrehozunk egy (több), az osztálynak megfelelő objektumpéldányt (instance). Azt már tudjuk, hogy néhány esetben ezt megtehetjük a fejlesztőkörnyezetben pár kattintással (movie clip-pek, gombok, szövegmezők létrehozása), ActionScript-ben pedig a new kulcsszó szolgál erre. Elsőként - saját objektumosztály hiányában - hozzunk létre egy példányt a beépített osztályok egyikéből.

myString = new String("szöveg");

Ezután létrejön a String objektumosztály egy új példánya, s a myString változó fogja tartalmazni az objektumpéldányra mutató hivatkozást. Ezután az objektum tulajdonságai és metódusai egyszerűen elérhetők a következő módon, pontot használva elválasztójelként (dot syntax):

hossz = myString.length; // Ez egy tulajdonság
kisbetus = myString.toLowerCase(); // Ez egy metódus

Vagy tulajdonságok esetében még a tömbhivatkozáshoz hasonlóan is lehet hivatkozni, a tulajdonság nevét szövegként megadva:

hossz = myString["length"];

Miután a new létrehozta a kívánt osztályú objektumpéldányt, visszatérési értékként egy erre az objektumra mutató hivatkozást ad, s ezt tároljuk el egy változóban. Ha ugyanezt a hivatkozást később más változókba is elhelyezzük, attól még nem növekszik az objektumpéldányok száma, s mindegyik változó ugyanarra az objektumra fog mutatni (természetesen a new ismételt használatával új példány is létrejön), így ha az egyik változón keresztül hivatkozva megváltoztatjuk az objektum tartalmát, akkor ez a változás a másik változón keresztüli hivatkozáskor is érvényesül.

tomb1 = new Array("Minden", "bogár", "rovar");
tomb2 = tomb1;

trace("Tömb 1: " + tomb1);
trace("Tömb 2: " + tomb2 + newline);

tomb2[2] = "hatlábú";

trace("A tartalom megváltozott:")
trace("Tömb 1: " + tomb1);
trace("Tömb 2: " + tomb2 + newline);

Ennek eredmény ez lesz:

Egy objektumra több hivatkozás is mutathat

Ha már egyszer létrehoztunk egy objektumpéldányt, felmerülhet az igény, hogy - amennyiben már nincs szükségünk rá - megszüntethessük, csökkentendő a lefoglalt memória méretét. A Flash az objektumok megszüntetését voltaképpen automatikusan végzi: ha nincs több hivatkozás egy objektumra, akkor törli azt. Eképpen ha pl. megváltoztatjuk egy objektumhivatkozást tároló változó tartalmát, akkor az objektum, melyre eredetileg hivatkozott megszűnik létezni (hacsak nem hivatkozott rá egy másik változó is). Ugyanezt lehet elérni a delete utasítás használatával, s az objektum így is csak akkor törlődik, ha nincs rá egyéb hivatkozás. A két módszer eredménye tehát ugyanaz, de talán a delete egyértelműbben utal a művelet céljára. Az előbb megkezdett példánkat folytatva pedig erre az eredményre jutunk:

delete tomb1;

trace("Tömb1 törölve...");
trace("Tömb1: " + tomb1);
trace("Tömb2: " + tomb2 + newline);

tomb2 = undefined;

trace("Tömb2 is törölve, az objektum is megszűnik...");
trace("Tömb2: " + tomb2);

Egy objektumpéldány törlése

Megjegyzendő, hogy a beépített osztályok egy részénél az objektumpéldányok nem hozhatók létre a new-val. MovieClip objektumot a MovieClip osztály createEmptyMovieClip(), attachMovie() és duplicateMovieClip() metódusaival, TextField objektumot pedig a createTextField()-del hozhatunk létre, s Button objektumot egyáltalán nem lehet scripttel létrehozni. A Number, String és Boolean objektumok létrehozhatók a new kulcsszóval és egy egyszerű értékadással is (de csak a new-val létrehozottakra adja vissza a typeof az object választ, noha mindkét módon létehozva objektumként működnek). Az Array objektum létrehozható new-val és a szögletes zárójelek között, vesszővel elválasztott tömbelemek felsorolásával. Függvény (Function) objektumot létre lehet hozni a szokásos függvénydeklarációval (ilyenkor a függvénynév objektum-hivatkozásként, azaz változóként is működik), valamint változó értékadásához hasonlóan, függvénynév = function(paraméterek) { ... } alakban. A többi beépített objektum (Color, TextFormat, stb.) szabályosan viselkedik és csak new-val példányosítható.

Eddig tudunk új objektumpéldányt létrehozni, valamint ennek tulajdonságait és mezőit elérni, most következhet a saját objektumosztályok létrehozása, illetve egy meglévő kiegészítése.

Új objektumosztályt ActionScript-ben úgy alkothatunk, hogy megadjuk azt a függvényt, mely az osztály egy objektumpéldányának létrehozásakor fog lefutni. Ezt konstruktornak (constructor) nevezik, s többnyire inicializálás és az alapbeállítások elvégzése a feladata (már ha szükséges - ha nem, akkor nem csinál semmit). ActionScript-ben egy objektumosztálynak egy konstruktora lehet (más nyelvekben akár több is), s ennek neve egyben az osztály neve is lesz. A konstruktor megadása teljesen megegyezik egy "hagyományos" függvényével:

function myClass() {
}

Ezután már létrehozhatók a myClass osztály példányai, melyek - noha még egyetlen mezőt vagy metódust sem adtunk meg - már rendelkeznek bizonyos elemekkel, ugyanis az új objektumosztályok automatikusan öröklik az Object osztály jellemzőit, tehát az Object osztály összes mezője és metódusa használható myClass-szal is, bár ezeket egyelőre nem igazán fogjuk igénybe venni.

myObj = new myClass();

/* A toString() metódust az Object osztálytól örököltük */
s = myObj.toString();

 
           
 
 

© Devnet.hu. A segédletek semmilyen formában nem másolhatók, publikálhatók a Devnet.hu és a szerzők közös írásos engedélye nélkül.
 
. .. : Swf.hu 1.0 archívum : Swf.hu főoldal >>> : .. .