Zobrazit nápovědu v souboru

Transkript

Jak se naučit jazyk
ACTIONSCRIPT® 3.0
Právní upozornění
Právní upozornění
Právní upozornění viz http://help.adobe.com/cs_CZ/legalnotices/index.html.
Poslední aktualizace 12.5.2011
iii
Obsah
Kapitola 1: Úvodní informace k jazyku ActionScript 3.0
O ActionScriptu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
Výhody jazyka ActionScript 3.0
......................................................................................... 1
Co je nového v jazyce ActionScript 3.0
................................................................................. 2
Kapitola 2: Začínáme s jazykem ActionScript
Základy programování . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
Práce s objekty
........................................................................................................ 7
Společné prvky programu
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
Příklad: Animace portfolia (Flash Professional)
Vytváření aplikací v jazyce ActionScript
Vytváření vlastních tříd
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
Příklad: Vytváření základních aplikací
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
Kapitola 3: Jazyk ActionScript a jeho syntaxe
Přehled jazyka . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
Objekty a třídy
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
Balíčky a jmenné prostory
Proměnné
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
Typy dat
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
Syntaxe
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
Operátory
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
Podmíněné příkazy
Opakování
Funkce
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
Kapitola 4: Objektově orientované programování v jazyce ActionScript
Úvod k objektově orientovanému programování . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
Třídy
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
Rozhraní
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
Zdědění
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
Pokročilá témata
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
Příklad: GeometricShapes
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
1
Kapitola 1: Úvodní informace k jazyku
ActionScript 3.0
O ActionScriptu
ActionScript je programovací jazyk pro prostředí přehrávače Adobe® Flash® Player a programu Adobe® AIR™ v době
běhu. Umožňuje interakce, zpracovávání dat a další možnosti v obsahu a v aplikacích Flash, Flex a AIR.
Jazyk ActionScript se provádí v aplikaci ActionScript Virtual Machine (AVM), která je součástí přehrávače Flash
Player a programu AIR. Kód jazyka ActionScript se obvykle převádí pomocí kompilátoru do formátu bytového kódu.
(Bytový kód je druh programovacího jazyka, který píší a rozpoznávají počítače.) Mezi kompilátory patří i kompilátor
vestavěný v aplikaci Adobe® Flash® Professional a kompilátor vestavěný v aplikaci Adobe® Flash® Builder™, který je k
dispozici v sadě SDK aplikace Adobe® Flex™. Bytový kód se vkládá do souborů SWF, jež provádí aplikace Flash Player
a AIR.
Jazyk ActionScript 3.0 nabízí stabilní programovací model, který dobře znají vývojáři se základní znalostí objektově
orientovaného programování. Některé z klíčových funkcí jazyka ActionScript 3.0, které vylepšují předchozí verze
jazyka ActionScript, zahrnují následující:
• Nový nástroj ActionScript Virtual Machine nazvaný AVM2, který používá novou sadu pokynů bytového kódu a
nabízí o mnoho lepší výkon
• Modernější základ pro kód kompilátoru, který provede hlubší optimalizaci než předcházející verze kompilátoru
• Rozšířené a vylepšené programovací rozhraní aplikace (API) s nízkoúrovňovým ovládáním objektů a správným na
objekt orientovaným modelem
• Rozhraní API XML založené na ECMAScript pro specifikaci XML (E4X) (ECMA-357 vydání 2). E4X je rozšíření
jazyka pro ECMAScript, které přidává XML jako nativní datový typ jazyka.
• Model události založený na specifikaci událostí na úrovni 3 modelu objektu dokumentu (DOM)
Výhody jazyka ActionScript 3.0
Jazyk ActionScript 3.0 předčí skriptovací schopnosti předcházejících verzí jazyka ActionScript. Jeho účelem je
umožnit vytváření vysoce komplexních aplikací s velkými sadami dat a na objekt orientovanými, opětovně
použitelnými základnami kódů. Jazyk ActionScript 3.0 není nezbytný pro obsah, který lze spustit v přehrávači Adobe
Flash Player. Umožňuje však zlepšení výkonu, která jsou dostupná jen při použití aplikace AVM2 (virtuální počítač
ActionScript 3.0). Kód v jazyce ActionScript 3.0 umí provádět operace až desetkrát rychleji než kód v dřívějších verzích
jazyka ActionScript.
Předchozí verze aplikace ActionScript Virtual Machine, AVM1, pracuje s kódem v jazyce ActionScript 1.0
a ActionScript 2.0. Přehrávače Flash Player 9 a 10 podporují aplikaci AVM1 kvůli zajištění zpětné kompatibility.
2
JAK SE NAUČIT JAZYK ACTIONSCRIPT 3.0
Úvodní informace k jazyku ActionScript 3.0
Co je nového v jazyce ActionScript 3.0
Jazyk ActionScript 3.0 obsahuje mnoho tříd a funkcí, které jsou podobné jako ve verzích ActionScript 1.0 a 2.0.
Nicméně jazyk ActionScript 3.0 se od předchozích verzí jazyka ActionScript liší architektonicky a koncepčně.
Vylepšení v jazyce ActionScript 3.0 zahrnují nové funkce základního jazyka a vylepšené rozhraní API přehrávače, které
poskytuje lepší kontrolu objektů na nižších úrovních.
Základní jazykové prvky
Základní jazyk definuje základní stavební bloky programovacího jazyka, například příkazy, výrazy, podmínky,
opakování a typy. Jazyk ActionScript 3.0 obsahuje mnoho funkcí, jež urychlují proces vývoje.
Výjimky v době běhu
Jazyk ActionScript 3.0 hlásí více stavů chyb než předcházející verze jazyka ActionScript. Výjimky v době běhu jsou
použity pro běžné stavy chyb, vylepšují zkušenosti s laděním a umožňují vám vyvinout aplikace, které účinně
zpracovávají chyby. Chyby v době běhu mohou poskytnout sledování zásobníku, které je anotováno se zdrojovým
souborem a informací a počtu řádků. Tím vám umožňují rychlé a přesné určení chyb.
Typy v době běhu
V jazyce ActionScript 3.0 jsou za běhu zachovány informace o typech. Tyto informace slouží k provádění kontroly
typů za běhu, čímž se zvyšuje bezpečnost typů systému. Informace o typech se také používají ke znázornění
proměnných v nativních reprezentacích počítače, což vylepšuje výkon a snižuje využití paměti. Pro srovnání – anotace
typů v jazyce ActionScript 2.0 jsou především pomůckou pro vývojáře a všechny hodnoty se dynamicky typují za běhu.
Uzavřené třídy
Jazyk ActionScript 3.0 zahrnuje koncepci uzavřených tříd. Uzavřená třída má pouze fixní sadu vlastností a metod,
které jsou definovány v době kompilace; další vlastnosti a metody přidat nelze. Vyloučení možnosti změnit třídu za
běhu umožňuje přísnější kontrolu v době kompilace, takže programy jsou pak stabilnější. Vylepšuje také využití
paměti tím, že nevyžaduje pro každou instanci objektu interní tabulku křížku. Dynamické třídy jsou také přístupné
pomocí klíčového slova dynamic. Všechny třídy v definici jazyka ActionScript 3.0 jsou implicitně uzavřeny, ale lze je
deklarovat tak, aby byly dynamické, a to s klíčovým slovem dynamic.
Uzavření metody:
Jazyk ActionScript 3.0 umožňuje uzavření metody pro automatické zapamatování si původní instance objektu. Tato
funkce je užitečná pro zpracovávání událostí. V jazyce ActionScript 2.0 si uzavření metody nepamatují, z jaké instance
objektu byla vyjmuta, což vede k nečekanému chování při volání uzavření metody.
ECMAScript pro XML (E4X)
Jazyk ActionScript 3.0 implementuje ECMAScript pro XML (E4X), nedávno standardizovaný jako ECMA-357. E4X
nabízí přirozenou plynulou sadu jazykových konstruktů pro manipulaci s XML. Oproti tradiční analýze XML rozhraní
API má XML s E4X funkce stejné jako nativní datový typ jazyka. E4X urychluje vývoj aplikací, které využívají jazyk
XML, a to značným snížením potřebného množství kódu.
Specifikaci ECMA E4X naleznete na stránce www.ecma-international.org.
Regulární výrazy
Jazyk ActionScript 3.0 zahrnuje nativní podporu pro regulární výrazy, takže můžete rychle vyhledávat řetězce a
manipulovat s nimi. Jazyk ActionScript 3.0 implementuje podporu pro regulární výrazy dle jejich definice ve
specifikaci jazyka ECMAScript (ECMA-262), 3. vydání.
3
Jmenné prostory
Jmenné prostory se podobají tradičním specifikátorům přístupu používaným pro ovládání viditelnosti deklarací
(public, private, protected). Pracují jako vlastní specifikátory přístupu, které můžete pojmenovat dle svého
výběru. Pro zabránění kolizím jsou jmenné prostory vybaveny identifikátorem Universal Resource Identifier (URI) a
jsou také používány pro reprezentaci jmenných prostorů XML při práci s E4X.
Nové primitivní typy
Jazyk ActionScript 3.0 zahrnuje tři číselné typy: Number, int, uint. Typ Number (číslo) představuje číslo s plovoucí
čárkou s dvojitou přesností. Typ int je 32-bitové celé číslo se znaménkem, které umožňuje kódu jazyka ActionScript
využít výhody rychlých matematických schopností celého čísla CPU. Typ int je užitečný pro čítače opakování a
proměnné tam, kde jsou použita celá čísla. Typ uint je typ 32-bytového celého čísla bez znaménka, který je užitečný
pro barevné hodnoty RGB, počty bytů, atd. Oproti tomu jazyk ActionScript 2.0 má jen jeden číselný typ, a to Number.
Funkce rozhraní API
Rozhraní přehrávače API v jazyku ActionScript 3.0 obsahují mnoho tříd, které vám umožňují ovládat objekty na nízké
úrovni. Architektura jazyka je navržena tak, aby byla intuitivnější než předchozí verze. Přestože třídy nelze vzhledem
k jejich množství popisovat podrobně, za zmínku stojí několik podstatných rozdílů.
Model události DOM3
Model událostí DOM3 (objektový model dokumentu úrovně 3) poskytuje standardní způsob generování a zpracování
zpráv o událostech. Tento model událostí je navržen tak, aby objekty v rámci aplikací mohly vzájemně reagovat a
komunikovat, zachovat si svůj stav a reagovat na změnu. Model událostí v jazyce ActionScript 3.0 byl vytvořen podle
specifikace událostí Modelu objektu dokumentu (DOM) úrovně 3 sdružení W3C (World Wide Web Consortium).
Tento model poskytuje přehlednější a efektivnější mechanismus než systémy událostí v předchozích verzích jazyka
ActionScript.
Události a události chyb jsou umístěny v balíku flash.events. Komponenty aplikace Flash Professional a rámec Flex
používají stejný model událostí, takže systém událostí je v celé platformě Flash jednotný.
Rozhraní API seznamu zobrazení
Rozhraní API pro přístup k seznamu zobrazení – stromová struktura, která obsahuje jakékoliv vizuální elementy
v aplikaci – se skládá z tříd pro práci se základními vizuálními tvary.
Třída Sprite je odlehčený stavební prvek, jenž má být základní třídou pro vizuální elementy, např. komponenty
uživatelského rozhraní. Třída Shape představuje prosté vektorové tvary. Tyto třídy lze přirozeně konkretizovat pomocí
operátoru new a lze je kdykoliv dynamicky znovu přiřadit jako nadřazené.
Hloubková správa probíhá automaticky. Jsou k dispozici metody pro určení a ovládání pořadí překrývání objektů.
Zpracovávání dynamických dat a obsahu
Jazyk ActionScript 3.0 obsahuje mechanismy pro načítání a zpracovávání datových zdrojů a dat ve vaší aplikaci, které
jsou intuitivní a ve všech rozhraních API stejné. Třída Loader poskytuje jediný mechanismus pro načítání souborů
SWF a datových zdrojů obrazů a zajišťuje získání přístupu k podrobným informacím o načteném obsahu. Třída
URLLoaderposkytuje samostatný mechanismus pro načítání textu a binárních dat v aplikacích zaměřených na data.
Třída Socket poskytuje způsob načtení a zapsání binárních dat na servery soketů, a to v jakémkoliv formátu.
4
Přístup k datům na nízké úrovni
Různá rozhraní API poskytují k datům přístup nižší úrovně. Pro načítaná data poskytuje třída URLStream během
načítání přístup k datům jako k prvotním binárním datům. Třída ByteArray umožňuje optimalizovat čtení, zápis a
práci s binárními daty. Zvukové rozhraní API poskytuje podrobné ovládání zvuku pomocí tříd SoundChannel
a SoundMixer. Zabezpečovací rozhraní API poskytují informace o právech zabezpečení souboru SWF nebo načteného
obsahu a umožňují tak lepší zpracování chyb zabezpečení.
Práce s textem
Jazyk ActionScript 3.0 obsahuje balík flash.text pro všechna rozhraní API související s textem. Třída TextLineMetrics
poskytuje podrobnou metriku pro řádek textu v rámci textového pole; nahrazuje metodu
TextFormat.getTextExtent() v jazyce ActionScript 2.0. Třída TextField obsahuje metody nízké úrovně, jež
poskytují specifické informace o řádku textu nebo jednotlivém znaku v textovém poli. Například metoda
getCharBoundaries() vrátí obdélník představující ohraničovací rámeček znaku. Metoda getCharIndexAtPoint()
vrátí index znaku v určeném bodě. Metoda getFirstCharInParagraph() vrátí index prvního znaku v odstavci. Mezi
metody na úrovni řádku patří getLineLength(), která vrátí počet znaků na určitém řádku textu, a getLineText(),
která vrátí text určeného řádku. Třída Font poskytuje způsob ovládání vnořených písem v souborech SWF.
Pro zajištění kontroly nad textem na ještě nižší úrovni tvoří třídy v balíku flash.text.engine společně modul Flash Text
Engine. Tato sada tříd poskytuje kontrolu nad textem na nízké úrovni a slouží k vytváření rámců a komponent textu.
5
Kapitola 2: Začínáme s jazykem
ActionScript
Základy programování
Protože ActionScript je programovací jazyk, může být při jeho studiu užitečné nejprve porozumět několika obecným
konceptům počítačového programování.
Co dělají počítačové programy
Nejprve je vhodné koncepčně porozumět tomu, co počítačový program je a co má za úkol. Existují dva hlavní aspekty
počítačového programu:
• Program je sledem instrukcí nebo kroků, které má počítač provádět.
• Každý krok znamená zpracování části informace nebo dat.
V obecném smyslu je počítačový pouze seznamem posloupností instrukcí, které předáváme počítači, aby je jednu za
druhou provedl. Každá jednotlivá instrukce se nazývá příkaz. V jazyce ActionScript je každý příkaz zakončen
středníkem.
V podstatě všechny instrukce uvedené v programu zpracovávají určité množství dat, která jsou uložena v paměti
počítače. Jednoduchým příkladem může být pokyn, aby počítač sečetl dvě čísla a uložil výsledek do paměti. Jako
složitější příklad si představte, že na obrazovce je vykreslen obdélník a vaším úkolem je napsat program, který jej
přesune na jiné místo na obrazovce. Počítač si pamatuje určité informace o obdélníku: souřadnice X, Y umístění, jeho
šířku a výšku, barvu atd. Každá taková část informací je uložena na určitém místě v paměti počítače. Program
zajišťující posun obdélníku na jiné místo bude zahrnovat kroky, jako např. „změnit souřadnici X na 200; změnit
souřadnici Y na 150“. Jinými slovy určí nové hodnoty souřadnic X a Y. V pozadí přitom počítač zpracuje data
a převede tato čísla na obraz, který se zobrazí na obrazovce. Jako základ však stačí vědět, že proces „posunutí obdélníku
po obrazovce“ vyžaduje přeměnu kusů dat v paměti počítače.
Proměnné a konstanty
Programování z převážné části sestává z přeměny jednotlivých informací v paměti počítače. Proto je důležité mít
možnost vyjádřit každou informaci v programu. Proměnná je název vyjadřující hodnotu v paměti počítače. Při
zapisování příkazů pro zpracování hodnot zapisujete místo hodnoty název proměnné. Kdykoliv počítač vidí
v programu název proměnné, prohledá paměť a použije hodnotu, kterou zde nalezne. Pokud například máte dvě
proměnné pojmenované hodnota1 a hodnota2 a každá obsahuje číslo, můžete pro sečtení těchto čísel zadat příkaz:
value1 + value2
Při provádění těchto kroků počítač vyhledá hodnoty každé proměnné a poté je sečte.
V jazyce ActionScript 3.0 je proměnná tvořena třemi různými součástmi:
• Název proměnné
• Typ dat, které lze do proměnné uložit
• Skutečná hodnota uložená v paměti počítače
6
Začínáme s jazykem ActionScript
Viděli jste, jak počítač používá název jako vyhrazené místo pro hodnotu. Typ dat je také důležitý. Při vytváření
proměnné v jazyce ActionScript definujete konkrétní typ dat, která v ní mají být uložena. Od tohoto okamžiku bude
v pokynech programu možné do této proměnné uložit pouze tento typ dat. Hodnotu lze zpracovávat za použití
určitých vlastností spojených s jejím typem dat. V jazyce ActionScript vytváříte proměnnou (tento proces se nazývá
deklarování proměnné) pomocí příkazu var:
var value1:Number;
V tomto příkladu dostane počítač pokyn, aby vytvořil proměnnou s názvem value1, v níž mohou být uložena pouze
data typu Number (číslo). („Number“ je určitý datový typ definovaný v jazyce ActionScript.) Hodnotu můžete také
uložit přímo do proměnné:
var value2:Number = 17;
Adobe Flash Professional
V aplikaci Flash Professional existuje jiný způsob, jak deklarovat proměnnou. Když umístíte symbol filmového klipu,
symbol tlačítka nebo textové pole na plochu, můžete jej pojmenovat názvem instance v Inspektoru vlastností. Aplikace
Flash Professional vytvoří v pozadí proměnnou, jejíž název je shodný s názvem instance. Tento název lze použít v kódu
jazyka ActionScript k vyjádření dané položky Stage. Předpokládejme například, že se na ploše nachází symbol
filmového klipu, kterému přiřadíte název instance rocketShip. Pokaždé, když v kódu jazyka ActionScript použijete
proměnnou rocketShip, budete v podstatě pracovat s tímto filmovým klipem.
Konstanta je podobná proměnné. Jedná se o název, který představuje hodnotu v paměti počítače s určeným typem dat.
Rozdíl je v tom, že konstanta může mít přiřazenou hodnotu pouze v průběhu aplikace jazyka ActionScript. Jakmile je
hodnota konstanty přiřazena, je stejná v celé aplikaci. Syntaxe pro deklarování konstanty je téměř stejná jako při
deklarování proměnné. Jediný rozdíl je v tom, že se místo klíčového slova var použije klíčové slovo const.
const SALES_TAX_RATE:Number = 0.07;
Konstanta je užitečná k definování hodnoty použité na několika místech v projektu, která se za normálních okolností
nemění. Použitím konstanty namísto literálové hodnoty bude váš kód čitelnější. Zvažte například dvě verze stejného
kódu. V jedné se cena násobí konstantou SALES_TAX_RATE. Ve druhé se cena násobí číslem 0,07. Verze používající
konstantu SALES_TAX_RATE je snáze pochopitelná. Dále předpokládejme, že se hodnota definovaná konstantou mění.
Jestliže v celém projektu použijete k vyjádření této hodnoty konstantu, stačí změnit hodnotu na jediném místě
(v deklaraci konstanty). Naproti tomu při použití pevně zakódovaných hodnot literálů bude nutné hodnotu změnit na
různých místech.
Typy dat
V jazyce ActionScript existuje mnoho datových typů, které můžete použít jako datový typ vytvářené proměnné.
Některé z těchto datových typů lze považovat za „jednoduché“ nebo „základní“ datové typy:
• String (řetězec): textová hodnota, například název nebo text kapitoly knihy
• Numeric (číselný typ): jazyk ActionScript 3.0 zahrnuje tři specifické datové typy pro číselná data:
• Number (číslo): kterákoliv číselná hodnota, zahrnující hodnoty se zlomkem nebo bez něj
• int: celočíselná hodnota (celé číslo bez zlomku)
• uint: celočíselná hodnota bez znaménka, což znamená, že celé číslo nemůže být záporné
• Boolean (booleovská hodnota): logická hodnota PRAVDA nebo NEPRAVDA, například jako přepínač, který může
být zapnutý nebo vypnutá, nebo zad se dvě hodnoty rovnají či nikoliv
7
Jednoduché datové typy představují jednotlivý kus informací: například jedno číslo nebo jednu posloupnost textu.
Nicméně většina datových typů definovaných v jazyce ActionScript jsou komplexní datové typy. Představují sadu
hodnot v jediném kontejneru. Například proměnná s datovým typem Date představuje jednu hodnotu (časový
okamžik). Tato hodnota data je však zastoupena jako několik hodnot: den, měsíc, rok, hodina, minuta, sekunda atd.,
přičemž všechny jsou jednotlivými čísly. O datu obvykle uvažujeme jako o jediném čísle a při vytvoření proměnné
Date lze datum zpracovávat jako jednu hodnotu. Počítač ji však interně zpracovává jako skupinu několika hodnot,
které při složení dohromady dávají jediné datum.
Většina z vestavěných datových typů a také datových typů definovaných programátory jsou komplexní datové typy.
Mezi komplexní datové typy patří i následující:
• MovieClip: symbol filmového klipu
• TextField: dynamické nebo vstupní textové pole
• SimpleButton: symbol tlačítka
• Date: informace o jednotlivém okamžiku v čase (datum a čas)
Dvě slova, která jsou často používána jako synonymum pro datový typ, jsou třída a objekt. Třída je jednoduše definicí
datového typu. Slouží jako šablona pro všechny objekty daného datového typu, jako by říkala „všechny proměnné
datového typu Example mají tyto vlastnosti: A, B a C“. Naproti tomu objekt je jen konkrétní instancí třídy. Například
proměnnou s datovým typem MovieClip lze popsat jako objekt MovieClip. Níže jsou uvedeny různé způsoby, jak
vyjádřit stejnou věc:
• Datový typ proměnné myVariable je Number.
• Proměnná myVariable je instancí Number.
• Proměnná myVariable je objektem Number.
• Proměnná myVariable je instancí třídy Number.
Práce s objekty
Jazyk ActionScript znám jako objektově orientovaný programovací jazyk. Objektově orientovaného programování je
jednoduše přístup k programování. Ve skutečnosti to není nic jiného než způsob uspořádání kódu v programu pomocí
objektů.
Dříve byl termín „počítačový program“ definován jako série kroků nebo pokynů prováděných počítačem. Koncepčně
je pak možné si představit počítačový program jako jeden dlouhý seznam pokynů. Nicméně v objektově orientovaném
programování jsou pokyny programu rozděleny mezi různé objekty. Kód je seskupen do shluků funkcí, takže
související typy funkcí nebo související informace jsou seskupeny v jednom kontejneru.
Pokud jste v aplikaci Flash Professional pracovali se symboly, již jste zvyklí na práci s objekty. Představte si, že jste
definovali symbol filmového klipu, např. vykreslení obdélníku, a umístili jste jeho kopii na plochu. Tento symbol
filmového klipu je (doslova) objektem v jazyce ActionScript, instancí třídy MovieClip.
8
Existují různé charakteristiky filmového klipu, které můžete změnit. Po jeho vybrání lze v Inspektoru vlastností změnit
jeho hodnoty, např. souřadnici X nebo šířku. Rovněž lze provádět různé úpravy barvy, např. změnit jeho hodnotu alfa
(průhlednost) nebo aplikovat filtr vrženého stínu. Jiné nástroje aplikace Flash Professional umožňují provádění
dalších změn, například použití nástroje Volná transformace k otočení obdélníku. Všechny tyto způsoby, jimiž lze
v aplikaci Flash Professional upravovat symbol filmového klipu, jsou rovněž dostupné v jazyce ActionScript. V jazyce
ActionScript lze filmový klip upravit změnou dat, která jsou sloučena v jediném balíku zvaném objekt MovieClip.
V objektově orientovaném programování v jazyce ActionScript existují tři typy charakteristiky, které může obsahovat
kterákoliv třída.
• Vlastnosti
• Metody
• Události
Tyto prvky slouží pro správu kusů dat použitých programem a pro rozhodování o tom, které činnosti se budou
provádět a v jakém pořadí.
Vlastnosti
Vlastnost představuje jeden z kusů dat, které jsou seskupené dohromady do objektu. Vzorový objekt song může mít
vlastnosti pojmenované artist a title; třída MovieClip má vlastnosti rotation, x, width a alpha. S vlastnostmi se
pracuje jako s jednotlivými proměnnými. Vlastnosti si lze v podstatě představit jako „podřízené“ proměnné obsažené
v objektu.
Zde jsou některé příklady kódu jazyka ActionScript využívajícího vlastnosti. Tento řádek kódu pohybuje klipem
MovieClip pojmenovaným square do souřadnice X o 100 obrazových bodů:
square.x = 100;
Tento kód používá vlastnost rotation k otočení MovieClip square tak, aby to odpovídalo otočení MovieClip
triangle:
square.rotation = triangle.rotation;
Tento kód upraví horizontální stupnici třídy MovieClip square tak, aby byla 1,5krát větší než předtím:
square.scaleX = 1.5;
Povšimněte si společné struktury: používáte proměnnou (square, triangle) jako název objektu, následuje tečka (.)
a pak název vlastnosti (x, rotation, scaleX). Tečka, které se říká operátor dot, se používá k označení přístupu k
jednomu z podřízených prvků objektu. Celá struktura společně, „název proměnné-tečka-název vlastnosti“ se používá
jako jedna proměnná, jako název jedné hodnoty v paměti počítače.
Metody
Metoda je akce, kterou může objekt provést. Předpokládejme například, že v aplikaci Flash Professional byl vytvořen
symbol filmového klipu, na jehož časové ose je několik klíčových snímků a animací. Filmový klip se může přehrát nebo
zastavit, nebo může dát přehrávací hlavě pokyn, aby se přesunula na konkrétní snímek.
Tento kód vydává instrukci klipu MovieClip pojmenovanému shortFilm, aby se začal přehrávat:
shortFilm.play();
Tato řádka způsobí zastavení klipu MovieClip pojmenovaného shortFilm (přehrávací hlava se zastaví na místě, jako
při pozastavení videa):
9
shortFilm.stop();
Tento kód vydává instrukci klipu MovieClip pojmenovanému shortFilm přesunout přehrávací hlavu na snímek
Frame 1 a zastavit přehrávání (jako při převíjení videa):
shortFilm.gotoAndStop(1);
Metody, podobně jako vlastnosti, jsou přístupné zapsáním názvu objektu (proměnné), pak tečky, pak názvu metody
následované závorkami. Závorky jsou způsobem, jak naznačit, že voláte metodu. Jinými slovy dávají objektu pokyn,
aby provedl danou činnost. Někdy jsou hodnoty (či proměnné) umístěny do závorek kvůli předání dalších informací,
které jsou nezbytné k provedení činnosti. Tyto hodnoty jsou známy jako parametry metody. Například metoda
gotoAndStop() potřebuje informace o tom, na který snímek má přejít, takže vyžaduje v závorkách jeden parametr.
Jiné metody, jako play() a stop(), jsou zřejmé a nevyžadují další informace. Nicméně jsou i přesto psány se
závorkami.
Na rozdíl od vlastností (a proměnných) nejsou metody použity jako vyhrazená místa pro hodnotu. Některé metody
však mohou provádět výpočty a vracet výsledky, které lze použít jako proměnnou. Například metoda toString()
třídy Number převádí číselnou hodnotu na textové vyjádření.
var numericData:Number = 9;
var textData:String = numericData.toString();
Metodu toString() můžete například použít v případě, že chcete zobrazit hodnotu proměnné Number v textovém
poli na obrazovce. Vlastnost text třídy TextField je definována jako řetězec, takže může obsahovat pouze textové
hodnoty. (Vlastnost property textu představuje vlastní obsah textu zobrazeného na obrazovce.) Tento řádek kódu
převede číselnou hodnotu v proměnné numericData na text. Pak tuto hodnotu zobrazí na obrazovce v objektu
TextField s názvem calculatorDisplay:
calculatorDisplay.text = numericData.toString();
Události
Počítačový program je řada pokynů, které počítač vykonává krok za krokem. Některé jednoduché počítačové
programy nejsou tvořeny ničím jiným než několika kroky, které počítač provede, a program se poté ukončí. Programy
v jazyce ActionScript jsou však navrženy tak, aby se uchovaly v chodu, vyčkaly na vstup uživatele nebo jinou událost.
Události jsou mechanismy jež stanoví, které instrukce počítač provede a kdy.
V podstatě jsou události věci, které nastávají, kterých si je jazyk ActionScript vědom a může na ně reagovat. Řada
událostí souvisí s činností uživatele, např. s kliknutím na tlačítko nebo se stisknutím klávesy na klávesnici. Existují také
další typy událostí. Pokud například použijete jazyk ActionScript k načtení externího obrázku, existuje událost, která
vás vyrozumí, když načítání obrázku skončí. Když je spuštěn program v jazyce ActionScript, koncepčně jen čeká, až se
stanou určité věci. Jakmile k nim dojde, spustí se kód v jazyce ActionScript, který byl pro tyto události definován.
Základní zpracování událostí
Technika specifikování jistých činností, které mají být provedeny v odezvě na určité události, je známá jako zpracování
událostí. Když zapisujete kód v jazyce ActionScript k provedení zpracování události, existují tři důležité prvky, které
musíte identifikovat:
• Zdroj události: který objekt je ten, jemuž se událost přihodí? Například na které tlačítko bylo kliknuto, nebo který
objekt Loader načítá obrázek? Zdroj události se rovněž nazývá cíl události. Říká se mu tak proto, že se jedná o objekt,
kde počítač zaměří událost (tj. kde k události vlastně dojde).
• Událost: Jaká akce bude provedena, tj. akce, na kterou chcete reagovat? Tuto konkrétní událost je důležité
identifikovat, protože mnoho objektů spouští několik událostí.
• Odezva: jaké kroky mají být provedeny, když k události dojde?
10
Každý kód napsaný v jazyce ActionScript pro zpracování událostí vyžaduje tyto tři elementy. Kód sleduje tuto základní
strukturu (elementy psané tučně jsou vyhrazená místa, která by se vyplnila pro určitý případ):
function eventResponse(eventObject:EventType):void
{
// Actions performed in response to the event go here.
}
eventSource.addEventListener(EventType.EVENT_NAME, eventResponse);
Tento kód provádí dva kroky. Nejprve definuje funkci, která je způsobem specifikace činností, které budou provedeny
v odezvě na událost. Potom zavolá metodu addEventListener() zdrojového objektu. Volání metody
addEventListener() v podstatě „upíše“ tuto funkci určené události. Když k události dojde, provedou se činnosti
funkce. Zvažte každou z těchto částí podrobněji.
Funkce poskytuje způsob, kterým lze seskupit činnosti pod jedním názvem, který slouží jako název zástupce
k provedení činností. Funkce je stejná jako metoda s tím rozdílem, že nemusí být nutně spojená s určitou třídou.
(Termín „metoda“ lze definovat jako funkci, která je spojená s určitou třídou.) Při vytváření funkce pro zpracování
událostí, musíte vybrat název této funkce (v tomto případě se nazývá eventResponse). Kromě toho je třeba určit jeden
parametr (v tomto případě má název eventObject). Specifikování parametru funkce je jako deklarování proměnné,
takže musíte také uvést datový typ parametru. (V tomto příkladu je datový typ parametru EventType.)
Každý typ události, které chcete naslouchat, má připojenou třídu jazyka ActionScript. Specifikovaný datový typ pro
parametr funkce je vždy přidruženou třídou specifické události, na kterou chcete reagovat. Například událost click
(spustí se, když uživatel klikne na položku myší) je spojena s třídou MouseEvent. Chcete-li zapsat funkci posluchače
pro událost click, definujete funkci posluchače pomocí parametru typu dat MouseEvent. Nakonec mezi levou a
pravou složenou závorku ({ ... }) napište pokyny, které má počítač provést, když k události dojde.
Funkce pro zpracování události je napsaná. Potom přikážete zdrojovému objektu události (objekt, kterému se událost
stane, např. tlačítko), aby zavolal danou funkci, když k události dojde. Funkci lze zaregistrovat se zdrojovým objektem
události voláním metody addEventListener() tohoto objektu (všechny objekty, jež mají události, mají také metodu
addEventListener()). Metoda addEventListener()má dva parametry:
• První, název specifické události, na kterou chcete reagovat. Každá událost je připojená k určité třídě. Každá třída
události má pro každou ze svých událostí definovánu zvláštní hodnotu, která slouží jako jedinečný název. Tato
hodnota se použije pro první parametr.
• Druhý, název funkce odezvy na událost. Povšimněte si, že název funkce je zapsán bez závorek, když je předáván
jako parametr.
Proces zpracování událostí
Následující podrobný popis se věnuje procesu, který nastává, když vytvoříte posluchače události. V tomto případě je
příkladem vytvoření funkce posluchače, která je zavolaná po klepnutí na objekt nazvaný myButton.
Skutečný programátorem zapsaný kód je následující:
function eventResponse(event:MouseEvent):void
{
// Actions performed in response to the event go here.
}
myButton.addEventListener(MouseEvent.CLICK, eventResponse);
11
Zde je uvedeno, jak by kód pracoval při spuštění:
1 Když se načte soubor SWF, počítač zaregistruje, že existuje funkce s názvem eventResponse().
2 Počítač pak spustí kód (konkrétně řádky kódu, které nejsou funkcí). V tomto případě se jedná pouze o jednu řádku
kódu: volání metody addEventListener() pro objekt zdroje události (s názvem myButton) a předání funkci
eventResponse jako parametr.
Objekt myButton interně uchovává seznam funkcí, jež poslouchají každou z jeho událostí. Po zavolání metody
addEventListener() objekt myButton uloží funkci eventResponse() do seznamu posluchačů událostí.
12
3 V některém bodě uživatel klepne na objekt myButton, spustí událost click (identifikována v kódu jako
MouseEvent.CLICK).
V tento okamžik nastane následující:
a Vytvoří se objekt, který je instancí třídy spojené s danou událostí (v tomto příkladu je to událost MouseEvent).
U řady událostí je tento objekt instancí třídy Event. V případě událostí myši je to instance třídy MouseEvent.
U dalších událostí se jedná o instanci třídy, která je spojena s danou událostí. Tento vytvořený objekt se nazývá
objekt události a obsahuje specifické informace o události, která proběhla: o jaký typ události se jedná, kde k ní
došlo a ostatní informace specifické pro danou událost, pokud jsou k dispozici.
b Počítač poté vyhledá posluchače událostí uložené objektem myButton. Postupně projde tyto funkce, zavolá
každou z nich a předá objekt události funkci jako parametr. Jelikož je funkce eventResponse() jednou z
posluchačů objektu myButton, jako součást tohoto procesu počítač zavolá funkci eventResponse().
13
c Když je zavolána funkce eventResponse(), kód v této funkci se spustí, takže jsou vykonány specifikované
činnosti.
Příklady zpracování událostí
Zde je uvedeno několik konkrétnějších příkladů kódu pro zpracování událostí. Pomocí těchto příkladů se seznámíte
s několika běžnými elementy událostí a s možnými obměnami, které jsou při psaní kódu pro zpracování událostí
k dispozici:
• Klepnutím na tlačítko spustíte přehrávání stávajícího filmového klipu. V následujícím příkladu je playButton
název instance tlačítka a this je speciální název, mající význam „stávající objekt“:
this.stop();
function playMovie(event:MouseEvent):void
{
this.play();
}
playButton.addEventListener(MouseEvent.CLICK, playMovie);
• Detekce zadávání textu do pole. V tomto příkladu je entryText vstupní textové pole a outputText je dynamické
textové pole:
function updateOutput(event:TextEvent):void
{
var pressedKey:String = event.text;
outputText.text = "You typed: " + pressedKey;
}
entryText.addEventListener(TextEvent.TEXT_INPUT, updateOutput);
• Klepnutí na tlačítko a přesun na adresu URL. V tomto příkladu je linkButton názvem instance tlačítka:
function gotoAdobeSite(event:MouseEvent):void
{
var adobeURL:URLRequest = new URLRequest("http://www.adobe.com/");
navigateToURL(adobeURL);
}
linkButton.addEventListener(MouseEvent.CLICK, gotoAdobeSite);
14
Vytváření instancí objektu
Aby bylo možné objekt v jazyce ActionScript použít, musí tento objekt nejprve existovat. Jednou z částí procesu
vytváření objektu je deklarování proměnné. Toto deklarování však pouze vytvoří prázdné místo v paměti počítače.
Proměnné vždy přiřaďte skutečnou hodnotu (vytvořte objekt a uložte jej do proměnné), než ji zkusíte použít nebo
zpracovat. Procesu tvorby objektu se říká vytvoření instance objektu. Jinými slovy vytvoříte instanci určité třídy.
Jednoduchý způsob vytvoření instance objektu vůbec nevyžaduje jazyk ActionScript. V aplikaci Flash Professional
umístěte na plochu symbol filmového klipu, symbol tlačítka nebo textové pole a přiřaďte mu název instance. Aplikace
Flash Professional automaticky deklaruje proměnnou s tímto názvem instance, vytvoří instanci objektu a uloží tento
objekt do proměnné. Podobně lze i v aplikaci Flex vytvořit komponentu v jazyce MXML buďto napsáním kódu tagu
MXML, nebo umístěním komponenty do editoru aplikace Flash Builder v režimu Design. Když této komponentě
přiřadíte ID, stane se z tohoto ID název proměnné v jazyce ActionScript obsahující instanci této komponenty.
Někdy však nemusíte chtít vytvářet objekt vizuálně a u nevizuálních objektů to není možné. Existuje řada dalších
způsobů, jak lze vytvořit instance objektů pouze pomocí jazyka ActionScript.
S několika datovými typy jazyka ActionScript můžete vytvořit instanci pomocí literálového výrazu, což je hodnota
zapsaná přímo do kódu jazyka ActionScript. Zde jsou uvedeny některé příklady:
• Literálová číselná hodnota (zadejte číslo přímo):
var someNumber:Number = 17.239;
var someNegativeInteger:int = -53;
var someUint:uint = 22;
• Literálová hodnota řetězce (text uložte do uvozovek):
var firstName:String = "George";
var soliloquy:String = "To be or not to be, that is the question...";
• Literálové booleovská hodnota (použijte literálové hodnoty true nebo false):
var niceWeather:Boolean = true;
var playingOutside:Boolean = false;
• Literálová hodnota pole (seznam hodnot oddělených čárkami v vložte do hranatých závorek):
var seasons:Array = ["spring", "summer", "autumn", "winter"];
• Literálová hodnota XML (zadejte XML přímo):
var employee:XML = <employee>
<firstName>Harold</firstName>
<lastName>Webster</lastName>
</employee>;
Jazyk ActionScript také definuje literálové výrazy pro datové typy Array, RegExp, Object a Function.
Nejběžnější způsob vytvoření instance pro libovolný datový typ je použití operátoru new s názvem třídy, jak je
znázorněno zde:
var raceCar:MovieClip = new MovieClip();
var birthday:Date = new Date(2006, 7, 9);
Vytvoření objektu pomocí operátoru new je často označováno jako „volání konstruktoru třídy“. Konstruktor je
speciální metodou volanou jako část procesu vytváření instance třídy. Všimněte si, že při vytváření instance tímto
způsobem se za název třídy vkládají závorky. Někdy se v závorkách definují hodnoty parametrů. Tyto dvě činnosti se
rovněž provádějí při volání metody.
I pro datové typy, které umožňují vytvářet instance pomocí literálového výrazu, lze rovněž použít operátor new
k vytvoření instance objektu. Například tyto dva řádky kódu provádějí stejnou činnost:
15
var someNumber:Number = 6.33;
var someNumber:Number = new Number(6.33);
Je důležité se dobře seznámit s vytvářením objektů způsobem newClassName(). Řada datových typů jazyka
ActionScript nemá vizuální znázornění. Tudíž je nelze vytvořit umístěním položky na plochu aplikace Flash
Professional ani v režimu Design editoru MXML aplikace Flash Builder. Instance těchto datových typů lze v jazyce
ActionScript vytvářet pouze pomocí operátoru new.
V aplikaci Flash Professional lze operátor new rovněž použít k vytvoření instance symbolu filmového klipu, který je
definován v knihovně, ale není umístěn na ploše.
Další témata nápovědy
Práce s poli
Používání regulárních výrazů
Vytváření objektů MovieClip pomocí kódu ActionScript
Společné prvky programu
Při vytváření programu v jazyce ActionScript se používá také několik dalších stavebních bloků.
Operátory
Operátory jsou speciální symboly (nebo příležitostně slova), která jsou používána k provádění výpočtů. Jsou většina
používány pro matematické operace a rovněž pro porovnávání hodnot. Operátor obecně používá jednu nebo více
hodnot a „vypracuje“ jeden výsledek. Například:
• Operátor sčítání (+) sečte dvě hodnoty a vytvoří jedno číslo:
var sum:Number = 23 + 32;
• Operátor násobení (*) vynásobí jednu hodnotu druhou a vytvoří jedno číslo:
var energy:Number = mass * speedOfLight * speedOfLight;
• Operátor rovnosti (==) porovná dvě hodnoty a poskytne výsledek ve formě jedné booleovské hodnoty (pravda nebo
nepravda).
if (dayOfWeek == "Wednesday")
{
takeOutTrash();
}
Jak je zde znázorněno, operátor rovnosti a další operátory „porovnání“ se nejčastěji používají s příkazem if, který
určí, zda budou určité pokyny vykonány nebo nikoliv.
16
Poznámky
Při psaní kódu v jazyce ActionScript si pro sebe můžete chtít nechat některé poznámky. Někdy například chcete
vysvětlit, jak fungují některé řádky kódu, nebo proč byla zvolena určitá možnost. Komentáře kódu jsou nástrojem pro
zapsání textu, který bude počítač v kódu ignorovat. Jazyk ActionScript zahrnuje dva typy komentářů:
• Jednořádkový komentář: jednořádkový komentář je označen vložením dvou lomítek kdekoliv do řádky. Počítač
ignoruje vše, co následuje za lomítky až na konec daného řádku:
// This is a comment; it's ignored by the computer.
var age:Number = 10; // Set the age to 10 by default.
• Víceřádkový komentář: víceřádkový komentář zahrnuje značku počátku (/*), pak samotný obsah a nakonec
značku konce (*/). Počítač ignoruje vše mezi počáteční a koncovou značkou bez ohledu na to, kolik řádků
komentář zahrnuje:
/*
This is a long description explaining what a particular
function is used for or explaining a section of code.
In any case, the computer ignores these lines.
*/
Dále se komentáře běžně používají k dočasnému „vypnutí“ jednoho či několika řádků kódu. Komentáře lze například
využít, jestliže zkoušíte jiný způsob provedení určité věci. Rovněž je můžete použít, když se snažíte zjistit, proč určitý
kód v jazyce ActionScript nefunguje podle očekávání.
Řízení toku
Mnohokrát potřebujete v programu opakovat jisté činnosti, provést pouze některé činnosti a jiné nikoliv, provést
alternativní činnosti v závislosti na určitých podmínkách atd. Řízení toku je ovládáním provádění jednotlivých
činností. Existuje několik typů prvků řízení tok, které jsou v jazyce ActionScript dostupné.
• Funkce: funkce jsou jako zástupci. Poskytují možnost seskupení řady činností pod jedním názvem a mohou být
použity k provedení výpočtů. Funkce jsou nezbytné ke zpracování událostí, slouží ale také jako obecné nástroje
k seskupení řady pokynů.
• Cykly: Struktury cyklů umožňují označit sadu pokynů, kterou počítač provádí po stanovený počet opakování nebo
dokud se nezmění stanovená podmínka. Cykly se často používají pro zpracování několika souvisejících položek,
pomocí proměnné, jejíž hodnota se změní pokaždé, když počítač dokončí jednotlivý cyklus.
• Podmíněné příkazy: podmíněné příkazy poskytují způsob pro vymezení určitých pokynů, které budou provedeny
pouze za jistých podmínek. Rovněž se používají k vytvoření alternativních sad pokynů pro odlišné podmínky.
Nejběžnějším typem podmíněného příkazu je příkaz if. Příkaz if kontroluje hodnotu nebo výraz v závorkách.
Mají-li hodnotu true, budou řádky kódu ve složených závorkách provedeny. V opačném případě budou
ignorovány. Například:
if (age < 20)
{
// show special teenager-targeted content
}
Společník příkazu if, příkaz else, umožňuje určit alternativní pokyny, které počítač provede, pokud podmínka
nebude mít hodnotu true:
17
if (username == "admin")
{
// do some administrator-only things, like showing extra options
}
else
{
// do some non-administrator things
}
Příklad: Animace portfolia (Flash Professional)
Tento příklad je navržen tak, abyste měli příležitost vidět, jak lze sestavit kusy kódu ActionScript do kompletní
aplikace. Část s portfoliem animací ukazuje, že je možné vzít existující lineární animaci a přidat několik drobných
interaktivních prvků. Do online portfolia lze například začlenit animaci vytvořenou pro klienta. Interaktivní chování,
které se přidá do animace, zahrnuje dvě tlačítka, na než může uživatel kliknout: jedno pro spuštění animace a druhé
pro přechod na samostatnou adresu URL (například nabídka portfolia nebo úvodní stránka autora).
Proces vytvoření tohoto kusu lze rozdělit do následujících hlavních částí:
1 Připravení souboru FLA pro přidání kódu v jazyce ActionScript a interaktivních prvků.
2 Vytvoření a přidání tlačítek.
3 Zapsání kódu v jazyce ActionScript.
4 Testování aplikace.
Příprava na přidání interaktivních prvků
Před přidáním interaktivních prvků do animace je vhodné nastavit soubor FLA vytvořením několika míst pro přidání
nového obsahu. Tato úloha zahrnuje vytvoření vlastního prostoru na ploše, kam lze umístit tlačítka. Rovněž zahrnuje
vytvoření „prostoru“ v souboru FLA, aby různé položky zůstaly oddělené.
Chcete-li nastavit soubor FLA pro přidání interaktivních prvků:
1 Vytvořte soubor FLA s jednoduchou animací, např. s jedním doplněním pohybu nebo doplněním tvaru. Jestliže již
máte soubor FLA obsahující animaci, která se objevuje v projektu, otevřete tento soubor a uložte jej pod jiným
názvem.
2 Rozhodněte, kde na ploše se mají tato dvě tlačítka zobrazit. Jedno tlačítko slouží ke spuštění animace a druhé
k přechodu do portfolia autora nebo na úvodní stránku. V případě potřeby pro tento nový obsah uvolněte nebo
přidejte další prostor na ploše. Pokud animace dosud nemá spouštěcí obrazovku, můžete ji vytvořit na prvním
snímku. V takovém případě zřejmě budete chtít animaci posunout, aby začínala od snímku 2 nebo později.
3 Přidejte novou vrstvu nad ostatní vrstvy v časové ose a pojmenujte ji tlačítka. V této vrstvě se budou přidávat
tlačítka.
4 Přidejte novou vrstvu nad vrstvu tlačítek a pojmenujte ji actions. V této vrstvě přidáte do aplikace kód
ActionScript.
Vytváření a přidávání tlačítek
Následně zřejmě přidáte a rozmístíte tlačítka tvořící jádro interaktivní aplikace.
18
Vytvoření a přidání tlačítek do souboru FLA:
1 Pomocí nástrojů kreslení vytvořte vizuální vzhled prvního tlačítka (tlačítko přehrávání) na vrstvě tlačítek.
Například můžete nakreslit vodorovný ovál s textem nad ním.
2 Pomocí nástroj výběru vyberte všechny součásti grafiky jednoho tlačítka.
3 V hlavní nabídce zvolte Změnit > Převést na symbol.
4 V dialogovém okně zvolte jako typ symbolu Tlačítko, zadejte název a klepněte na tlačítko OK.
5 S vybraným tlačítkem Inspektor vlastností stanoví pro tlačítko název instance playButton.
6 Opakujte kroky 1 až 5 a vytvořte tlačítko, které přesune uživatele na domovskou stránku autora. Pojmenujte toto
tlačítko homeButton.
Zápis kódu
Kód ActionScript pro tuto aplikaci lze rozdělit do tří souborů funkčnosti, i když vše bude zadáváno na jednom místě.
Kód provádí následující tři věci:
• Zastavit přehrávací hlavu, jakmile se soubor SWF načte (když přehrávací hlava najede na snímek 1).
• Naslouchat události, která spustí přehrávání souboru SWF, když uživatel klepne na tlačítko přehrávání.
• Naslouchat události, která odešle prohlížeč na příslušnou stránku URL, když uživatel klepne na tlačítko výchozí
webové stránky autora.
Vytvoření kódu, který zastaví přehrávací hlavu po najetí na snímek 1:
1 Zvolte klíčový snímek jako snímek 1 vrstvy akcí.
2 Otevřete panel Akce z hlavní nabídky vybráním možnosti Okno > Akce.
3 V panelu Skript zadejte následující kód:
stop();
Zapsání kódu, který spustí animaci, když klepnete na tlačítko přehrávání:
1 Na konci kódu zadaného v předchozích krocích přidejte dvě prázdné řádky.
2 Na konec skriptu zadejte následující kód:
function startMovie(event:MouseEvent):void
{
this.play();
}
Tento kód definuje funkci nazvanou startMovie(). Když zavoláte funkci startMovie(), způsobí spuštění
přehrávání hlavní časové osy.
3 Na řádku za kódem přidaným v předchozím kroku zadejte tento řádek kódu:
playButton.addEventListener(MouseEvent.CLICK, startMovie);
Tento řádek kódu registruje funkci startMovie() jako posluchače pro událost click tlačítka playButton. Jinými
slovy, kdykoliv klepnete na tlačítko pojmenované playButton, je zavolána funkce startMovie().
Chcete-li zapsat kód pro přesměrování prohlížeče na adresu URL, když je klepnuto na tlačítko výchozí stránky:
1 Na konci kódu zadaného v předchozích krocích přidejte dvě prázdné řádky.
2 Na konec skriptu zadejte následující kód:
19
function gotoAuthorPage(event:MouseEvent):void
{
var targetURL:URLRequest = new URLRequest("http://example.com/");
navigateToURL(targetURL);
}
Tento kód definuje funkci nazvanou gotoAuthorPage(). Tato funkce nejprve vytvoří instanci třídy URLRequest
představující adresu URL http://example.com/. Ta potom předá tuto adresu URL funkci navigateToURL(),
následkem čehož prohlížeč uživatele tuto adresu URL otevře.
3 Na řádku za kódem přidaným v předchozím kroku zadejte tento řádek kódu:
homeButton.addEventListener(MouseEvent.CLICK, gotoAuthorPage);
Tento řádek kódu registruje funkci gotoAuthorPage() jako posluchače pro událost click tlačítka homeButton.
Jinými slovy, kdykoliv klepnete na tlačítko pojmenované homeButton, je zavolána funkce gotoAuthorPage().
Testování aplikace
Nyní je aplikace plně funkční. Otestujme ji a přesvědčme se o tom.
Testování aplikace:
1 V hlavní nabídce zvolte Ovládání > Testovat film. Aplikace Flash Professional vytvoří soubor SWF a otevře jej
v okně Flash Player.
2 Vyzkoušejte obě tlačítka a ujistěte se, že provádějí přesně ty činnosti, které zamýšlíte.
3 Pokud tlačítka nepracují, měli byste ověřit následující:
• Mají obě tlačítka odlišné názvy instancí?
• Volají metody addEventListener() použití stejných názvů, jako jsou názvy instancí tlačítek?
• Jsou použité správné názvy událostí ve volání metody addEventListener()?
• Je specifikován správný parametr pro každou funkci? (Obě metody by měly mít jeden parametr s datovým
typem MouseEvent.)
Všechny tyto chyby, jakož i většina ostatních možných chyb, vedou k zobrazení chybové zprávy. Chybová zpráva
se může zobrazit buďto po zvolení příkazu Testovat film, nebo při kliknutí na toto tlačítko během testování
projektu. Na panelu Chyby kompilátoru vyhledejte chyby kompilátoru (ty, k nimž dochází při prvním zvolení
příkazu Testovat film). Na panelu Výstupy zkontrolujte chyby běhu programu, ke kterým dochází během
přehrávání obsahu, např. při kliknutí na tlačítko.
Vytváření aplikací v jazyce ActionScript
Proces psaní kódu v jazyce ActionScript a vytváření aplikace zahrnuje více než jenom znalost syntaxe a názvů tříd,
které použijete. Tato dvě témata popisuje většina dokumentace řešení Flash Platform (syntaxe a použití tříd jazyka
ActionScript). Avšak k vytvoření aplikace v jazyce ActionScript bude rovněž třeba znát například následující
informace:
• Jaké programy lze použít k psaní kódu v jazyce ActionScript.
• Jak se kód v jazyce ActionScript organizuje?
• Jak se vkládá kód v jazyce ActionScript do aplikace?
• Podle jakých kroků se postupuje při vyvíjení aplikace v jazyce ActionScript?
20
Možnosti organizování kódu
Kód jazyka ActionScript 3.0 můžete použít pro cokoliv, od jednoduchých grafických aplikací, až po složité systém
zpracování transakcí klient-server. V závislosti na typu vytvářené aplikace použijte jeden nebo několik těchto různých
způsobů zahrnutí kódu ActionScript do projektu.
Uložení kódu do snímků časové osy aplikace Flash Professional
Ve vývojovém prostředí aplikace Flash Professional lze přidat kód ActionScript ke kterémukoliv snímku v časové ose.
Tento kód bude vykonán při přehrávání filmu, když přehrávací hlava najede na daný snímek.
Umístění kódu ActionScript dovnitř snímků poskytuje jednoduchý způsob, jak lze přidávat chování do aplikací
vytvořených v aplikaci Flash Professional. Můžete přidat kód ke kterémukoliv snímku v hlavní časové ose nebo ke
kterémukoliv snímku v časové ose kteréhokoliv symbolu MovieClip. Tato flexibilita však není zdarma. Když vytváříte
větší aplikace, snadno ztratíte povědomí o tom, které snímky obsahují které skripty. To může po čase způsobit
obtížnější údržbu aplikace.
Mnoho vývojářů zjednodušuje organizaci kódu ActionScript v aplikaci Flash Professional vložením kódu pouze do
prvního snímku časové osy, nebo do určité vrstvy dokumentu Flash. To usnadňuje lokalizaci a údržbu kódu
v souborech FLA aplikace Flash. Nicméně stejný kód nelze použít v jiném projektu aplikace Flash Professional bez
toho, aby byl kód zkopírován a vložen do nového souboru.
Aby bylo použití kódu jazyka ActionScript snazší v budoucnu v dalších projektech aplikace Flash Professional, uložte
kód do externích souborů jazyka ActionScript (textové soubory s příponou .as).
Vkládání kódu do souborů Flex MXML
Ve vývojovém prostředí aplikace Flex, např. Flash Builder, lze zahrnout kód jazyka ActionScript do tagu <fx:Script>
v souboru Flex MXML. Nicméně použití této techniky může přidat velkým projektům na složitosti a znesnadnit
použití stejného kódu v jiném projektu Flex. Aby bylo použití kódu jazyka ActionScript v dalších projektech Flex
v budoucnu snazší, uložte kód do externích souborů jazyka ActionScript.
Poznámka: Lze definovat zdrojový parametr pro tag <fx:Script>. Pomocí zdrojového parametru lze „importovat“ kód
jazyka ActionScript z externího souboru, jako kdyby byl vepsán přímo v tagu <fx:Script>. Použitý zdrojový soubor
však nemůže definovat vlastní třídu, což omezuje jeho opakovatelnou použitelnost.
Uložení kódu v souborech ActionScript
Pokud projekt zahrnuje velkou část v kódu ActionScript, nejlepším způsobem organizace kódu je jeho oddělení do
samostatných souborů ActionScript (textové soubory s příponou .as). Soubor ActionScript může být strukturován
jedním ze dvou způsobů, v závislosti na tom, jak jej zamýšlíte použít v aplikaci.
• Nestrukturovaný kód ActionScript: řádky kódu ActionScript, včetně definic příkazů nebo funkcí, zapsané jako by
byly zadány přímo do skriptu časové osy či souboru MXML.
Kód ActionScript zapsaný tímto způsobem je přístupný v jazyce ActionScript pomocí příkazu include, nebo
v jazyce Flex MXML pomocí tagu <mx:Script>. Příkaz include jazyka ActionScript říká kompilátoru, aby na
určité místo a v daném rozsahu ve skriptu zahrnul obsah externího souboru jazyka ActionScript. Výsledek je stejný,
jako kdyby tam byl kód zadán přímo. V jazyce MXML se pomocí tagu <fx:Script> s atributem zdroje určuje
externí kód ActionScript, který kompilátor načte v dané chvíli do aplikace. Například následující tag načte externí
soubor jazyka ActionScript s názvem Box.as:
<fx:Script source="Box.as" />
• Definice třídy ActionScript: definice třídy ActionScript, včetně definic metody a vlastností.
21
Při definování třídy lze získat přístup ke kódu ActionScript v této třídě vytvořením instance dané třídy a použitím
jejích vlastností, metod a událostí. Použití vlastních tříd je stejné jako použití vestavěných tříd ActionScript
a vyžaduje dvě části:
• Použití příkazu import pro specifikování úplného názvu třídy, aby kompilátor jazyka ActionScript věděl, kde
jej má nalézt. Chcete-li například použít třídu MovieClip v jazyce ActionScript, importujte ji pomocí jejího
úplného názvu včetně balíku a třídy:
import flash.display.MovieClip;
Alternativně můžete importovat balík, který obsahuje třídu MovieClip, což je ekvivalent pro zápis samostatného
příkazu import pro každou třídu v balíku.
import flash.display.*;
Jedinou výjimkou z pravidla, že třída musí být importována, aby ji bylo možné použít v kódu, jsou třídy nejvyšší
úrovně. Tyto třídy nejsou definovány v balíku.
• Zadejte kód, který výslovně používá název třídy. Deklarujte například proměnnou s touto třídou jako jejím
datovým typem a vytvořte instanci této třídy, jež bude v proměnné uložena. Použitím třídy v kódu ActionScript
sdělujete kompilátoru, aby načetl definici dané třídy. Například pro externí třídu s názvem Box by tento příkaz
vytvořil instanci třídy Box:
var smallBox:Box = new Box(10,20);
Když kompilátor poprvé narazí na odkaz na třídu Box, prohledá dostupný zdrojový kód, aby nalezl definici třídy Box.
Výběr správného nástroje
Pro psaní a úpravu kódu ActionScript lze použít jeden z mnoha nástrojů (nebo několik nástrojů dohromady).
Flash Builder
Aplikace Adobe Flash Builder je nejlepší nástroj pro vytváření projektů s architekturou Flex, nebo projektů
sestávajících především z kódu ActionScript. Aplikace Flash Builder rovněž zahrnuje plnohodnotný editor jazyka
ActionScript, jakož i možnost vizuálního rozvržení a upravování jazyka MXML. Lze ji použít k vytváření projektů
s architekturou Flex nebo projektů zahrnujících pouze jazyk ActionScript. Architektura Flex poskytuje několik výhod,
včetně bohaté sady předem vytvořených ovládacích prvků uživatelského rozhraní, flexibilních ovládacích prvků
dynamického uspořádání a vestavěných mechanismů pro práci s externími datovými zdroji a propojování externích
dat s prvky uživatelského rozhraní. Nicméně kvůli množství dalšího kódu nezbytného pro zajištění těchto funkcí
mohou mít projekty používající architekturu Flex větší soubory SWF než jejich protějšky, které architekturu Flex
nepoužívají.
Aplikaci Flash Builder použijte, pokud vytváříte plnohodnotné, výkonné, datově řízené internetové aplikace
s architekturou Flex. Použijte ji, jestliže chcete upravovat kód ActionScript, upravovat kód MXML a provádět vizuální
rozvržení aplikace, to vše v rámci jediného nástroje.
Řada uživatelů aplikace Flash Professional, kteří vytvářejí projekty zahrnující velké množství kódu ActionScript,
používá aplikaci Flash Professional k vytváření vizuálních datových zdrojů a aplikaci Flash Builder jako editor pro kód
ActionScript.
22
Flash Professional
Kromě grafických a animačních schopností zahrnuje aplikace Flash Professional nástroje pro práci s kódem
ActionScript. Kód může být připojený k elementům v souboru FLA nebo v externích souborech obsahujících pouze
jazyk ActionScript. Aplikace Flash Professional je ideální pro projekty obsahující z podstatné části animaci či video. Je
užitečná, když chcete většinu grafických datových zdrojů vytvářet sami. Dalším důvodem k použití aplikace Flash
Professional při vyvíjení projektu v jazyce ActionScript je vytváření vizuálních datových zdrojů a zapisování kódu ve
stejné aplikaci. Aplikace Flash Professional rovněž zahrnuje předem vytvořené komponenty uživatelského rozhraní.
Použitím těchto komponent lze docílit menší velikosti souborů SWF a pomocí vizuálních nástrojů je možné upravovat
jejich vzhled v daném projektu.
Aplikace Flash Professional zahrnuje dva nástroje pro zápis kódu v jazyce ActionScript:
• Panel Akce: dostupný při práci na souboru FLA. tento panel umožňuje zapisovat kód ActionScript připojený je
snímkům v časové ose.
• Okno Skript: okno Skript je vyhrazeným textovým editorem pro práci s kódem v jazyce ActionScript (soubory .as).
Editor jazyka ActionScript od jiných výrobců
Jelikož jsou soubory jazyka ActionScript (.as) uloženy jako jednoduché textové soubory, lze k psaní souborů jazyka
ActionScript použít jakýkoliv program schopný editace prostého textu. Kromě produktů ActionScript od Adobe
existuje několik textových editorů třetích stran, se specifickými schopnostmi práce s kódem ActionScript. Soubor
MXML nebo třídy ActionScript můžete zapisovat pomocí kteréhokoliv textového editoru. Pak můžete z těchto
souborů vytvořit aplikaci pomocí sady Flex SDK. Projekt může využívat architekturu Flex, nebo se může jednat
o aplikaci obsahující pouze jazyk ActionScript. Někteří vývojáři případně používají aplikaci Flash Builder nebo editor
jazyka ActionScript jiného výrobce k zápisu tříd ActionScript v kombinaci s aplikací Flash Professional k vytváření
grafického obsahu.
K použití editoru jazyka ActionScript jiného výrobce existují například následující důvody:
• Dáváte přednost zapisování kódu ActionScript v samostatném programu a navrhování vizuálních elementů
v aplikaci Flash Professional.
• Používáte aplikaci pro programování v jiném jazyce než ActionScript (například vytváření stránek HTML nebo
vytváření aplikací v jiném programovacím jazyce) a chcete používat stejnou aplikaci také pro zápis kódu v jazyce
ActionScript.
• Chcete vytvořit projekty obsahující pouze jazyk ActionScript nebo projekty Flex pomocí sady Flex SDK, bez použití
aplikace Professional nebo Flash Builder.
Některé vhodné editory programového kódu se specifickou podporou jazyka ActionScript zahrnují:
• Adobe Dreamweaver® CS4
• ASDT
• FDT
• FlashDevelop
• PrimalScript
• SE|PY
• TextMate (s balíky ActionScript a Flex)
23
Proces vývoje kódu v jazyce ActionScript
Bez ohledu na to, zda je projekt v jazyce ActionScript velký nebo malý, proces návrhu a vývoje aplikace celou práci
zefektivní. Následující kroky popisují základní proces vývoje aplikace pomocí ActionScript 3.0:
1 Navrhněte aplikaci.
Před započetím vývoje aplikaci vhodným způsobem popište.
2 Sestavte kód v jazyce ActionScript 3.0.
Kód ActionScript lze vytvořit pomocí aplikací Flash Professional, Flash Builder, Dreamweaver nebo textového
editoru.
3 Vytvořte projekt Flash nebo Flex, který spustí váš kód.
V aplikaci Flash Professional vytvořte soubor FLA, zadejte nastavení publikování, přidejte do aplikace komponenty
uživatelského rozhraní a vytvořte odkaz na kód ActionScript. V architektuře Flex definujte aplikaci, pomocí jazyka
MXML přidejte komponenty uživatelského rozhraní a vytvořte odkaz na kód ActionScript.
4 Publikujte a otestujte svou aplikaci ActionScript.
V rámci testování aplikace spusťte aplikaci ze svého vývojového prostředí a ujistěte se, že provádí všechny
zamýšlené operace.
Všimněte si, že není nutné provádět tyto kroky v přesně uvedeném pořadí, nebo dokončit jeden krok před započetím
jiného. Můžete například navrhnout jednu obrazovku aplikace (krok 1), pak vytvořit grafiku, tlačítka atd. (krok 3) a až
poté napsat kód v jazyce ActionScript (krok 2) a provést testování (krok 4). Nebo můžete navrhnout část, pak přidat
jedno tlačítko nebo prvek rozhraní, zapsat kód v jazyce ActionScript pro každý z těchto prvků a otestovat jej v daném
provedení. Je užitečné si tyto čtyři fáze procesu vývoje zapamatovat. Nicméně při vývoji v reálném prostředí je
mnohem efektivnější přeskakovat mezi těmito fázemi podle potřeby.
Vytváření vlastních tříd
Proces vytváření tříd pro použití ve vašich projektech může vypadat skličující. Obtížnější částí vytvoření třídy je však
její návrh jejích metod, vlastností a událostí.
Strategie vytváření třídy
Téma objektově orientovaného návrhu je komplexní. Celé kariéry mnoha osob byly věnovány akademickému studiu
a profesionální praxi v této disciplíně. Existuje však několik doporučovaných přístupů. které mohou v začátcích
pomoci.
1 Přemýšlejte o úloze, kterou hrají instance této třídy v dané aplikaci. Obecně objekty slouží jedné z těchto tří rolí:
• Objekt Value: tyto objekty slouží především jako kontejnery dat. Pravděpodobně mají řadu vlastností a méně
metod (nebo někdy žádné metody). Obecně jsou vyjádřením kódu jasně definovaných položek. Například
aplikace pro přehrávání hudby by mohla zahrnovat třídu Song představující jedinou skladbu a třídu Playlist
představující koncepční skupinu skladeb.
• Objekt Display: Tyto objekty se ve skutečnosti zobrazují na obrazovce. Patří k nim prvky uživatelského rozhraní,
například rozevírací seznam nebo indikace stavu, grafické prvky, jako jsou příšery ve video hře atd.
24
• Struktura aplikace: tyto objekty zajišťují širokou škálu podpůrných úloh v logice a zpracování prováděných
aplikacemi. Můžete například vytvořit objekt, který bude provádět určité výpočty v biologické simulaci. Můžete
vytvořit jeden objekt, který bude mít na starosti synchronizaci hodnot mezi volicím ovladačem a indikací
hlasitosti v aplikaci pro přehrávání hudby. Další objekt může spravovat pravidla ve videohře. Nebo můžete
vytvořit třídu, která načte uložený obraz do kreslicí aplikace.
2 Rozhodněte, jakou specifickou funkčnost musí třída mít. Různé typy funkcí se často stávají metodami třídy.
3 Pokud má třída sloužit jako objekt hodnoty, rozhodněte se, která data budou instance zahrnovat. Tyto položky jsou
vhodnými kandidáty pro vlastnosti.
4 Protože třída je navrhována specificky pro váš projekt, nejdůležitější je poskytnout funkčnost, kterou vyžaduje vaše
aplikace. Zkuste si odpovědět na následující otázky:
• Jaké kusy informací aplikace ukládá, sleduje a zpracovává? Odpověď na tuto otázku vám pomůže určit potřebné
objekty hodnot a vlastnosti.
• Jaké sady akcí aplikace provádí? Co se stane například při prvním načtení aplikace, při stisknutí určitého
tlačítka, při ukončení přehrávání filmu atd.? Toto jsou vhodní kandidáti na metody. Také to mohou být
vlastnosti, pokud „akce“ zahrnují změnu jednotlivých hodnot.
• Jaké informace vyžaduje jakákoliv daná akce, aby byla provedena? Tyto části informací se stávají parametry
metody.
• Když aplikace pokračuje v činnosti, kterou má vykonávat, k jakým změnám dojde ve vaší třídě, o nichž budou
jiné části této aplikace muset vědět? Toto jsou vhodní kandidáti na události.
5 Existuje již nějaký objekt, který by se podobal požadovanému objektu až na to, že postrádá některé dodatečné
funkce, jež chcete přidat? Zvažte vytvoření podtřídy. (Podtřída je třída, která staví na funkčnosti existující třídy, než
aby definovala všechny své funkce.) Chcete-li například vytvořit třídu, jíž je vizuální objekt na obrazovce, použijte
jako základ vlastní třídy chování existujícího objektu zobrazení. V takovém případě bude objekt zobrazení
(například objekt MovieClip nebo Sprite) základní třídou a vlastní třída bude tuto třídu rozšiřovat.
Zápis kódu pro třídu
Jakmile máte návrh vlastní třídy, nebo alespoň určitou představu o tom, jaké informace bude ukládat a jaké akce bude
provádět, je vlastní syntaxe zápisu třídy poměrně přímočará.
Zde jsou minimální kroky, které byste měli vytvořit ve vlastní třídě ActionScript:
1 Otevřete v programu textového editoru jazyka ActionScript nový textový dokument.
2 Zadáním příkazu classdefinujte název třídy. Chcete-li přidat příkaz class, zadejte slova public class
a následně název třídy. Přidejte levou a pravou složenou závorku, mezi nimiž bude uzavřen obsah třídy (definice
metod a vlastností). Například:
public class MyClass
{
}
Slovo public označuje, že třída může být přístupná z jiného libovolného kódu. Jiné alternativy naleznete v kapitole
Atributy jmenného prostoru řízení přístupu.
3 Zadáním příkazu package určete název balíku obsahujícího danou třídu. Syntaxí je slovo package, po kterém
následuje úplný název balíku, za nímž je umístěna levá a pravá složená závorka kolem bloku příkazu class. Změňte
například kód v předchozím kroku na následující:
25
package mypackage
{
public class MyClass
{
}
}
4 Definujte každou vlastnost ve třídě pomocí příkazu var v těle třídy. Syntaxe je stejná jako při deklarování kterékoliv
proměnné (s přidáním modifikátoru public). Například přidáním těchto řádek mezi levou a pravou složenou
závorku definice třídy se vytvoří vlastnosti pojmenované textProperty, numericProperty a dateProperty:
public var textProperty:String = "some default value";
public var numericProperty:Number = 17;
public var dateProperty:Date;
5 Definujte každou metodu ve třídě pomocí stejné syntaxe, kterou použijete pro definování funkce. Například:
• Chcete-li vytvořit metodu myMethod(), zadejte:
public function myMethod(param1:String, param2:Number):void
{
// do something with parameters
}
• Chcete-li vytvořit konstruktor (speciální metoda, která je volaná jako součást procesu vytváření instance třídy),
vytvoření metody, jejíž název odpovídá přesně názvu třídy:
public function MyClass()
{
// do stuff to set initial values for properties
// and otherwise set up the object
textVariable = "Hello there!";
dateVariable = new Date(2001, 5, 11);
}
Pokud do třídy nezahrnete metodu konstruktoru, kompilátor automaticky vytvoří v dané třídě prázdný
konstruktor. (Jinými slovy konstruktor bez jakýchkoliv parametrů a příkazů.)
Kromě toho lze definovat i několik dalších elementů třídy. Tyto elementy jsou složitější.
• Zpřístupňovače jsou speciální přechody mezi metodou a vlastností. Při zápisu kódu pro definování třídy
zapisujete zpřístupňovač jako metodu. Můžete provádět několik akcí a nikoliv jen čtení nebo přiřazení hodnoty,
což je to jediné, co lze provádět při definování vlastnosti. Nicméně když vytváříte instanci vlastní třídy, zacházíte
se zpřístupňovačem jako s vlastností a používáte název ke čtení nebo přiřazení hodnoty.
• Události v jazyce ActionScript nejsou definované pomocí specifické syntaxe. Místo toho definujete události ve
třídě pomocí funkcí třídy EventDispatcher.
Zpracování událostí
Příklad: Vytváření základních aplikací
Jazyk ActionScript 3.0 lze použít v řadě prostředí pro vývoj aplikací, včetně nástrojů Flash Professional a Flash Builder,
nebo v libovolném textovém editoru.
26
Tento příklad prochází kroky při vytváření a zlepšování jednoduché aplikace v kódu ActionScript 3.0 pomocí aplikace
Flash Professional nebo Flash Builder. Vytvořená aplikace představuje jednoduchý vzor k použití externích souborů
třídy ActionScript 3.0 v aplikacích Flash Professional a Flex.
Návrh aplikace ActionScript
Tato vzorová aplikace v jazyce ActionScript je standardní aplikace s nápisem „Hello World“, takže její návrh je
jednoduchý:
• Aplikace se nazývá Hello World.
• Zobrazuje jediné textové pole se slovy „Hello World!“.
• Aplikace používá jedinou objektově orientovanou třídu s názvem Greeter. Tento návrh umožňuje použití třídy
z projektu Flash Professional nebo Flex.
• V tomto příkladu nejprve vytvoříte základní verzi aplikace. Potom přidáte funkce, pomocí nichž uživatel zadá
jméno uživatele a aplikace zkontroluje jméno podle seznamu známých uživatelů.
Se stručným definováním můžete začít vytvářet aplikaci samotnou.
Vytváření projektu Hello World a třídy Greeter
Návrh příkazu pro aplikaci Hello World říká, že kód je snadno opakovaně použitelný. K dosažení tohoto cíle používá
aplikace jedinou objektově orientovanou třídu s názvem Greeter. Tato třída se používá z aplikace vytvořené ve
vývojovém nástroji Flash Builder nebo Flash Professional.
Chcete-li vytvořit projekt Hello World a třídu Greeter ve vývojovém prostředí Flex:
1 V aplikaci Flash Builder zvolte Soubor > Nový > Projekt Flex.
2 Zadejte HelloWorld jako název projektu. Ujistěte se, že je typ aplikace nastaven na „Web (pro přehrávač Adobe
Flash Player)“, a potom klikněte na tlačítko Dokončit.
Aplikace Flash Builder vytvoří projekt a zobrazí jej v průzkumníku balíku. Projekt již standardně obsahuje soubor
pojmenovaný HelloWorld.mxml a tento soubor je otevřen v editoru.
3 Chcete-li nyní vytvořit soubor vlastní třídy jazyka ActionScript v aplikaci Flash Builder, vyberte položky Soubor >
Nový > Třídy jazyka ActionScript.
4 V dialogovém okně Nová třída jazyka ActionScript zadejte do pole Název pro název třídy výraz Greeter a poté
klepněte na tlačítko Dokončit.
Zobrazí se nové editační okno ActionScript.
Pokračujte se zapisováním kódu do třídy Greeter.
Postup při vytváření třídy Greeter v aplikaci Flash Professional:
1 V aplikaci Flash Professional zvolte Soubor > Nový.
2 V dialogovém okně Nový dokument zvolte soubor ActionScript a klepněte na tlačítko OK.
Zobrazí se nové editační okno ActionScript.
3 Vyberte Soubor > Uložit. Vyberte složku pro uložení aplikace, pojmenujte soubor ActionScript Greeter.as a
klepněte na tlačítko OK.
Pokračujte se zapisováním kódu do třídy Greeter.
27
Zapisování kódu do třídy Greeter
Třída Greeter definuje objekt Greeter, který použijete v aplikaci HelloWorld.
Chcete-li zapsat kód do třídy Greeter:
1 Zadejte do nového pole následující kód. (Některé části kódu mohly být přidány za vás.):
package
{
public class Greeter
{
public function sayHello():String
{
var greeting:String;
greeting = "Hello World!";
return greeting;
}
}
}
Třída Greeter zahrnuje jednu metodu sayHello(), která vrací řetězec říkající „Hello World!“.
2 Vyberte Soubor > Uložit a uložte tento soubor ActionScript.
Třída Greeter je nyní připravena k použití v aplikaci.
Vytváření aplikace, která používá kód ActionScript
Třída Greeter, kterou jste vytvořili, definuje samostatný soubor softwarových funkcí, ale nereprezentuje kompletní
aplikaci. Chcete-li třídu použít, vytvořte dokument aplikace Flash Professional nebo projekt Flex.
Kód potřebuje instanci třídy Greeter. Zde je popsáno, jak použijete třídu Greeter ve své aplikaci.
Postup při vytváření aplikace ActionScript pomocí vývojového prostředí Flash Professional:
1 Zvolte Soubor > Nový.
2 V dialogovém okně Nový dokument zvolte soubor Flash (ActionScript 3.0) a klepněte na tlačítko OK.
Zobrazí se nové okno dokumentu.
3 Vyberte Soubor > Uložit. Zvolte stejnou složku, která obsahuje soubor třídy Greeter.as, pojmenujte dokumentu
Flash HelloWorld.fla a klepněte na tlačítko OK.
4 V paletě nástrojů aplikace Flash Professional zvolte nástroj Text. Táhnutím přes plochu definujte nové textové pole
široké asi 300 obrazových bodů a vysoké asi 100 obrazových bodů.
5 S textovým polem stále vybraným na ploše nastavte v panelu Vlastnosti typ textu na „Dynamický text“. Jako název
instance textového pole zadejte mainText.
6 Klikněte na první snímek v hlavní časové ose. Vyberte položky Okna > Akce a otevřete panel Akce.
7 V panelu Akce zadejte následující skript:
var myGreeter:Greeter = new Greeter();
mainText.text = myGreeter.sayHello();
8 Uložte soubor.
Pokračujte v části Publikování a testování aplikace ActionScript.
28
Postup při vytváření aplikace ActionScript pomocí vývojového prostředí Flash Builder:
1 Otevřete soubor HelloWorld.mxml a přidejte kód odpovídající následujícímu výčtu:
<?xml version="1.0" encoding="utf-8"?>
<s:Application xmlns:fx="http://ns.adobe.com/mxml/2009"
xmlns:s="library://ns.adobe.com/flex/spark"
xmlns:mx="library://ns.adobe.com/flex/halo"
minWidth="1024"
minHeight="768""
creationComplete="initApp()">
<fx:Script>
<![CDATA[
private var myGreeter:Greeter = new Greeter();
public function initApp():void
{
// says hello at the start, and asks for the user's name
mainTxt.text = myGreeter.sayHello();
}
]]>
</fx:Script>
<s:layout>
<s:VerticalLayout/>
</s:layout>
<s:TextArea id="mainTxt" width="400"/>
</s:Application>
Tento projekt rozhraní Flex zahrnuje čtyři tagy jazyka MXML:
• Tag <s:Application>, který definuje kontejner Application.
• Tag <s:layout>, který definuje styl rozvržení (svislé rozvržení) pro tag Application.
• Tag <fx:Script>, který zahrnuje části kódu jazyka ActionScript.
• Tag <s:TextArea>, který definuje pole k zobrazení textové zprávy uživateli.
Kód v tagu <fx:Script> definuje metodu initApp(). Tato metoda je volána při načtení aplikace. Metoda
initApp() nastaví textovou hodnotu mainTxt TextArea na řetězec „Hello World!“ vrácený metodou sayHello()
uživatelské třídy Greeter, kterou jste právě napsali.
2 Vyberte Soubor > Uložit a uložte aplikaci.
Pokračujte v části Publikování a testování aplikace ActionScript.
Publikování a testování aplikace ActionScript
Vývoj softwaru je iterační proces. Napíšete část kódu, pokusíte se jej zkompilovat a upravíte kód tak, až je zkompilován
čistě. Spustíte sestavenou aplikaci a otestujete ji, zda splňuje zamýšlený návrh. V opačném případě budete kód znovu
upravovat, dokud jej nebude splňovat. Vývojová prostředí Flash Professional a Flash Builder nabízejí mnoho způsobů,
jak publikovat, testovat a ladit aplikace.
Zde jsou uvedeny některé základní kroky pro testování aplikace HelloWorld v jednotlivých prostředích.
29
Postup při publikování a testování aplikace ActionScript ve vývojovém prostředí Flash Professional:
1 Publikujte svou aplikaci a sledujte chyby kompilace. Ve vývojovém nástroji Flash Professional zvolte Ovládání >
Testovat film a zkompilujte kód v jazyce ActionScript a spusťte aplikaci HelloWorld.
2 Jestliže se při testování aplikace zobrazují v okně Výstup jakékoliv chyby či upozornění, opravte tyto chyby
v souboru HelloWorld.fla nebo HelloWorld.as. Potom znovu zkuste aplikaci otestovat.
3 Pokud žádné chyby během kompilace nenastanou, zobrazí se okno přehrávače Flash Player s aplikací Hello World.
Právě jste vytvořili jednoduchou, objektově orientovanou aplikaci, která využívá kódu ActionScript 3.0. Pokračujte
v části Zlepšení aplikace HelloWorld.
Postup při publikování a testování aplikace ActionScript ve vývojovém prostředí Flash Builder:
1 Vyberte položky Spustit > Spustit aplikaci HelloWorld.
2 Aplikace HelloWorld se spustí.
• Jestliže se při testování aplikace zobrazují v okně Výstup jakékoliv chyby či upozornění, opravte je v souboru
HelloWorld.mxml nebo Greeter.as. Potom znovu zkuste aplikaci otestovat.
• Pokud se žádné chyby kompilace nevyskytnou, otevře se okno prohlížeče, zobrazující aplikaci HelloWorld. Měl
by být zobrazen text „Hello World!“ .
Právě jste vytvořili jednoduchou, objektově orientovanou aplikaci, která využívá kódu ActionScript 3.0. Pokračujte
v části Zlepšení aplikace HelloWorld.
Zlepšení aplikace HelloWorld
Chcete-li aplikaci poněkud vylepšit a učinit zajímavější, měli byste se nyní dotázat na jméno uživatele a ověřit jej vůči
předdefinovanému seznamu jmen.
Nejprve aktualizujte třídu Greeter a přidejte novou funkci. Pak aktualizujte aplikaci, aby novou funkci použila.
Aktualizace souboru Greeter.as:
1 Otevřete soubor Greeter.as.
2 Změňte obsah souboru tak, aby byl následující (nové a změněné řádky jsou zobrazeny tučným písmem).
package
{
public class Greeter
{
/**
* Defines the names that receive a proper greeting.
*/
public static var validNames:Array = ["Sammy", "Frank", "Dean"];
/**
* Builds a greeting string using the given name.
*/
public function sayHello(userName:String = ""):String
{
var greeting:String;
if (userName == "")
{
greeting = "Hello. Please type your user name, and then press "
+ "the Enter key.";
}
30
else if (validName(userName))
{
greeting = "Hello, " + userName + ".";
}
else
{
greeting = "Sorry " + userName + ", you are not on the list.";
}
return greeting;
}
/**
* Checks whether a name is in the validNames list.
*/
public static function validName(inputName:String = ""):Boolean
{
if (validNames.indexOf(inputName) > -1)
{
return true;
}
else
{
return false;
}
}
}
}
Třída Greeter má nyní několik nových vlastností:
• Pole validNames uvádí seznam s platnými uživatelskými jmény. Pole se inicializuje tak, aby po načtení třídy
Greeter otevřelo seznam tří jmen.
• Metoda sayHello() nyní přijme uživatelské jméno a změní pozdrav na základě některých podmínek. Pokud je
userName prázdný řetězec (""), vlastnosti greeting je nastaven na zobrazení výzvy uživateli, aby zadal jméno.
Pokud je uživatelské jméno platné, pozdrav bude "Hello, userName." Nakonec, pokud není ani jedna z těchto
dvou podmínek, proměnná greeting se nastaví na "Sorry userName, you are not on the list."
• Metoda validName() vrátí hodnotu true, pokud je nalezeno inputName v poli validNames, nebo hodnotu
false, pokud nalezeno není. Příkaz validNames.indexOf(inputName) kontroluje každý řetězec v poli
validNames proti řetězci inputName. Metoda Array.indexOf() vrací indexovou polohu první instance objektu
v poli. Není-li objekt v poli nalezen, vrátí hodnotu -1.
Potom upravte soubor aplikace, který odkazuje na třídu ActionScript.
Postup při úpravě aplikace pomocí vývojového prostředí Flash Professional:
1 Otevřete soubor HelloWorld.fla.
2 Změňte skript ve snímku 1 tak, aby prázdný řetězec ("") byl předán metodě sayHello() třídy Greeter:
mainText.text = myGreeter.sayHello("");
3 V paletě nástrojů zvolte nástroj Text. Vytvořte na ploše dvě nová textová pole. Umístěte je vedle sebe přímo pod
existující textové pole mainText.
4 Do prvního nového textového pole, což je popis, zadejte text Jméno uživatele:.
31
5 Vyberte druhé nové textové pole a v Inspektoru vlastností zvolte InputText jako typ textového pole. Jako typ řádky
zvolte jednotlivou řádku. Jako název instance zadejte textIn.
6 Klepněte na první snímek v hlavní časové ose.
7 V panelu Akce přidejte na konec stávajícího skriptu následující řádky:
mainText.border = true;
textIn.border = true;
textIn.addEventListener(KeyboardEvent.KEY_DOWN, keyPressed);
function keyPressed(event:KeyboardEvent):void
{
if (event.keyCode == Keyboard.ENTER)
{
mainText.text = myGreeter.sayHello(textIn.text);
}
}
Nový kód přidá následující funkci:
• První dva řádky jednoduše definují okraje dvou textových polí.
• Vstupní textové pole, například pole textIn, nastavilo události, které může odeslat. Metoda
addEventListener() umožňuje definovat funkci, která se spustí, když nastane typ události. V tomto případě
je touto události stisknutí klávesy.
• Uživatelská funkce keyPressed() kontroluje, zda stisknutou klávesou byla klávesa Enter. Pokud ani, funkce
zavolá metodu sayHello() objektu myGreeter a předá text z textového pole textIn jako parametr. Tato
metoda vrací řetězec pozdravu na základě předané hodnoty. Vrácený řetězec je pak přiřazen vlastnosti text
textového pole mainText.
Celý skript pro snímek 1 je následující:
mainText.text = myGreeter.sayHello("");
mainText.border = true;
textIn.border = true;
textIn.addEventListener(KeyboardEvent.KEY_DOWN, keyPressed);
function keyPressed(event:KeyboardEvent):void
{
if (event.keyCode == Keyboard.ENTER)
{
mainText.text = myGreeter.sayHello(textIn.text);
}
}
8 Uložte soubor.
9 Výběrem možností Ovládání > Testovat film spusťte aplikaci.
Po spuštění aplikace budete vyzváni k zadání jména uživatele. Pokud je platné (Sammy, Frank nebo Dean), aplikace
zobrazí hlášení s potvrzením „Hello“.
Postup při úpravě aplikace pomocí vývojového prostředí Flash Builder:
1 Otevřete soubor HelloWorld.mxml.
32
2 Potom upravte tag <mx:TextArea>, aby uživatele informoval, že slouží pouze k zobrazení. Změňte barvu pozadí
na světle šedou a nastavte atribut editable na hodnotu false:
<s:TextArea id="mainTxt" width="400" backgroundColor="#DDDDDD" editable="false" />
3 Nyní přidejte následující řádky přímo za koncový tag <s:TextArea>. Tyto řádky vytvářejí komponentu TextInput,
která umožňuje uživateli zadat hodnotu jména uživatele:
<s:HGroup width="400">
<mx:Label text="User Name:"/>
<s:TextInput id="userNameTxt" width="100%" enter="mainTxt.text =
myGreeter.sayHello(userNameTxt.text);" />
</s:HGroup>
Atribut enter definuje, co se stane, když uživatel stiskne klávesu Enter v poli userNameTxt. V tomto příkladu kód
předá text v poli metodě Greeter.sayHello(). Pozdrav v poli mainTxt se podle toho změní.
Soubor HelloWorld.mxml vypadá takto:
<?xml version="1.0" encoding="utf-8"?>
<s:Application xmlns:fx="http://ns.adobe.com/mxml/2009"
xmlns:s="library://ns.adobe.com/flex/spark"
xmlns:mx="library://ns.adobe.com/flex/halo"
minWidth="1024"
minHeight="768""
creationComplete="initApp()">
<fx:Script>
<![CDATA[
private var myGreeter:Greeter = new Greeter();
public function initApp():void
{
// says hello at the start, and asks for the user's name
mainTxt.text = myGreeter.sayHello();
}
]]>
</fx:Script>
<s:layout>
<s:VerticalLayout/>
</s:layout>
<s:TextArea id="mainTxt" width="400" backgroundColor="#DDDDDD" editable="false"/>
<s:HGroup width="400">
<mx:Label text="User Name:"/>
<s:TextInput id="userNameTxt" width="100%" enter="mainTxt.text =
myGreeter.sayHello(userNameTxt.text);" />
</s:HGroup>
</s:Application>
4 Uložte upravený soubor HelloWorld.mxml. Vyberte položky Spustit > Spustit aplikaci HelloWorld a spusťte
aplikaci.
Po spuštění aplikace budete vyzváni k zadání jména uživatele. Pokud je platné (Sammy, Frank nebo Dean), aplikace
zobrazí hlášení s potvrzením „Hello, jméno uživatele“.
33
Kapitola 3: Jazyk ActionScript a jeho
syntaxe
Jazyk ActionScript 3.0 zahrnuje jádro jazyka ActionScript i programovací rozhraní aplikace Adobe Flash Platform
(API). Základní jazyk je částí jazyka ActionScript, která definuje syntaxi jazyka i typy dat na nejvyšší úrovni. Jazyk
ActionScript 3.0 poskytuje programový přístup k běhovým modulům řešení Adobe Flash Platform: Adobe Flash
Player a Adobe AIR.
Přehled jazyka
Objekty ležící v jádru jazyka ActionScript 3.0 - tvoří základní stavební bloky. Každá proměnná, kterou deklarujete,
každá zapsaná funkce a každá vytvořená instance třídy je objektem. Program jazyka ActionScript 3.0 můžete
považovat za skupinu objektů provádějících úlohy, reagujících na události a komunikujících navzájem mezi sebou.
Programátoři seznámení s objektově orientovaným programováním (OOP) v jazyce Java nebo C++ mohou považovat
objekty za moduly, obsahující dva typy členů: data uložená v členských proměnných nebo vlastnostech, a chování
přístupné prostřednictvím metod. Jazyk ActionScript 3.0 definuje objekty podobným ale trochu odlišným způsobem.
V jazyce ActionScript 3.0 jsou objekty jednoduše sbírkou vlastností. Tyto vlastnosti jsou kontejnery, které uchovávají
nejenom data, ale také funkce nebo jiné objekty. Pokud je funkce tímto způsobem připojená k objektu, nazývá se
metodou.
Zatímco definice jazyka ActionScript 3.0 se může programátorům jazyků Java nebo C++ zdát poněkud podivná, v
praxi definování typů objektů s třídami ActionScript 3.0 bude velmi podobná způsobu, kterým jsou definovány třídy
v jazyce Java nebo C++. Rozdíl mezi dvěma definicemi objektu je důležitý při projednávání objektového modelu
ActionScript a dalších pokročilých témat, ale ve většině jiných situací znamená termín vlastnosti proměnné členy tříd,
což je protiklad metod. Referenční příručka jazyka ActionScript 3.0 pro řešení Adobe Flash Platform například
používá termín vlastnosti k označení proměnných nebo vlastností metody pro získání a nastavení. Používá termín
metody k popisu funkcí, které jsou součástí třídy.
Jedním drobným rozdílem mezi třídou ActionScript a třídami v jazycích Java nebo C++ je to, že v jazyce ActionScript
nejsou třídy pouhými abstraktními entitami. Třídy ActionScript jsou vyjádřeny objekty třídy, které ukládají vlastnosti
třídy a metody. To umožňuje používat techniky, které se mohou zdát programátorům jazyků Java a C++ podivné,
například zahrnutí příkazů nebo spustitelného kódu na horní úrovni třídy nebo balíku.
Dalším rozdílem mezi třídami ActionScript a jazyka Java nebo C++ je v tom, že každá třída ActionScript má něco, co
se nazývá prototypovýobjekt. V předchozích verzích jazyka ActionScript sloužily prototypové objekty spojené do
řetězců prototypů jako základy dědičnosti celé hierarchie třídy. V jazyce ActionScript 3.0 však prototypové objekty
hrají jenom malou úlohu v systému dědičnosti. Prototypový objekt může být i nadále užitečný, nicméně jako
alternativa statickým vlastnostem a metodám, pokud chcete sdílet vlastnost a její hodnotu mezi všemi instancemi
třídy.
V minulosti programátoři ActionScript mohli přímo manipulovat s prototypovým řetězcem se zvláštními
vestavěnými prvky jazyka. Nyní, když jazyk poskytuje zralejší implementaci programovacího rozhraní založeného na
třídách, mnoho z těchto speciálních prvků jazyka, například __proto__ a __resolve, již není jeho součástí. Kromě
toho optimalizace mechanismu vnitřní dědičnosti, která poskytuje významné zvýšení výkonu, zabraňuje přímému
přístupu k mechanismu dědičnosti.
34
Jazyk ActionScript a jeho syntaxe
Objekty a třídy
V jazyce ActionScript 3.0 je každý objekt definovaný svou třídou. Třída může být šablonu nebo modrotiskem typu
objektu. Definice třídy mohou zahrnovat proměnné a konstanty, které uchovávají datové hodnoty, a metody, které
jsou funkcemi obsahujícími chování spojené s danou třídou. Hodnoty uložené ve vlastnostech mohou být primitivní
hodnoty nebo jiné objekty. Primitivní hodnoty jsou čísla, řetězce a booleovské hodnoty.
Jazyk ActionScript obsahuje několik vestavěných tříd, které jsou součástí jádra jazyka. Některé z těchto vestavěných
tříd, například čísla, booleovské hodnoty a řetězce, představují primitivní hodnoty dostupné v jazyce ActionScript.
Jiné, např. třídy Array, Math a XML, definují složitější objekty.
Všechny třídy, vestavěné nebo definované uživatelem, jsou odvozeny od třídy Object. Pro programátory s předchozí
zkušenosti s jazykem ActionScript, je důležité poznamenat, že datový typ Object již není výchozím typem, i když jsou
všechny třídy od něj odvozeny. V jazyce ActionScript 2.0 byly následující dva řádky kódu shodné protože neexistovala
anotace typu znamenající, že proměnná by byla typu Object:
var someObj:Object;
var someObj;
Jazyk ActionScript 3.0 však zavádí koncept proměnných bez typu, které mohou být označeny následujícími dvěma
způsoby:
var someObj:*;
var someObj;
Proměnné bez typu nejsou stejné, jako proměnné typu Object. Klíčovým rozdílem je to, že proměnné bez typu mohou
uchovávat speciální hodnotu undefined, zatímco proměnná typu Object tuto hodnotu uchovávat nemůže.
Můžete definovat své vlastní třídy a to pomocí klíčového slova class. vlastnosti třídy deklarujete třemi způsoby:
konstanty mohou být definovány klíčovým slovem const, proměnné mohou být definovány klíčovým slovem var a
vlastnosti getter a setter mohou být definovány použitím atributu get a set v deklarování metody. Metody můžete
deklarovat klíčovým slovem function.
Instanci třídy můžete vytvořit pomocí operátoru new. Následující příklad vytváří instanci třídy Date nazvanou
myBirthday.
var myBirthday:Date = new Date();
Balíčky a jmenné prostory
Balíčky a jmenné prostory jsou související koncepty. Balíčky umožňují spojit definice tříd způsobem, který usnadňuje
sdílení kódu a minimalizuje konflikty pojmenování. Jmenné prostory umožňují řídit viditelnost identifikátorů,
například názvů vlastnosti a metody, a mohou být použity v kódu bez ohledu na to, zda je umístěn vně nebo uvnitř
balíčku. Balíčky umožňují organizovat soubory tříd, jmenné prostory umožňují zpracovat viditelnost jednotlivých
vlastností a metod.
Balíky
Balíčky v jazyce ActionScript 3.0 jsou implementovány s jmennými prostory, ale nejsou jejich synonymem. Když
deklarujete balíček, implicitně vytváříte speciální typ jmenného prostoru, který je zaručeně znám v okamžiku
kompilace. Jmenné prostory, když jsou vyjádřeny explicitně, nejsou nutně známy v čase kompilace.
Následující příklad používá instrukci package k vytvoření jednoduchého balíčku obsahujícího jednu třídu:
35
package samples
{
public class SampleCode
{
public var sampleGreeting:String;
public function sampleFunction()
{
trace(sampleGreeting + " from sampleFunction()");
}
}
}
Název třídy je v tomto příkladu SampleCode. Protože třída je uvnitř vzorového balíčku, kompilátor automaticky
kvalifikuje název třídy v okamžiku kompilace do plně platného názvu: samples.SampleCode. Kompilátor také
kvalifikuje názvy všech vlastností nebo metod, takže sampleGreeting a sampleFunction() se stanou
samples.SampleCode.sampleGreeting a samples.SampleCode.sampleFunction().
Mnoho vývojářů, obzvláště pokud mají zkušenosti s programováním v jazyce Java, volí umístění pouze tříd na horní
úrovni balíčku. Jazyk ActionScript 3.0 však podporuje nejenom třídy na horní úrovni balíčku, ale také proměnné,
funkce a také příkazy. Pokročilým použitím této funkce je definování jmenného prostoru na horní úrovni balíčku tak,
aby byl k dispozici všem třídám v daném balíčku. Povšimněte si však, že na horní úrovni balíčku jsou povoleny pouze
dva specifikátory přístupu, public a internal. Na rozdíl od jazyka Java, ve kterém lze deklarovat vnořené třídy jako
soukromé, jazyk ActionScript 3.0 nepodporuje ani vnořené, ani soukromé třídy.
Mnoha jinými způsoby jsou však balíčky jazyka ActionScript 3.0 podobné balíčkům v programovacím jazyce Java. Jak
jste mohli vidět na předchozím příkladu, zcela platné reference balíčku jsou vyjádřeny pomocí operátoru tečka (.),
stejně jako v jazyce Java. Balíčky můžete použít k organizování kódu do intuitivní hierarchické struktury pro použití
jinými programátory. To usnadňuje sdílení kódu a umožňuje vytvářet vlastní balíčky pro sdílení s ostatními a používat
balíčky vytvořené jinými programátory ve vlastním kódu.
Používání balíčků rovněž pomáhá zajistit, aby použité názvy identifikátorů byly unikátní a nebyly ve střetu s jinými
názvy identifikátorů. Ve skutečnosti by někdo mohl říci, že se jedná o primární výhodu balíčků. Například dva
programátoři, kteří chtějí navzájem sdílet svůj kód, mohou vytvořit třídu s názvem SampleCode. Bez balíčků by to
vedlo ke konfliktu názvů a jediným řešením by bylo přejmenování jedné ze tříd. Díky balíčkům je však konflikt názvů
snadno odstranitelný a to vložením jedné, nebo lépe obou tříd do balíčku s unikátními názvy.
Můžete také zahrnout integrované tečky do názvů svých balíčků a vytvořit tak vnořené balíčky. To umožňuje vytvářet
hierarchické organizování balíčků. Dobrým příkladem je balíček flash.display v jazyce ActionScript 3.0. Balíček
flash.display je vnořen v balíčku flash.
Většina jazyka ActionScript 3.0 je organizována v rámci balíku flash. Například balíček flash.display obsahuje seznam
zobrazení API, a balíček flash.events obsahuje nový model událostí.
Vytváření balíčků
Jazyk ActionScript 3.0 poskytuje významnou flexibilitu způsobu, kterým je možné organizovat balíčky, třídy a
zdrojové soubory. Předchozí verze jazyka ActionScript povolovaly pouze jednu třídu na zdrojový soubor a vyžadovaly,
aby název zdrojového souboru odpovídal názvu třídy. Jazyk ActionScript 3.0 umožňuje zahrnout více tříd do jednoho
zdrojového souboru, avšak pouze jedna třída v každém souboru může být zpřístupněna kódu, který je pro daný soubor
externí. Jinými slovy pouze jedna třída v každém souboru může být deklarována uvnitř deklarace balíčku. Musíte
deklarovat všechny dodatečné třídy vně definice balíčku, což tyto třídy zneviditelní pro kód vně tohoto zdrojového
souboru. Název třídy deklarované uvnitř definice balíčku musí odpovídat názvu zdrojového souboru.
36
Jazyk ActionScript 3.0 také poskytuje vyšší stupeň flexibility způsobu deklarování balíčků. V předchozích verzích
ActionScript balíčky představovaly pouze adresáře, ve kterých byly umístěny zdrojové soubory, a nebylo nutné
deklarovat balíčky příkazem package, spíše se název balíčku zahrnul jako součást plně kvalifikovaného názvu třídy ve
vaší deklaraci třídy. I když balíčky stále vyjadřují adresáře v jazyku ActionScript 3.0, mohou obsahovat více než třídy.
V jazyku ActionScript 3.0 použijete příkaz package k deklarování balíčku, což znamená, že můžete také deklarovat
proměnné, funkce a jmenné prostory na horní úrovni balíčku. Na horní úrovni balíčku můžete také zahrnout
spustitelné příkazy. Pokud deklarujete proměnné, funkce nebo jmenné prostory na horní úrovni balíčku, jediným
atributem dostupným na této úrovni je public a internal a pouze jedna deklarace na úrovni balíčku na soubor může
použít atribut public, bez ohledu na to, zda je tato deklarace třídou, proměnnou, funkcí nebo jmenným prostorem.
Balíčky jsou užitečné pro organizování kódu a zabránění konfliktů názvů. Nezaměňujte koncept balíčků s
nesouvisejícím konceptem dědičnosti třídy. Dvě třídy spočívající ve stejném balíčku budou mít společný jmenný
prostor, ale jinak spolu nemusejí být nijak spojeny. Podobně, vnořené prostory nemají žádný sémantický vztah s
nadřazeným balíčkem.
Importování balíčků
Pokud chcete použít třídu uvnitř balíčku, musíte importovat balíček nebo jeho specifickou třídu. To je odlišné od
jazyka ActionScript 2.0, kde importování tříd bylo volitelné.
Zvažte například dříve uvedený příklad třídy SampleCode. Pokud třída spočívá v balíčku pojmenovaném samples,
musíte použít jeden z následujících příkladů před použitím třídy SampleCode:
import samples.*;
nebo
import samples.SampleCode;
Obecně příkazy import by měly být co nejspecifičtější. Pokud plánujete použít pouze třídu SampleCode z balíčku
samples, měli byste importovat pouze třídu SampleCode, nikoli celý balíček, ke kterému náleží. Importování celého
balíčku může vést k neočekávaným konfliktům názvů.
Musíte také umístit zdrojový kód, který definuje balíček nebo třídu do classpath. Třída classpath představuje
uživatelem definovaný seznam cest místních adresářů, který určuje, kde bude kompilátor vyhledávat importované
balíčky a třídy. Třída classpath je někdy nazývána cesta sestavení nebo cesta zdroje.
Po správném importování třídy nebo balíčku použijete buď plně kvalifikovaný název třídy (samples.SampleCode)
nebo pouze název třídy samotné (SampleCode).
Plně kvalifikované názvy jsou užitečné v případě, že identicky pojmenované třídy, metody nebo vlastnosti vedou k
nejednoznačnému kódu, ale jejich správa může být obtížná, pokud jsou použity pro všechny identifikátory. Například
použití plně kvalifikovaného názvu vede k rozvláčnému kódu, když konkretizujete instanci třídy SampleCode:
var mySample:samples.SampleCode = new samples.SampleCode();
Když se zvýší úroveň třídy vnořeného balíčku, čitelnost kódu se sníží. V případě, kdy jste si jisti, že nejednoznačné
identifikátory nepředstavují žádný problém, můžete kód pro čtení zjednodušit pomocí jednoduchých identifikátorů.
Například konkretizace nové instance třídy SampleCode je mnohem méně rozvláčná, pokud použijete pouze
identifikátor třídy:
var mySample:SampleCode = new SampleCode();
Pokud se pokusíte použít názvy identifikátorů bez předchozího importování příslušného balíčku nebo třídy, nebude
kompilátor schopen nalézt definice třídy. Na druhou stranu, jestliže importujete balíček nebo třídu, jakýkoliv pokus
o definování názvu vedoucí ke konfliktu s importovaným názvem, vygeneruje chybu.
37
Když je vytvořen balíček, výchozí specifikátor přístupu pro všechny členy daného balíčku je internal, což znamená,
že standardně jsou členové balíčku viditelné pouze ostatním členům tohoto balíčku. Pokud chcete, aby třída byla
dostupná kódu vně balíčku, musíte deklarovat tuto třídu jako public. Například následující balíček obsahuje dvě
třídy, SampleCode a CodeFormatter:
// SampleCode.as file
package samples
{
public class SampleCode {}
}
// CodeFormatter.as file
package samples
{
class CodeFormatter {}
}
Třída SampleCode je viditelná vně balíčku, protože je deklarovaná jako třída public. Třída CodeFormatter je nicméně
viditelná pouze v rámci samotného balíčku. Pokud se pokusíte přistupovat k třídě CodeFormatter mimo vzorový
balíček, dojde k chybě, jak je vidět na následujícím příkladu:
import samples.CodeFormatter;
var mySample:SampleCode = new SampleCode(); // okay, public class
var myFormatter:CodeFormatter = new CodeFormatter(); // error
Pokud chcete obě třídy zpřístupnit vně balíčku, musíte je obě deklarovat jako public. Nemůžete použít atribut public
pro deklarování balíčku.
Plně kvalifikované názvy jsou užitečné pro vyřešení konfliktů názvů, které mohou při použití balíčků nastat. Takový
scénář může nastat, pokud importujete dva balíčky definující třídy se stejným identifikátorem. Například zvažte
následující balíček, který také obsahuje třídu pojmenovanou SampleCode:
package langref.samples
{
public class SampleCode {}
}
Jestliže importujete obě třídy následujícím způsobem, dojde při použití třídy SampleCode ke konfliktu názvů:
import langref.samples.SampleCode;
var mySample:SampleCode = new SampleCode(); // name conflict
Kompilátor nemá žádnou možnost zjistit, kterou třídu SampleCode použít. Chcete-li vyřešit tento konflikt, musíte
využít plně kvalifikovaného názvu každé třídy, a to následujícím způsobem:
var sample1:samples.SampleCode = new samples.SampleCode();
var sample2:langref.samples.SampleCode = new langref.samples.SampleCode();
Poznámka: Programátoři se znalostí C++ často zaměňují příkaz import s příkazem #include. Instrukce #include je
nutná v jazyce C++ proto, že kompilátory C++ zpracovávají postupně jeden soubor za druhým, a nevyhledávají definice
třídy v dalších souborech, pokud je soubor záhlaví explicitně zahrnut. Jazyk ActionScript 3.0 mí instrukci include, ale
není navržen pro importování tříd a balíčků. Chcete-li importovat třídy nebo balíčky do jazyka ActionScript 3.0, musíte
použít příkaz import a vložit zdrojový soubor obsahující balíček do cesty třídy.
38
Jmenné prostory
Jmenné prostory umožňují ovládat viditelnost vlastností a metod, které vytvoříte. Na specifikátory řízení přístupu
public, private, protected, a internal můžete nahlížet jako na vestavěné jmenné prostory. Pokud tyto
předdefinované specifikátory řízení přístupu nevyhovují vašim požadavkům, můžete vytvořit vlastní jmenné prostory.
Pokud jste seznámeni se jmennými prostory XML, většina těchto informací pro vás nebude nová, i když syntaxe a
podrobnosti o implementování jazyka ActionScript se mírně odlišuje od těch v XML. Pokud jste nikdy dříve
nepracovali s jmennými prostory, koncept samotný je přímý, ale implementace má specifickou terminologii, kterou
se musíte naučit.
Chcete-li porozumět funkci jmenných prostorů, je dobré znát, že název vlastnosti nebo metody vždy obsahuje dvě
části: identifikátor a jmenný prostor. Identifikátor je to, co obvykle považujete za název. Například identifikátory v
následující definici třídy jsou sampleGreeting a sampleFunction():
class SampleCode
{
var sampleGreeting:String;
function sampleFunction () {
trace(sampleGreeting + " from sampleFunction()");
}
}
Kdykoliv definice nejsou předcházeny atributem jmenného prostoru, jejich názvy jsou kvalifikovány výchozím
jmenným prostorem internal, což znamená, že jsou viditelné pouze volajícím ve stejném balíčku. Pokud je
kompilátor nastaven do přísného režimu, vydá upozornění, že jmenné prostory internal platí pro jakýkoli
identifikátor bez atributu jmenného prostoru. Aby byl identifikátor dostupné všude, musíte specificky uvést v
předponě název identifikátoru s atributem public. V předchozím příkladu kódu obě třídy sampleGreeting a
sampleFunction() mají hodnotu jmenného prostoru internal.
Existují tři základní kroky, které je nutné při používání jmenných prostorů používat. Nejprve musíte definovat jmenný
prostor pomocí klíčového slova namespace. Například následující kód definuje jmenný prostor version1:
namespace version1;
Za druhé použijete jmenný prostor namísto specifikátoru řízení přístupu v deklaraci vlastnosti nebo metody.
Následující příklad vkládá funkci pojmenovanou myFunction() do jmenného prostoru version1:
version1 function myFunction() {}
Za třetí, jakmile použijete jmenný prostor, můžete na něj odkazovat instrukcí use nebo kvalifikováním názvu
identifikátoru jmenným prostorem. Následující příklad odkazuje na funkci myFunction() pomocí instrukce use:
use namespace version1;
myFunction();
Můžete také použít kvalifikovaný název pro odkazování na funkci myFunction(), jak je vidět na následujícím
příkladu:
version1::myFunction();
Definování jmenných prostorů
Jmenné prostory obsahují jednu hodnotu, Univerzální identifikátor zdroje (URI - Uniform Resource Identifier), která
se někdy nazývá název jmenného prostoru. URI umožňuje zajistit, aby definice jmenného prostoru byla jedinečná.
Vytváříte jmenný prostor deklarováním definice jmenného prostoru jedním ze dvou způsobů. Můžete buď definovat
jmenný prostor s explicitní URI, jako byste definovali jmenný prostor XML, nebo můžete URI vynechat. Následující
příklad ukazuje, jak lze jmenný prostor definovat pomocí URI:
39
namespace flash_proxy = "http://www.adobe.com/flash/proxy";
URI slouží jako unikátní identifikační řetězec pro daný jmenný prostor. Pokud vynecháte identifikátor URI, jako v
následujícím příkladu, kompilátor vytvoří na místě identifikátoru URI jedinečný vnitřní identifikační řetězec. K
tomuto vnitřnímu identifikačnímu řetězci nemáte přístup.
namespace flash_proxy;
Jakmile definujete jmenný prostor, s URI nebo bez, tento jmenný prostor nelze předefinovat ve stejném rozsahu.
Pokus o definování jmenného prostoru, jak bylo uvedeno výše ve stejném rozsahu, vede k chybám kompilátoru.
Pokud je jmenný prostor definován v balíčku nebo třídě, jmenný prostor nemůže být viditelný pro kód vně tohoto
balíčku nebo třídy, pokud není použit příslušný specifikátor řízení přístupu. Například následující kód zobrazuje
flash_proxy jmenný prostor definovaný v balíčku flash.utils. V následujícím příkladu chybějící specifikátor řízení
přístupu znamená, že jmenný prostor flash_proxy bude viditelný pouze pro kód v balíčku flash.utils a nebude
viditelný pro jakýkoli kód vně tohoto balíčku:
package flash.utils
{
namespace flash_proxy;
}
Následující kód využívá atribut public pro zviditelnění jmenného prostoru flash_proxy pro kód vně balíčku:
package flash.utils
{
public namespace flash_proxy;
}
Použití jmenných prostor
Použití jmenných prostor znamená vložení definice do jmenného prostoru. Definice, které lze vložit do jmenného
prostoru zahrnují funkce, proměnné a konstanty (třídu do vlastního jmenného prostoru vložit nelze).
Zvažte například funkci deklarovanou pomocí jmenného prostoru řízení přístupu public. Pomocí atributu public v
definici funkce vloží funkci do veřejného jmenného prostoru, což ji zpřístupní pro veškerý kód. Jakmile definujete
jmenný prostor, můžete jej použít stejným způsobem, jak byste použili atribut public, a definice bude dostupná pro
kód, který může odkazovat na vlastní jmenný prostor. Pokud například definujete jmenný prostor example1, můžete
přidat metodu nazvanou myFunction() pomocí example1 jako atributu, jak je vidět na následujícím příkladu:
namespace example1;
class someClass
{
example1 myFunction() {}
}
Deklarování metody myFunction() pomocí jmenného prostoru example1 jako atributu znamená, že metoda náleží
jmennému prostoru example1.
Při použití jmenného prostoru byste měli mít na paměti následující:
• Můžete použít pouze jeden jmenný prostor pro každou deklaraci.
• Neexistuje žádný způsob, jak aplikovat atribut jmenného prostoru pro více než jednu definici najednou. Jinými
slovy, pokud chcete použít svůj jmenný prostor na deset různých funkcí, musíte přidat jmenné prostory jako atribut
k jedné z deseti definic funkcí.
• Pokud použijete pouze jmenný prostor, nemůžete také uvést specifikátor řízení přístupu, protože jmenné prostory
a specifikátory řízení přístupu se vzájemně vylučují. Jinými slovy, nemůžete deklarovat funkci nebo vlastnosti jako
public, private, protected nebo internal kromě použití jmenného prostoru.
40
Odkazování jmenných prostory
Není nutné explicitně definovat odkaz na jmenný prostor, když použijete metodu nebo vlastnost deklarovanou
pomocí kteréhokoliv jmenného prostoru řízení přístupu, například public, private, protected a internal. Tak
tomu je proto, že přístup k těmto speciálním jmenným prostorům je řízen kontextem. Například definice vložené do
jmenného prostoru private jsou automaticky dostupné kódu ve stejné třídě. Pro vámi definované jmenné prostory
nicméně taková citlivost na kontext neexistuje. Chcete-li použít metodu nebo vlastnost, kterou jste vložili do vlastního
jmenného prostoru, musíte na jmenný prostor odkazovat.
Jmenný prostor můžete odkazovat s použitím instrukce use namespace nebo můžete kvalifikovat název se jmenným
prostorem pomocí symbolu kvalifikátoru názvu (::). Odkazování jmenného prostoru pomocí instrukce use
namespace „otevře” jmenný prostor, takže jej lze použít pro všechny identifikátory, které nejsou kvalifikované. Pokud
jste například definovali jmenný prostor example1, můžete přistupovat k názvům v tomto jmenném prostoru pomocí
use namespace example1:
use namespace example1;
myFunction();
Můžete otevřít více než jeden jmenný prostor najednou. Jakmile otevřete jmenný prostor s use namespace, zůstane
otevřený v celém bloku kódu, ve kterém byl otevřen. Neexistuje žádný způsob, jak explicitně jmenný prostor uzavřít.
Pokud budete mít otevřený více než jeden jmenný prostor, zvyšuje se tak pravděpodobnost konfliktu názvů. Pokud
dáváte přednost neotevírání jmenného prostoru, můžete se vyhnout instrukci use namespace kvalifikováním názvu
metody nebo vlastnosti s jmenným prostorem a symbolem kvalifikátoru jména. Například následující kód znázorňuje,
jak lze kvalifikovat název myFunction() pomocí jmenného prostoru example1:
example1::myFunction();
Použití jmenného prostoru
Ve třídě flash.utils.Proxy, která je součástí jazyka ActionScript 3.0, můžete nalézt reálný příklad jmenného prostoru,
který je použit k zabránění konfliktům názvů. Třída Proxy, která je náhradou za Object.__resolve z jazyka
ActionScript 2.0 umožňuje sledovat odkazy k nedefinovaným vlastnostem nebo metodám předtím, než se vyskytne
chyba. Všechny metody třídy Proxy spočívají v jmenném prostoru flash_proxy, aby nedocházelo ke konfliktu názvů.
Pro lepší porozumění použití jmenného prostoru flash_proxy je nutné porozumět použití třídy Proxy. Funkce třídy
Proxy je dostupná pouze třídám které z ní pocházejí. Jinými slovy, pokud chcete používat metody třídy Proxy na
objekt, musí definice třídy objektu rozšiřovat třídu Proxy. Pokud chcete například sledovat pokusy volání
nedefinované metody, rozšířili byste třídu Proxy a pak potlačili metodu callProperty() třídy Proxy.
Můžete si pamatovat, že implementování jmenného prostoru je obvykle proces složený ze tří kroků definování, použití
a pak odkazování jmenného prostoru. Protože nikdy explicitně nevoláte metody třídy Proxy, jmenný prostor
flash_proxy je pouze definován a použit, ale nikdy není referencován. ActionScript 3.0, definuje jmenný prostor
flash_proxy a použije jej na třídu Proxy. Kód musí pouze aplikovat jmenný prostor flash_proxy na třídy, které
rozšiřují třídu Proxy.
Jmenný prostor flash_proxy je definován v balíčku flash.utils způsobem obdobný následujícímu:
package flash.utils
{
public namespace flash_proxy;
}
Jmenný prostor je aplikován na metody třídy Proxy, jak je znázorněno v následujícím výňatku z třídy Proxy:
41
public class Proxy
{
flash_proxy function callProperty(name:*, ... rest):*
flash_proxy function deleteProperty(name:*):Boolean
...
}
jak ukazuje následující kód, musíte nejprve importovat třídu Proxy a pak jmenný prostor flash_proxy. Musíte pak
deklarovat svou třídu tak, aby rozšiřovala třídu Proxy (v případě, že kompilujete v přísném režimu, musíte také přidat
atribut dynamic). Když potlačíte metodu callProperty(), musíte použít jmenný prostor flash_proxy.
package
{
import flash.utils.Proxy;
import flash.utils.flash_proxy;
dynamic class MyProxy extends Proxy
{
flash_proxy override function callProperty(name:*, ...rest):*
{
trace("method call intercepted: " + name);
}
}
}
Pokud vytvoříte instanci třídy MyProxy a zavoláte nedefinovanou metodu, například metodu testing() volanou v
následujícím příkladu, objekt Proxy sleduje volání metody a vykonává příkazy uvnitř potlačené metody
callProperty() (v tomto případě jednoduchý příkaz trace()).
var mySample:MyProxy = new MyProxy();
mySample.testing(); // method call intercepted: testing
Existují dvě výhody, proč mít metody třídy Proxy uvnitř jmenného prostoru flash_proxy. První, mít samostatné
jmenné prostory redukuje nepořádek ve veřejném rozhraní jakékoliv třídy, která rozšiřuje třídu Proxy. (Existuje asi
tucet metod v třídě Proxy, které můžete potlačit, všechny nejsou navrženy pro přímé volání. Jejich umístění do
veřejného jmenného prostoru může být matoucí.) Druhá, použití jmenného prostoru flash_proxy zabraňuje
konfliktu názvů v případě, že vaše podtřída Proxy obsahuje metody instance s názvy odpovídajícími metodám třídy
Proxy. Můžete například chtít pojmenovat jednu z vlastních metod callProperty(). Následující kód je přijatelný,
protože vaše verze metody callProperty() je v jiném jmenném prostoru.
dynamic class MyProxy extends Proxy
{
public function callProperty() {}
flash_proxy override function callProperty(name:*, ...rest):*
{
trace("method call intercepted: " + name);
}
}
Jmenné prostory mohou být také užitečné v případě, že chcete zajistit přístup k metodám nebo vlastnostem způsobem,
který nelze uskutečnit se čtyřmi specifikátory řízení přístupu (public, private, internal a protected). Například
můžete mít několik pomocných meto, které jsou rozprostřeny v několika balíčcích. Chcete například všechny tyto
metody zpřístupnit všem svým balíčkům, ale nechcete je mít veřejně přístupné. To uskutečníte tak, že vytvoříte jmenný
prostor a použijete jej jako vlastní speciální specifikátor řízení přístupu.
42
Následující příklad ilustruje použití uživatelem definovaného jmenného prostoru k seskupení dvou funkcí, jež
spočívají v různých balíčcích. Jejich seskupením do stejného jmenného prostoru můžete obě funkce zviditelnit ve třídě
nebo balíčku pomocí jediného příkazu use namespace.
Tento příklad používá čtyři soubory k demonstrování této techniky. Všechny soubory musí být v cestě pro třídu. První
soubor, myInternal.as, se použije pro definování jmenného prostoru myInternal. Protože soubor je v balíčku
pojmenovaném podle příkladu, musíte umístit soubor do složky pojmenované podle příkladu. Jmenný prostor je
označen jako public, takže jej lze importovat do ostatních balíčků.
// myInternal.as in folder example
package example
{
public namespace myInternal = "http://www.adobe.com/2006/actionscript/examples";
}
Druhý a třetí soubor, Utility.as a Helper.as, definují třídy obsahující metody, které by měly být dostupné pro ostatní
balíčky. Třída Utility je v balíčku example.alpha, což znamená, že soubor by měl být umístěn dovnitř složky
pojmenované alpha, která je podsložkou složky v příkladu. Třída Helper je v balíčku example.beta, což znamená, že
soubor by měl být umístěn dovnitř složky pojmenované beta, která je podsložkou složky v příkladu. Oba tyto balíčky,
example.alpha i example.beta, musí importovat jmenný prostor před jeho použitím.
// Utility.as in the example/alpha folder
package example.alpha
{
import example.myInternal;
public class Utility
{
private static var _taskCounter:int = 0;
public static function someTask()
{
_taskCounter++;
}
myInternal static function get taskCounter():int
{
return _taskCounter;
}
}
}
43
// Helper.as in the example/beta folder
package example.beta
{
import example.myInternal;
public class Helper
{
private static var _timeStamp:Date;
public static function someTask()
{
_timeStamp = new Date();
}
myInternal static function get lastCalled():Date
{
return _timeStamp;
}
}
}
Čtvrtý soubor, NamespaceUseCase.as, je hlavní třídou aplikaci a měl by být příbuzným složky příkladu. V aplikaci
Flash Professional tato třída bude použita jako třída dokumentu pro FLA. Třída NamespaceUseCase rovněž importuje
jmenný prostor myInternal a používá jej pro zavolání statických metod, které spočívají v jiných balíčcích. Příklad
používá statické metody pouze pro zjednodušení kódu. Statické a instanční metody mohou být vloženy do jmenného
prostoru myInternal.
// NamespaceUseCase.as
package
{
import example.myInternal; // import namespace
import example.alpha.Utility;// import Utility class
import example.beta.Helper;// import Helper class
public class NamespaceUseCase extends MovieClip
{
public function NamespaceUseCase()
{
use namespace myInternal;
Utility.someTask();
Utility.someTask();
trace(Utility.taskCounter); // 2
Helper.someTask();
trace(Helper.lastCalled); // [time someTask() was last called]
}
}
}
44
Proměnné
Proměnné umožňují uložit hodnoty, které v programu používáte. Pro deklarování proměnné musíte použít příkaz var
s názvem proměnné. V jazyce ActionScript 3.0 je použití příkazu var vyžadováno vždy. Například následující řádek
jazyka ActionScript deklaruje proměnnou pojmenovanou i:
var i;
Pokud při deklarování proměnné vynecháte příkaz var, zobrazí se v přísném režimu chyba kompilátoru a ve
standardním režimu chyba spuštění. Následující řádek kódu například způsobí chybu v případě, že proměnná i nebyla
dříve definována:
i; // error if i was not previously defined
Pro spojení proměnné s datovým typem musíte toto učinit, když deklarujete proměnnou. Deklarování proměnné bez
označení jejího typu je povoleno, ale v přísném režimu vyvolá výstrahu kompilátoru. Typ proměnné definujete
připojením dvojtečky (:) za název a typem proměnné. Například následující kód deklarujete proměnnou i typu int:
var i:int;
Můžete přiřadit hodnotu proměnné pomocí operátoru (=). Například následující kód deklarujete proměnnou i a
přiřazuje jí hodnotu 20:
var i:int;
i = 20;
Patrně bude pohodlnější přiřadit hodnotu proměnné ve stejný okamžik, když deklarujete proměnnou, jako v
následujícím příkladu:
var i:int = 20;
Technika přiřazování hodnoty proměnné v době její deklarace je běžně použita nejenom pro přiřazování primitivních
hodnot, jako jsou celočíselné hodnoty a řetězce, ale také při vytváření pole nebo konkretizaci instance třídy.
Následující příklad zobrazuje pole, které má deklarovanou a přiřazenou hodnotu pomocí jedné řádky kódu.
var numArray:Array = ["zero", "one", "two"];
Můžete vytvořit instanci třídy pomocí operátoru new. Následující příklad vytváří instanci pojmenovanou
CustomClass a přiřazuje referenci nově vytvořené instanci třídy proměnné pojmenované customItem:
var customItem:CustomClass = new CustomClass();
Pokud máte pro deklarován více než jednu proměnnou, můžete deklarovat všechny v jedné řádce pomocí operátoru
čárka (,) a proměnné tak oddělit. Například následující kód deklarujete tři proměnné v jedné řádce kódu:
var a:int, b:int, c:int;
Můžete také přiřadit hodnoty každé proměnné ve stejné řádce kódu. Například následující kód deklaruje tři proměnné
(a, b a c) a přiřazuje každé hodnotu:
var a:int = 10, b:int = 20, c:int = 30;
I když můžete použít operátor čárka pro seskupení deklarace proměnných do jednoho příkazu, může to snížit čitelnost
kódu.
45
Porozumění rozsahu proměnných
Rozsah proměnné představuje oblast kódu, kde může být proměnná zpřístupněna lexikálním odkazem. Globální
proměnná je taková, která je definovaná ve všech oblastech kódu, zatímco lokální proměnná je taková, která je
definována pouze v jedné části kódu. V jazyce ActionScript 3.0 mají proměnné vždy přiřazen rozsah funkce nebo třídy,
ve které jsou deklarované. Globální proměnná je taková, kterou definujete vně funkce nebo definice třídy. Například
následující kód vytváří globální proměnnou strGlobal jejím deklarováním vně veškerých funkcí. Příklad ukazuje, že
globální proměnná je k dispozici uvnitř a vně definice funkce.
var strGlobal:String = "Global";
function scopeTest()
{
trace(strGlobal); // Global
}
scopeTest();
trace(strGlobal); // Global
Místní proměnou deklarujete pomocí proměnné uvnitř definice funkce. Nejmenší oblast kódu, pro kterou lze
definovat místní proměnnou, je definice funkce. Místní proměnná deklarovaná v rámci funkce existuje pouze v této
funkci. Pokud například deklarujete proměnnou s názvem str2 v rámci funkce nazvané localScope(), tato
proměnná nebude vně funkce dostupná.
function localScope()
{
var strLocal:String = "local";
}
localScope();
trace(strLocal); // error because strLocal is not defined globally
Pokud název proměnné použité jako místní proměnná bude již deklarován jako globální proměnná, místní definice
skryje (nebo vytvoří stín) globální definici, když bude místní proměnná v jejím rozsahu. Globální proměnná se stále
vyskytuje vně funkce. Například následující kód vytváří globální řetězcovou proměnnou pojmenovanou str1 a pak
vytváří místní proměnou stejného názvu uvnitř funkce scopeTest(). Příkaz trace uvnitř funkce odesílá na výstup
místní hodnotu proměnné, ale příkaz trace vně funkce odesílá na výstup globální hodnotu proměnné.
var str1:String = "Global";
function scopeTest ()
{
var str1:String = "Local";
trace(str1); // Local
}
scopeTest();
trace(str1); // Global
Proměnné jazyka ActionScript, na rozdíl od proměnných v C++ a Java, nemají rozsah blok-úroveň. Blok kódu je
libovolná skupina příkazů mezi levou složenou závorkou ( { ) a pravou složenou závorkou ( } ). V některých
programovacích jazycích, například C++ a Java, proměnné deklarované uvnitř bloku kódu nejsou dostupné vně
tohoto bloku. Toto omezení je nazváno rozsah blok-úroveň a v jazyce ActionScript neexistuje. Pokud deklarujete
proměnnou uvnitř bloku kódu, tato proměnná nebude dostupná pouze v tomto bloku kódu, ale také v ostatních
částech funkce, ke které blok kódu náleží. Například následující funkce obsahuje proměnné, které jsou definované v
různých rozsazích bloku. Všechny proměnné jsou dostupné prostřednictvím funkce.
46
function blockTest (testArray:Array)
{
var numElements:int = testArray.length;
if (numElements > 0)
{
var elemStr:String = "Element #";
for (var i:int = 0; i < numElements; i++)
{
var valueStr:String = i + ": " + testArray[i];
trace(elemStr + valueStr);
}
trace(elemStr, valueStr, i); // all still defined
}
trace(elemStr, valueStr, i); // all defined if numElements > 0
}
blockTest(["Earth", "Moon", "Sun"]);
Zajímavým dopadem neexistence rozsahu blok-úroveň je to, že můžete číst proměnnou nebo do ní zapisovat předtím,
než je deklarovaná, pokud je deklarovaný před ukončením funkce. Tak tomu je díky technice nazvané zvedání, což
znamená, že kompilátor přesouvá všechny deklarace proměnných na horní stranu funkce. Například následující kód
je zkompilován i v případě, že se počáteční funkce trace() pro proměnnou num vyskytuje před deklarováním
proměnné num:
trace(num); // NaN
var num:Number = 10;
trace(num); // 10
Kompilátor však „nezvedne“ žádné příkazy přiřazení. To vysvětluje, proč počáteční trace() proměnné num vede k
NaN (není číslo), což je výchozí hodnota proměnných datového typu Number. To znamená, že můžete přiřadit
hodnoty proměnným ještě před jejich deklarováním, jak je vidět v následujícím příkladu:
num = 5;
trace(num); // 5
var num:Number = 10;
trace(num); // 10
Výchozí hodnoty
Výchozí hodnota je hodnota, kterou proměnná obsahuje před nastavením její hodnoty. Proměnnou inicializujete, když
poprvé nastavíte její hodnotu. Pokud deklarujete proměnou, ale nenastavíte její hodnotu, tato proměnná bude
neinicializovaná. Hodnota neinicializované proměnné závisí na datovém typu. Následující tabulka popisuje výchozí
hodnoty proměnných organizované podle datového typu:
Typ dat
Výchozí hodnota
Booleovské
false
int
0
Number
NaN
Objekt
null
Řetězec
null
47
Typ dat
Výchozí hodnota
uint
0
Není deklarováno (ekvivalent anotaci typu *)
undefined
Všechny ostatní třídy, včetně uživatelem definovaných tříd.
null
Pro proměnné typu Number je výchozí hodnota NaN (není číslo), což je speciální hodnota definovaná standardem
IEEE-754 pro vyjádření hodnoty, která nepředstavuje číslo.
Pokud deklarujete proměnnou, ale nikoliv její datový typ, bude platit výchozí datový typ *, což ve skutečnosti
znamená, že proměnná bude bez typu. Pokud také neinicializujete proměnnou bez typu pomocí hodnoty, její výchozí
hodnota je undefined.
Pro datové typy jiné, než Boolean, Number, int a uint je výchozí hodnota kterékoliv proměnné null. To platí pro
všechny třídy definované jazykem ActionScript 3.0, stejně jako pro všechny vlastní třídy, které vytvoříte.
Hodnota null není platnou hodnotou pro proměnné typu Boolean, Number, int nebo uint. Pokud se pokusíte přiřadit
hodnotu null takové proměnné, hodnota je převedena na výchozí hodnotu pro daný datový typ. Pro proměnné typu
Object můžete přiřadit hodnotu null. Pokud se pokusíte přiřadit hodnotu undefined proměnné typu Object,
hodnota je převedena na null.
Pro proměnné typu Number existuje speciální funkce horní úrovně pojmenovaná isNaN(), která vrací booleovskou
hodnotu true v případě, že proměnná není číslem, jinak vrací hodnotu false.
Typy dat
Datový typ definuje soubor hodnot. Například datový typ booleovská hodnota je souborem přesně dvou hodnot: true
a false. Kromě datového typu booleovská hodnota jazyk ActionScript 3.0 definuje několik běžně používaných
datových typů, například String, Number a Array. Můžete definovat vlastní datové typy pomocí tříd nebo rozhraní a
definovat tak vlastní soubor hodnot. Všechny hodnoty v jazyce ActionScript 3.0, ať už primitivní nebo komplexní, jsou
objekty.
Primitivní hodnota je hodnota náležející jednomu z následujících datových typů: booleovský, int, Number, String a
uint. Práce s primitivními hodnotami je obvykle rychlejší než s komplexními hodnotami, protože jazyk ActionScript
ukládá primitivní hodnoty speciálním způsobem, které umožňuje optimalizaci paměti a rychlosti.
Poznámka: Pro čtenáře se zájmem o technické podrobnosti jazyk ActionScript ukládá primitivní hodnoty interně jako
nezměnitelné objekty. Ve skutečnosti to, že jsou uloženy jako nezměnitelné objekty znamená, že předání odkazem je
efektivně shodné jako předání hodnotou. To snižuje využití paměti a zvyšuje rychlost vykonávání, protože odkazy jsou
obvykle výrazně menší než hodnoty samotné.
Komplexní hodnota je hodnota, která není primitivní. Datové typy definující komplexní hodnoty zahrnují: Array,
Date, Error, Function, RegExp, XML a XMLList.
Mnoho programovacích jazyků odlišuje mezi primitivními hodnotami a jejich objekty obalu. Například jazyk Java má
primitivní hodnotu int a třídu java.lang.Integer, která jí obaluje. Primitivní hodnoty Java nejsou objekty, ale jejich
obaly ano, což činí primitivní hodnoty užitečné pro jedny operace a objekty obalu vhodnější pro jiné operace. V jazyku
ActionScript 3.0 primitivní hodnoty a jejich objekty obalu jsou z praktických účelů nerozlišitelné. Všechny hodnoty, i
primitivní hodnoty, jsou objekty. Běhový modul pracuje s těmito primitivními typy jako se speciálními případy, které
se chovají jako objekty, ale nevyžadují normální doplňky související s vytvářením objektů. To znamená, že následující
dva řádky kódu jsou shodné:
48
var someInt:int = 3;
var someInt:int = new int(3);
Všechny primitivní a komplexní datové typy uvedené výše jsou definovány třídami jádra jazyka ActionScript 3.0.
Třídy jádra umožňují vytvářet objekty pomocí liberálových hodnot namísto pomocí operátoru new. Například můžete
vytvořit pole pomocí literálové hodnoty nebo konstruktoru třídy Array, a to takto:
var someArray:Array = [1, 2, 3]; // literal value
var someArray:Array = new Array(1,2,3); // Array constructor
Kontrola typu
Kontrola typu může nastat buď v čase kompilace nebo v čase spuštění. Staticky zadávané jazyky, například C++ a Java,
provádějí kontrolu typu v okamžiku kompilace. Dynamicky zadávané jazyky, například Smalltalk a Python, provádějí
kontrolu typu v okamžiku spuštění. Jako dynamicky zadávaný má jazyk ActionScript 3.0 kontrolu typu během
spouštění, ale podporuje také kontrolu během kompilace díky speciálnímu režimu kompilátoru, nazvanému přísný
režim. V přísném režimu kontrola typu nastává v čase kompilace i spuštění, ale ve standardním režimu pouze v čase
spuštění.
Dynamicky zadávané jazyky nabízejí vynikající flexibilitu když svůj kód strukturujete, ale za cenu toho, že se chyby
typu projeví až v době spuštění. Staticky zadávané jazyky hlásí chyby typu v době kompilace, ale za cenu toho, že
vyžaduje známost informace typu v čase kompilace.
Kontrola typu v čase kompilace
Kontrola typu v čase kompilace je často vhodnější u větších projektů, protože s rostoucí velikostí projektu se obvykle
důležitost flexibility datového typu snižuje, na rozdíl od odstranění chyb typu, která je nutná co nejdříve. Proto je
kompilátor jazyka ActionScript v aplikacích Flash Professional a Flash Builder standardně nastaven na spouštění
v přísném režimu.
Adobe Flash Builder
Přísný režim lze v aplikaci Flash Builder vypnout pomocí nastavení kompilátoru jazyka ActionScript v dialogovém
okně Vlastnosti projektu.
K zajištění kontroly typu v čase kompilace je nutné, aby kompilátor znal informace o datovém typu pro proměnné
nebo výrazy použité v kódu. Chcete-li explicitně deklarovat datový typ pro proměnnou, přidejte operátor dvojtečku
(:) následovanou datovým typem jako příponou názvu proměnné. Chcete-li připojit k datovému typu parametr,
použijte operátor dvojtečku následovanou datovým typem. Například následující kód přidává informaci o datovém
typu k parametru xParam a deklaruje proměnnou myParam s explicitním datovým typem:
function runtimeTest(xParam:String)
{
trace(xParam);
}
var myParam:String = "hello";
runtimeTest(myParam);
V přísném režimu kompilátor jazyka ActionScript hlásí neshody typu jako chyby kompilátoru. Například následující
kód deklaruje parametr funkce xParam typu Object, ale později se pokusí přiřadit hodnoty typu String a Number
tomuto parametru. To v přísném režimu vede k chybě kompilátoru.
49
function dynamicTest(xParam:Object)
{
if (xParam is String)
{
var myStr:String = xParam; // compiler error in strict mode
trace("String: " + myStr);
}
else if (xParam is Number)
{
var myNum:Number = xParam; // compiler error in strict mode
trace("Number: " + myNum);
}
}
I v přísném režimu se můžete selektivně rozhodnout pro kontrolu v čase kompilace a to ponecháním pravé straně
přiřazovacího příkazu nezadané. Můžete označit proměnnou nebo výraz jako bez typu buď vynecháním anotace typu
nebo pomocí speciální anotace typu hvězdičky (*). Bude-li například parametr xParam v předchozím příkladu
modifikován tak, aby již neměl anotaci typu, bude kód zkompilován v přísném režimu:
function dynamicTest(xParam)
{
if (xParam is String)
{
var myStr:String = xParam;
trace("String: " + myStr);
}
else if (xParam is Number)
{
var myNum:Number = xParam;
trace("Number: " + myNum);
}
}
dynamicTest(100)
dynamicTest("one hundred");
Kontrola typu v době spuštění
Kontrola typu v době spuštění nastává v jazyce ActionScript 3.0 bez ohledu na to, zda kompilaci provádíte v přísném
nebo standardním režimu. Zvažte situaci, ve které je hodnota 3 předána jako argument funkci, která očekává pole. V
přísném režimu kompilátor vygeneruje chybu, protože hodnota 3 není kompatibilní s datovým typem Array. Pokud
přísný režim vypnete a spustíte standardní režim, nebude kompilátor neshodu typu signalizovat, ale kontrola typu za
běhu povede k vyvolání chyby v čase zpracování.
Následující příklad zobrazuje funkci pojmenovanou typeTest(), která očekává argument Array, avšak předána je
hodnota 3. To způsobí chybu v okamžiku spuštění ve standardním režimu, protože hodnota 3 není členem datového
typu (Array) deklarovaných pro parametr.
function typeTest(xParam:Array)
{
trace(xParam);
}
var myNum:Number = 3;
typeTest(myNum);
// run-time error in ActionScript 3.0 standard mode
50
Mohou také nastat situace, kde se zobrazí chyba dat při spuštění, i když pracujete v přísném režimu. To je možné v
případě použití přísného režimu, ale rozhodnete se nepoužívat kontrolu v okamžiku kompilace pomocí proměnné bez
stanoveného typu. Když použijete proměnnou bez stanoveného typu, neeliminujete kontrolu typu, ale spíše ji
odkládejte na dobu spuštění. Pokud například proměnná myNum v předchozím příkladu nemá deklarovaný datový typ,
nemůže kompilátor detekovat neshodu typu, ale kód vygeneruje chybu v čase zpracování, protože porovná hodnotu
za běhu parametru myNum, který je v důsledku příkazu přiřazení nastaven na hodnotu 3, s typem parametru xParam,
který je nastaven na datový typ Array.
function typeTest(xParam:Array)
{
trace(xParam);
}
var myNum = 3;
typeTest(myNum);
// run-time error in ActionScript 3.0
Kontrola typu v době spuštění rovněž umožňuje flexibilnější použití dědičnosti, než kontrola v době kompilace.
Odložením kontroly typu na dobu spuštění ve standardním režimu umožňuje odkazovat vlastnosti podtřídy i v
případě povýšení. Povýšení nastává v případě, že použijete základní třídu k deklarování typu instance třídy, ale ke
konkretizaci použijete podtřídu. Můžete například vytvořit třídu pojmenovanou ClassBase, která může být rozšířena
(třídy s atributem final nemohou být rozšířeny):
class ClassBase
{
}
Poté vytvoříte podtřídu pro ClassBase pojmenovanou ClassExtender, která má jednu vlastnost pojmenovanou
someString, a to takto:
class ClassExtender extends ClassBase
{
var someString:String;
}
Pomocí obou tříd můžete vytvořit instanci třídy, která je deklarovaná pomocí datového typu ClassBase, ale
konkretizována je pomocí konstruktoru ClassExtender. Povýšení je považováno za bezpečnou operaci, protože
základní třída neobsahuje žádné vlastnosti nebo metody, které nejsou v podtřídě.
var myClass:ClassBase = new ClassExtender();
Podtřída však neobsahuje vlastnosti nebo metody, které nemá základní třída. Například třída ClassExtender obsahuje
vlastnost someString, která ve třídě ClassBase neexistuje. V jazyce ActionScript 3.0 ve standardním režimu můžete
odkazovat tuto vlastnost pomocí instance myClass bez generování chyby v době kompilace, jak je vidět na
následujícím příkladu:
var myClass:ClassBase = new ClassExtender();
myClass.someString = "hello";
// no error in ActionScript 3.0 standard mode
Operátor is
Pomocí operátoru is lze testovat, zda je proměnná nebo výraz členem daného datového typu. V předchozí verzi jazyka
ActionScript operátor instanceof zajišťovat tutéž funkci, ale v ActionScript 3.0 operátor instanceof by neměl být
k testování členství v datovém typu používán. Operátor is by měl být použit namísto operátoru instanceof pro ruční
kontrolu typu, protože výraz x instanceof y pouze kontroluje prototypový řetězec x, zda-li existuje y (a v
ActionScript 3.0 prototypový řetězec neposkytuje kompletní obraz o hierarchii dědičnosti).
51
Operátor is prověřuje správnou hierarchii dědičnosti a lze jej použít ke kontrole nejenom zda je objekt instancí
specifické třídy, ale také ke kontrole, zda je objekt instancí třídy, která implementuje specifické rozhraní. Následující
příklad vytváří instanci třídy Sprite pojmenovanou mySprite a používá operátor is k testování, zda je mySprite
instancí tříd Sprite a DisplayObject a zda implementuje rozhraní IEventDispatcher:
var mySprite:Sprite = new Sprite();
trace(mySprite is Sprite); // true
trace(mySprite is DisplayObject);// true
trace(mySprite is IEventDispatcher); // true
Operátor is kontroluje hierarchii dědičnosti a správně hlásí, že mySprite je kompatibilní s třídami Sprite a
DisplayObject (třída Sprite je podtřídou třídy DisplayObject). Operátor is rovněž kontroluje, zda je mySprite
odvozená z některých tříd, které implementují rozhraní IEventDispatcher. Protože třída Sprite je odvozená z třídy
EventDispatcher, která implementuje rozhraní IEventDispatcher, operátor is správně hlásí, že mySprite
implementuje stejné rozhraní.
Následující příklad zobrazuje stejné testy z předchozího příkladu, avšak s operátorem instanceof namísto is.
Operátor instanceof správně identifikuje, že mySprite je instancí Sprite nebo DisplayObject, ale vrací false, když
je použit pro testování, zda mySprite implementuje rozhraní IEventDispatcher.
trace(mySprite instanceof Sprite); // true
trace(mySprite instanceof DisplayObject);// true
trace(mySprite instanceof IEventDispatcher); // false
Operátor as
Pomocí operátoru as lze rovněž kontrolovat, zda je výraz členem daného datového typu. Na rozdíl od operátoru is
nevrací operátor as booleovskou hodnotu. Místo toho operátor as vrací hodnotu výrazu, namísto true a hodnotu
null namísto false. Následující příklad ukazuje výsledky použití operátoru as místo operátoru is v jednoduchém
případě kontroly, zda je instance Sprite členem datových typů DisplayObject, IEventDispatcher a Number.
var mySprite:Sprite = new Sprite();
trace(mySprite as Sprite); // [object Sprite]
trace(mySprite as DisplayObject); // [object Sprite]
trace(mySprite as IEventDispatcher); // [object Sprite]
trace(mySprite as Number);
// null
Když použijete operátor as, operand na pravé straně musí být datovým typem. Pokus použít výraz jiný, než datový typ
na pravé straně povede k chybě.
Dynamické třídy
Dynamické třídy definují objekt, který může být změně v době spuštění přidáním nebo změnou vlastností a metod.
Třída, která není dynamická, například String, je zapouzdřenou třídou. Nemůžete přidávat vlastnosti nebo metody do
zapouzdřené třídy v době spuštění.
Dynamické třídy vytváříte pomocí atributu dynamic při deklarování třídy. Například následující kód vytváří
dynamickou třídu pojmenovanou Protean:
52
dynamic class Protean
{
private var privateGreeting:String = "hi";
public var publicGreeting:String = "hello";
function Protean()
{
trace("Protean instance created");
}
}
Jestliže později vytvoříte instanci třídy Protean, můžete k ní přidávat vlastnosti nebo metody vně definice třídy.
Například následující kód vytváří instanci třídy Protean a přidává vlastnost pojmenovanou aString a vlastnost
pojmenovanou aNumber do instance:
var myProtean:Protean = new Protean();
myProtean.aString = "testing";
myProtean.aNumber = 3;
trace(myProtean.aString, myProtean.aNumber); // testing 3
Vlastnosti přidané do instance dynamické třídy jsou entity spuštění, takže jakákoliv kontrola typu je prováděna v době
spuštění. Nemůžete přidat anotaci typu k vlastnosti, kterou přidáváte tímto způsobem.
Můžete také přidat metodu instanci myProtean definování funkce a připojením funkce k vlastnosti instance
myProtean. Následující kód přesouvá příkaz trace do metody pojmenované traceProtean():
var myProtean:Protean = new Protean();
myProtean.aString = "testing";
myProtean.aNumber = 3;
myProtean.traceProtean = function ()
{
trace(this.aString, this.aNumber);
};
myProtean.traceProtean(); // testing 3
Metody takto vytvořené nemají přístup k žádným soukromým vlastnostem nebo metodám třídy Protean. Kromě toho,
i reference na veřejné vlastnosti nebo metody třídy Protean musí být kvalifikovaná buď klíčový slovem this nebo
názvem třídy. Následující příklad ukazuje metodu traceProtean() pokoušející se o přístup k soukromé a veřejné
proměnné třídy Protean.
myProtean.traceProtean = function ()
{
trace(myProtean.privateGreeting); // undefined
trace(myProtean.publicGreeting); // hello
};
myProtean.traceProtean();
Popisy typů dat
Primitivní datové typy zahrnují Boolean, int, Null, Number, String, uint a void. Třídy jádra ActionScript rovněž
definují následující komplexní datové typy: Object, Array, Date, Error, Function, RegExp, XML a XMLList.
Datový typ Boolean
Datový typ Boolean zahrnuje dvě hodnoty: true (pravda) a false (nepravda). Pro booleovskou hodnotu nejsou
platné žádné jiné hodnoty. Výchozí hodnota booleovské proměnné, která byla deklarovaná, avšak neinicializována, je
false.
53
Datový typ int
Datový typ int je uložen interně jako 32bitová celočíselná hodnota a zahrnuje soubor celých čísel od
-2 147 483 648 (-231) do 2 147 483 647 (231 - 1) včetně. Předchozí verze jazyka ActionScript nabízely pouze datový typ
Number, který byl používán pro celočíselné hodnoty a hodnoty s desetinnou čárkou. V jazyce ActionScript 3.0 nyní
máte přístup k nízko úrovňovým typům pro 32bitové celočíselné hodnoty se znaménkem nebo bez něj. Pokud
proměnná nepotřebuje čísla s plovoucí čárkou, použití datového typu int místo datového typu Number by mělo být
rychlejší a účinnější.
Pro celočíselné hodnoty mimo rozsah minimální a maximální hodnoty int použijte datový typ Number, který dokáže
pracovat s hodnotami mezi kladnou a zápornou hodnotu 9 007 199 254 740 992 (53bitová celočíselná hodnota).
Výchozí hodnota pro proměnné, které jsou typu int, je 0.
Datový typ null
Datový typ null obsahuje pouze jednu hodnotu, null. Toto je výchozí hodnota pro datový typ String a všechny třídy,
které definují komplexní datové typy, včetně třídy Object. Žádný jiný primitivní datový typ, například Boolean,
Number, int a uint, hodnotu null neobsahuje. Pokud se za běhu pokusíte přiřadit hodnotu null k proměnné typu
Boolean, Number, int nebo uint, bude hodnota null převedena na odpovídající výchozí hodnotu. Nemůžete použít
tento datový typ jako anotaci typu.
Datový typ Number
V jazyce ActionScript 3.0 datový typ Number může zastupovat celočíselné hodnoty, celočíselné hodnoty bez
znaménka a desetinná čísla. Pro maximalizaci výkonu byste měli používat datový typ Number pouze pro celočíselné
hodnoty vyšší, než mohou uložit 32bitové typy int a uint nebo pro desetinná čísla. Chcete-li uložit desetinné číslo,
uveďte v čísle desetinnou čárku. Jestliže desetinnou čárku vynecháte, bude číslo uloženo jako celočíselná hodnota.
Datový typ Number využívá 64bitový formát s dvojitou přesností, jak je specifikováno standardem IEEE pro binární
aritmetiku s plovoucí desetinou čárkou (IEEE-754). Tento standard určuje, jak mají být desetinná čísla uložena
pomocí 64 dostupných bitů. Jeden bit se používá k označení, zda je číslo kladné nebo záporné. Jedenáct bitů se používá
pro exponent, který je uložen jako základ 2. Zbývajících 52 bitů se používá pro uložení mantisy (také significand), což
je číslo umocněné exponentem.
Použitím některých bitů k uložení exponentu může datový typ Number uložit desetinná čísla významně větší, než
pokud by byly všechny bity použity pro mantisu. Pokud například datový typ Number používá všech 64 bitů k uložení
mantisy, může uložit číslo až o hodnotě 265 - 1. Použitím 11 bitů k uložení exponentu může datový typ Number zvýšit
svou mantisu na mocninu 21023.
Maximální a minimální hodnoty, které může typ Number vyjadřovat, jsou uloženy ve statických vlastnostech třídy
Number nazvaných Number.MAX_VALUE a Number.MIN_VALUE.
Number.MAX_VALUE == 1.79769313486231e+308
Number.MIN_VALUE == 4.940656458412467e-324
I když tento rozsah čísel je enormní, cenou za tento rozsah je přesnost. Datový typ Number používá 52 bitů k uložení
mantisy s tím výsledkem, že čísla vyžadující k přesnému vyjádření více než 52 bitů, například zlomek 1/3, jsou pouze
přibližné aproximace. Pokud aplikace vyžaduje absolutní přesnost s desetinnými čísly, musíte použít software
implementující aritmetiku s desetinnými čísly v desítkové soustavě, jako protiklad aritmetiky desetinných čísel v
soustavě binární.
Když uložíte celočíselné hodnoty jako datový typ Number, použije se pouze 52 bitů mantisy. Datový typ Number
použije těchto 52 bitů a speciální skrytý bit k vyjádření celočíselné hodnoty od 9 007 199 254 740 992 (-253) do 9 007
199 254 740 992 (253).
54
Hodnota NaN slouží nejen jako výchozí hodnota pro proměnné typu Number, ale také jako výsledek každé operace,
která by měla vrátit číslo, ale nečiní tak. Pokud se například pokusíte vypočítat druhou odmocninu záporného čísla,
bude výsledkem hodnota NaN. Jiné speciální hodnoty Number zahrnují kladné nekonečno a záporné nekonečno.
Poznámka: Výsledkem dělení 0 je pouze NaN v případě, že dělitel je také 0. Dělení 0 dává ve výsledku infinity, pokud
je dělenec kladný, nebo -infinity, pokud je dělenec záporný.
Datový typ String
Datový typ String představuje posloupnost 16bitových znaků. Data String jsou uložena interně jako znaky Unicode,
pomocí formátu UTF-16. Data String jsou nezměnitelné hodnoty, stejně jako v programovacím jazyce Java. Operace
s hodnotou String vrací novou instanci řetězce. Výchozí hodnota proměnné deklarované datovým typem String je
null. Hodnota null není stejná jako prázdný řetězec („"). Hodnota null znamená, že proměnná v sobě nemá
uloženou žádnou hodnotu, zatímco prázdný řetězec značí, že proměnná má hodnotu, kterou je řetězec neobsahující
žádné znaky.
Datový typ uint
Datový typ uint je uložen interně jako 32bitová celočíselná hodnota bez znaménka a zahrnuje soubor celých čísel od 0
do 4 294 967 295 (232 - 1) včetně. Datový typ uint použijte pro zvláštní okolnosti, které volají po nezáporných
celočíselných hodnotách. Datový typ uint musíte například použít k vyjádření hodnot obrazového bodu, protože
datový typ unit má vnitřní bit pro znaménko a nehodí se pro manipulaci s hodnotami barev. Pro celočíselné hodnoty
větší než maximální hodnota uint použijte datový typ Number, který dokáže pracovat až s 53bitovými celočíselnými
hodnotami. Výchozí hodnota pro proměnné, které jsou typu uint je 0.
Datový typ void
Datový typ void obsahuje pouze jednu hodnotu, undefined. V předchozích verzích jazyka ActionScript byla hodnota
undefined výchozí pro instance třídy Object. V jazyce ActionScript 3.0 je výchozí hodnota pro instance Object null.
Pokud se pokusíte přiřadit hodnotu undefined instanci třídy Object, bude tato hodnota převedena na hodnotu null.
Hodnotu undefined můžete přiřadit pouze k proměnným, které nemají stanoven typ. Proměnné bez typu jsou ty,
které nemají anotaci typu, nebo používají symbol hvězdičky (*) jako anotaci typu. Můžete použít void pouze jako
anotaci vráceného typu.
Datový typ Object
Datový typ Object je definován třídou Object. Třída Objekt slouží jako základní třída pro všechny definice tříd v jazyce
ActionScript. Datový typ Object ve verzi ActionScript 3.0 se odlišuje od předchozích verzí třemi způsoby. První,
datový typ Object již není výchozím pro proměnné bez anotace typu. Druhý, datový typ Object již nezahrnuje hodnotu
undefined, která byla výchozí hodnotou pro instance Object. Třetí, v jazyce ActionScript 3.0 je výchozí hodnota
instance třídy Object null.
V předchozích verzích jazyka ActionScript byla proměnná bez anotace typu automaticky definována jako datový typ
Object. Tak tomu již v jazyce ActionScript 3.0 není, protože zde se využívá proměnná skutečně bez definovaného typu.
Proměnné bez anotace typu jsou nyní považovány za proměnné bez typu. Chcete-li čtenářům kódu objasnit, že vaším
záměrem je ponechat proměnnou bez definice typu, můžete pro anotaci typu použít symbol hvězdičky (*), což je
stejné, jako byste anotaci typu vynechali. Následující příklad ukazuje dva shodné příkazy, které deklarují proměnnou
bez typu x:
var x
var x:*
55
Pouze proměnné bez typu mohou uchovávat hodnoty undefined. Jestliže se pokusíte přiřadit hodnotu undefined
proměnné mající datový typ, převede běhový modul hodnotu undefined na výchozí hodnotu daného datového typu.
Pro instance datového typu Object je výchozí hodnota null, což znamená, že pokud se instanci třídy Object pokusíte
přiřadit hodnotu undefined, bude tato hodnota převedena na hodnotu null.
Převody typu
Převod typu nastává v případě, že hodnota je transformované do hodnoty odlišného datového typu. Převody typu
mohou být buď implicitní, nebo explicitní. Za běhu se někdy provádí implicitní převod, rovněž označovaný jako
donucení. Bude-li například proměnné datového typu Boolean přiřazena hodnota 2, bude hodnota 2 převedena na
booleovskou hodnotu true před tím, než bude tato hodnota přiřazena proměnné. Explicitní převod, nazývaný
obsazování, nastává v případě, že kód vydává instanci kompilátoru, aby s proměnnou jednoho datového typu zacházel,
jako by náležela jinému datovému typu. Když se procesu účastní primitivní hodnoty, obsazování ve skutečnosti
převede hodnoty z jednoho datového typu na jiný. Chcete-li obsadit objekt jiným datovým typem, vložte jej do závorek
a předsaďte název nového typu. Například následující kód přebírá booleovskou hodnotu a obsahuje ji celočíselnou
hodnotou:
var myBoolean:Boolean = true;
var myINT:int = int(myBoolean);
trace(myINT); // 1
Implicitní převody
Implicitní převody nastávají v době spuštění v mnoha kontextech:
• Během příkazu přiřazení
• Když jsou hodnoty předány jako argumenty funkce
• Když jsou hodnoty vráceny z funkcí
• Ve výrazech využívajících jisté operátory, například přidání operátoru (+)
Pro uživatelem definované typy uspějí implicitní převody tam, kde je převáděná hodnota instancí cílové třídy nebo
třídy, které je odvozena od své cílové třídy. Pokud je implicitní převod neúspěšný, je signalizována chyba. Například
následující kód obsahuje úspěšný i neúspěšný implicitní převod.
class A {}
class B extends A {}
var objA:A = new A();
var objB:B = new B();
var arr:Array = new Array();
objA = objB; // Conversion succeeds.
objB = arr; // Conversion fails.
Pro primitivní typy jsou implicitní převody zpracovávány voláním stejných vnitřních převodních algoritmů, které
jsou volány explicitními převodními funkcemi.
Explicitní převody
Je užitečné používat explicitní převody nebo obsazování, když kompilujete kód v přísném režimu, protože se mohou
vyskytovat okamžiky, kdy nechcete, aby neshoda typu vygenerovala chybu v době kompilace. Tak tomu může být v
případě, že vynucení převede vaše hodnoty správně v době spuštění. Například při práci s daty přijatým z formuláře
se můžete spolehnout na vynucení a převést jisté řetězcové hodnoty na numerické hodnoty. Následující kód
vygeneruje chybu v době kompilace, ale kód bude ve standardním režimu pracovat správně:
56
var quantityField:String = "3";
var quantity:int = quantityField; // compile time error in strict mode
Pokud chcete pokračovat v přísném režimu, ale chcete převést řetězec na celočíselnou hodnotu, můžete použít
explicitní převod a to takto:
var quantityField:String = "3";
var quantity:int = int(quantityField); // Explicit conversion succeeds.
Obsazení do int, uint a Number
Můžete obsadit kterýkoliv datový typ jedním ze tří typů čísel: int, uint a Number. Nelze-li číslo z nějakého důvodu
převést, přiřadí se datovým typům int a unint výchozí hodnota 0 a datovému typu Number se přiřadí výchozí hodnota
NaN. Pokud převedete na číslo booleovskou hodnotu, z hodnoty true se stane hodnota 1 a z false bude 0.
var myBoolean:Boolean = true;
var myUINT:uint = uint(myBoolean);
var myINT:int = int(myBoolean);
var myNum:Number = Number(myBoolean);
trace(myUINT, myINT, myNum); // 1 1 1
myBoolean = false;
myUINT = uint(myBoolean);
myINT = int(myBoolean);
myNum = Number(myBoolean);
trace(myUINT, myINT, myNum); // 0 0 0
Řetězcové hodnoty obsahující pouze číslice mohou být úspěšně převedeny do jednoho z číselných typů. Číselný typ
může také převést řetězce, které vypadají jako záporná číselná hodnota nebo šestnáctková hodnota (například 0x1A).
Proces převodu ignoruje prázdné znaky na začátku a na konci v hodnotě řetězce. Můžete také obsadit řetězce, které
vypadají jako desetinná čísla a to pomocí Number(). Zahrnutí desetinné čárky způsobuje, že uint() a int() vrátí
celočíselnou hodnotu a zkrátí se desetinná hodnota a znaky za ní následující. Například následující hodnoty řetězce
mohou obsadit čísla.
trace(uint("5")); // 5
trace(uint("-5")); // 4294967291. It wraps around from MAX_VALUE
trace(uint(" 27 ")); // 27
trace(uint("3.7")); // 3
trace(int("3.7")); // 3
trace(int("0x1A")); // 26
trace(Number("3.7")); // 3.7
Hodnoty řetězce obsahující nečíselné znaky vrátí 0, když jsou obsazeny s int() nebo uint() a NaN, když jsou
obsazeny Number(). Proces převodu ignoruje prázdné znaky na začátku a na konci, ale vrací 0 nebo NaN, pokud má
řetězec prázdný znak oddělující dvě čísla.
trace(uint("5a")); // 0
trace(uint("ten")); // 0
trace(uint("17 63")); // 0
V jazyce ActionScript 3.0 funkce Number() již nepodporuje oktálová čísla, nebo čísla s osmičkovým základem. Pokud
řetězec s nulou na začátku předáte v jazyce ActionScript 2.0 funkci Number(), číslo bude interpretováno jako oktálové
číslo a převedeno na desítkovou hodnotu. V případě funkce Number() v jazyce ActionScript 3.0 tomu tak není, zde se
první nula ignoruje. Například následující kód vygeneruje jiný výstup při kompilování v různých verzích jazyka
ActionScript:
trace(Number("044"));
// ActionScript 3.0 44
// ActionScript 2.0 36
57
Obsazení není nutné, pokud hodnota jednoho číselného typu bude přiřazena proměnné s jiným číselným typem. I v
přísném režimu jsou číselné typy implicitně převáděny na jiné číselné typy. To znamená, že v některých případech se
mohou vyskytnout neočekávané hodnoty, pokud je překročen rozsah typu. Všechny následující příklady jsou
kompilovány v přísném režimu, ačkoliv některé generují neočekávané hodnoty:
var myUInt:uint = -3; // Assign int/Number value to uint variable
trace(myUInt); // 4294967293
var myNum:Number = sampleUINT; // Assign int/uint value to Number variable
trace(myNum) // 4294967293
var myInt:int = uint.MAX_VALUE + 1; // Assign Number value to uint variable
trace(myInt); // 0
myInt = int.MAX_VALUE + 1; // Assign uint/Number value to int variable
trace(myInt); // -2147483648
Následující tabulka uvádí souhrn výsledků obsazení do datového typu Number, int nebo uint z jiného datového typu.
Datový typ nebo hodnota Výsledek převodu na typ Number, int nebo uint
Booleovské
Pokud je hodnota true, pak 1; jinak 0.
Datum
Vnitřní vyjádření objektu Date, což je počet milisekund od půlnoci 1. ledna 1970 univerzálního času.
null
0
Objekt
Pokud je instance null a převedená na Number, pak NaN; jinak 0.
Řetězec
Číslo, pokud lze řetězec převést na číslo, v opačném případě hodnota NaN, pokud je převeden na datový typ
Number, nebo 0, je-li převeden na datový typ int nebo uint.
undefined
Pokud převedeno na Number, pak NaN; pokud převedeno na int nebo uint, tak 0.
Obsazení do Booleovské hodnoty
Obsazení do Booleovské hodnoty z kteréhokoliv číselného datového typu int, unit a Number) vede k hodnotě false,
pokud je číselná hodnota 0, a v ostatních případech k hodnotě true. Pro datový typ Number hodnota NaN také vede k
false. Následující příklad ukazuje výsledky obsazení čísel -1, 0 a 1:
var myNum:Number;
for (myNum = -1; myNum<2; myNum++)
{
trace("Boolean(" + myNum +") is " + Boolean(myNum));
}
Výstup příklad ukazuje, že ze tří čísel pouze 0 vrací hodnotu false:
Boolean(-1) is true
Boolean(0) is false
Boolean(1) is true
Obsazení do Booleovské hodnoty z hodnoty String vrací false v případě, že řetězec je null nebo prázdný řetězec ("").
V opačném případě vrací true.
58
var str1:String; // Uninitialized string is null.
trace(Boolean(str1)); // false
var str2:String = ""; // empty string
trace(Boolean(str2)); // false
var str3:String = " "; // white space only
trace(Boolean(str3)); // true
Obsazení do Booleovské hodnoty z instance třídy Object vrací false, pokud je instance null; jinak vrací true:
var myObj:Object; // Uninitialized object is null.
trace(Boolean(myObj)); // false
myObj = new Object(); // instantiate
trace(Boolean(myObj)); // true
Booleovská proměnná je v přísném režimu zpracovávána zvláštním způsobem v tom, že booleovské proměnné můžete
přiřadit hodnoty kteréhokoliv datového typu bez obsazování. Implicitní vynucení ze všech datových typů do
booleovského datového typu nastává i v přísném režimu. Jinými slovy na rozdíl od téměř všech ostatních datových
typů obsazení do booleovské hodnoty není nutné k tomu, abyste se vyhnuli chybám přísného režimu. Následující
příklad jsou všechny kompilovány v přísném režimu a chovají se v době spuštění podle očekávání.
var myObj:Object = new Object(); // instantiate
var bool:Boolean = myObj;
trace(bool); // true
bool = "random string";
bool = new Array();
bool = NaN;
trace(bool); // false
Následující tabulka uvádí souhrn výsledků obsazení do datového typu Boolean z jiných datových typů.
Datový typ nebo hodnota
Výsledky převodu do booleovské hodnoty
Řetězec
false, pokud je hodnota null nebo prázdný řetězec (""); jinak true.
null
false
Number, int nebo uint
false, pokud je hodnota NaN nebo 0; jinak true.
Objekt
false, pokud je instance null; jinak true.
Obsazení do String
Obsazení do datového typu String z kteréhokoliv číselného datového typu vrací řetězcové vyjádření čísla. Obsazení do
datového typu String z booleovské hodnoty vrací řetězec"true", pokud je hodnota true, a řetězec "false", pokud je
hodnota false.
Obsazení do datového typu String z instance třídy Object vrací řetězec "null", pokud je instance null. Jinak obsazení
do datového typu String z třídy Object vrací řetězec "[object Object]".
Obsazení do datového typu String z instance třídy Array vrací řetězec tvořený seznamem všech prvků pole oddělených
čárkami. Například následující datový typ String vrací jeden řetěze obsahující všechny tři prvky pole:
var myArray:Array = ["primary", "secondary", "tertiary"];
trace(String(myArray)); // primary,secondary,tertiary
59
Obsazení do datového typu String z instance třídy date vrací řetězec vyjadřující datum, které instance obsahuje.
Například následující příklad vrací vyjádření instance třídy date (výstup ukazuje výsledek pro pacifický letní čas):
var myDate:Date = new Date(2005,6,1);
trace(String(myDate)); // Fri Jul 1 00:00:00 GMT-0700 2005
Následující tabulka uvádí souhrn výsledků obsazení do datového typu String z jiných datových typů.
Datový typ nebo hodnota
Výsledky převodu do řetězce
Pole
Řetězec tvořený všemi elementy pole.
Booleovské
"true" nebo "false"
Datum
Řetězcové vyjádření objektu Date.
null
"null"
Number, int nebo uint
Řetězcové vyjádření čísla.
Objekt
Pokud je instance null, "null"; jinak "[object Object]".
Syntaxe
Syntaxe jazyka definuje soubor pravidel, které musí být dodrženy při zapisování spustitelného kódu.
Rozlišování velkých a malých písmen
Jazyk ActionScript 3.0 využívá rozlišování velkých a malých písmen. Identifikátory, které se liší pouze velkým/malým
písmem, jsou považovány za odlišné identifikátory. Například následujíc kódy vytváří dvě různé proměnné
var num1:int;
var Num1:int;
Tečková syntaxe
Operátor tečka (.) poskytuje způsob přístupu k vlastnosti a metodě objektu. Pomocí tečkové syntaxe můžete
odkazovat na vlastnost třídy nebo metodu pomocí názvu instance, za kterým následující operátor tečka a název
vlastnosti nebo metody. Například zvažte následující definici třídy:
class DotExample
{
public var prop1:String;
public function method1():void {}
}
Pomocí tečkové syntaxe můžete přistupovat k vlastnosti prop1 a metodě method1() pomocí instance vytvořené
následujícím kódem:
var myDotEx:DotExample = new DotExample();
myDotEx.prop1 = "hello";
myDotEx.method1();
Tečkovou syntaxi můžete použít při definování balíčků. Operátor tečka můžete použít k odkazování na vnořené
balíčky. Například třída EventDispatcher spočívá uvnitř balíčku pojmenovaném events, který je vnořen do balíčku
pojmenovaného flash. Pomocí výrazu následujícího můžete odkazovat na balíček events:
flash.events
60
Pomocí následujícího výrazu můžete také odkazovat na třídu EventDispatcher:
flash.events.EventDispatcher
Lomítková syntaxe
Lomítková syntaxe není v jazyce ActionScript 3.0 podporována. Lomítková syntaxe byla používána v dřívějších verzích
jazyka ActionScript pro označení cesty filmového klipu nebo proměnné.
Literály
Literál je hodnota zobrazující se přímo ve vašem kódu. Následující příklady jsou všechno literály:
17
"hello"
-3
9.4
null
undefined
true
false
Literály mohou být také seskupeny do složených literálů. Literálová pole jsou uložena mezi závorkami ([]) a k
oddělení prvků pole používají čárku.
Literálové pole lze použít pro inicializaci pole. Následující příklady zobrazují dvě pole, která jsou inicializována
pomocí literálových polí. Můžete použít příkaz new a předat složený literál jako parametr do konstruktoru třídy Array,
ale můžete také přiřadit literálové hodnoty přímo při vytváření instancí následujících klíčových tříd jazyka
ActionScript: Object, Array, String, Number, int, uint, XML, XMLList a Boolean.
// Use new statement.
var myStrings:Array = new Array(["alpha", "beta", "gamma"]);
var myNums:Array = new Array([1,2,3,5,8]);
// Assign literal directly.
var myStrings:Array = ["alpha", "beta", "gamma"];
var myNums:Array = [1,2,3,5,8];
Literály mohou být také použity pro inicializaci generického objektu. Generický objekt je instancí třídy Object.
Literálové objekty jsou uvedeny ve složených závorkách ({}) a k oddělení vlastností objektu používají čárku. Každá
vlastnost je deklarovaná znakem dvojtečky (:), která odděluje název vlastnosti od její hodnoty.
Generický objekt můžete vytvořit pomocí příkazu new a předat literálový objekt jako parametr do konstruktoru třídy
Object, nebo můžete přiřadit literálový objekt přímo instanci, kterou deklarujete. Následující příklad ukazuje dva
alternativní způsoby vytváření nového generického objektu a inicializace objektu s třemi vlastnostmi (propA, propB a
propC), každá z těchto hodnot je nastavena na 1, 2 a 3:
// Use new statement and add properties.
var myObject:Object = new Object();
myObject.propA = 1;
myObject.propB = 2;
myObject.propC = 3;
// Assign literal directly.
var myObject:Object = {propA:1, propB:2, propC:3};
61
Práce s řetězci
Používání regulárních výrazů
Inicializace proměnných XML
Středníky
Středník (;) můžete použít k ukončení příkazu. Případně pokud středník vynecháte, bude kompilátor předpokládat,
že každá řádka kódu představuje jeden příkaz. Protože mnoho programátorů je zvyklých na středník jako znak
ukončení příkazu, může být snazší kód číst, pokud jej budete používat k ukončení příkazů konzistentně.
Použití středníku k ukončení příkazu umožňuje vložení více než jednoho příkazu do jedné řádky, ale to však může kód
znepřehlednit.
Závorky
Závorky (()) můžete v jazyce ActionScript 3.0 použít třemi způsoby. Za prvé, závorky můžete použít pro změnu
pořadí operací ve výrazu. Operace seskupené uvnitř závorek jsou vždy vykonávány jako první. Například závorky jsou
použité pro změnu pořadí operací v následujícím kódu:
trace(2 + 3 * 4); // 14
trace((2 + 3) * 4); // 20
Za druhé, závorky můžete použít s čárkou (,) pro vyhodnocení řady výrazů a vrácení výsledků konečného výrazu, jak
je vidět na následujícím příkladu:
var a:int = 2;
var b:int = 3;
trace((a++, b++, a+b)); // 7
Za třetí, závorky můžete použít jako funkce nebo metody, jak je vidět na následujícím příkladu, které předají hodnotu
String funkci trace():
trace("hello"); // hello
Poznámky
Kód jazyka ActionScript 3.0 podporuje dva typy komentářů: jednořádkový a víceřádkový. Tyto mechanismy
komentářů jsou podobné jazykům C++ a Java. Kompilátor bude ignorovat text označený jako komentář.
Jednořádkové komentáře začínají dopředným lomítkem (//) a pokračují na konec řádky. Například následující kód
obsahuje jednořádkový komentář:
var someNumber:Number = 3; // a single line comment
Víceřádkový komentář začíná dopředným lomítkem a hvězdičkou(/*) a končí hvězdičkou a dopředným lomítkem
(*/).
/* This is multiline comment that can span
more than one line of code. */
62
Klíčová slova jsou vyhrazená slova
Vyhrazená slova jsou slova, která nemůžete použít jako identifikátory v kódu, protože jsou vyhrazena pro použití
jazykem ActionScript. Vyhrazená slova zahrnují lexikální klíčová slova, která jsou vyňata z jmenného prostoru
programu kompilátorem. Kompilátor nahlásí chybu, pokud lexikální klíčová slova použijete jako identifikátor.
Následující tabulka uvádí seznam lexikálních klíčových slov jazyka ActionScript 3.0.
as
break
case
catch
class
const
continue
default
delete
do
else
extends
false
finally
for
function
if
implements
import
in
instanceof
interface
internal
is
native
new
null
package
private
protected
public
return
super
switch
this
throw
to
true
try
typeof
use
var
void
while
with
Existuje malá sada klíčových slov, nazvaných syntaktická klíčová slova, která mohou být použita jako identifikátory,
ale mají v jistém kontextu speciální význam. Následující tabulka uvádí seznam syntaktických klíčových slov jazyka
ActionScript 3.0.
each
get
set
namespace
include
dynamic
final
native
override
static
Existuje také několik identifikátorů, které jsou někdy odkazovány jako budoucí vyhrazená slova. Tyto identifikátory
nejsou jazykem ActionScript 3.0 vyhrazeny, ale některé z nich mohou být použita jako klíčová slova softwarem, který
jazyk ActionScript 3.0 obsahuje. Může být možné mnoho z těchto identifikátorů ve vašem kódu použít, ale společnost
Adobe doporučuje je nepoužívat, protože se mohou jako klíčová slova objevit v následujících verzích jazyka.
abstract
boolean
byte
cast
char
debugger
double
enum
export
float
goto
intrinsic
long
prototype
short
synchronized
throws
to
transient
type
virtual
volatile
63
Konstanty
Jazyk ActionScript 3.0 podporuje příkaz const, který můžete použít k vytváření konstant. Konstanty jsou vlastnosti s
pevnou hodnotu, kterou nelze změnit. Konstantě můžete přiřadit hodnotu pouze jednou a přiřazení musí být
provedeno v blízkosti deklarace konstanty. Pokud je například konstanta deklarována jako člen třídy, můžete přiřadit
hodnotu této konstantě pouze jako součást deklarace nebo uvnitř konstruktoru třídy.
Následující kód deklarujete dvě konstanty. První konstanta MINIMUM, má hodnotu přiřazenou jako součást příkazu
deklarace. Druhá konstanta, MAXIMUM, má hodnotu přiřazenou v konstruktoru. Povšimněte si, že tento příklad se
kompiluje pouze ve standardním režimu, protože v přísném režimu umožňuje přiřazení hodnoty konstanty pouze v
době inicializace.
class A
{
public const MINIMUM:int = 0;
public const MAXIMUM:int;
public function A()
{
MAXIMUM = 10;
}
}
var a:A = new A();
trace(a.MINIMUM); // 0
trace(a.MAXIMUM); // 10
Pokud se pokusíte přiřadit počáteční hodnotu konstantě jiným způsobem, dojde k chybě. Pokud se například pokusíte
nastavit počáteční hodnotu MAXIMUM vně třídy, dojde k chybě v čase zpracování.
class A
{
public const MINIMUM:int = 0;
public const MAXIMUM:int;
}
var a:A = new A();
a["MAXIMUM"] = 10; // run-time error
Jazyk ActionScript 3.0 definuje široké rozpětí konstant, které můžete použít. Na základě konvence konstanty v jazyce
ActionScript používají všechna velká písmena, se slovy oddělenými podtržítkem (_). Například definice třídy
MouseEvent používá tuto konvenci pojmenování pro své konstanty, každá z nich vyjadřuje událost související se
vstupem od myši:
package flash.events
{
public class MouseEvent extends Event
{
public static const CLICK:String = "click";
public static const DOUBLE_CLICK:String = "doubleClick";
public static const MOUSE_DOWN:String = "mouseDown";
public static const MOUSE_MOVE:String = "mouseMove";
...
}
}
64
Operátory
Operátory jsou speciální funkce, které mohou mít jeden nebo více operandů a vrací hodnotu. Operand je hodnota,
obvykle literál, proměnná nebo výraz, kterou operátor používá jako vstup. Například v následujícím kódu doplnění
(+) a násobení (*) operátorů je použito s třemi literálovými operandy (2, 3, a 4) a vrací hodnotu. Hodnota je pak
použita operátorem přiřazení (=) k přiřazení vrácené hodnoty, 14, proměnné sumNumber.
var sumNumber:uint = 2 + 3 * 4; // uint = 14
Operátory mohou být ternární, binární nebo unární. Unární operátor má jediný operand. Například přírůstkový
operátor (++) je unárním operátorem, protože má jenom jeden operand. Binární operátor má dva operandy.
Například operátor dělení (/) má dva operandy. Ternární operátor má tři operandy. Například operátor podmínky
(?:) má tři operandy.
Některé operátory jsou přetížené, což znamená, že se chovají odlišně v závislosti na typu nebo počtu operandu, které
jsou jim předané. Operátor sčítání (+) je příkladem přetíženého operátoru, který se chová odlišně v závislosti na
datovém typu operandu. Pokud jsou oba operandy čísly, operátor sčítání vrací součet hodnot. Pokud jsou oba
operandy řetězce, operátor sčítání vrací zkrácení obou operandů. Následující příklad kódu ukazuje, jak se operátor
chová odlišně v závislosti na operandech:
trace(5 + 5); // 10
trace("5" + "5"); // 55
Operátory se mohou také chovat odlišně na základě počtu operandů jim předaných. Operátor odčítání (-) je unární i
binární operátor. Pokud je předán pouze jediný operand, operátor odčítání neguje operand a vrací výsledek. Po
předání dvou operandů operátor odčítání vrací rozdíl mezi operandy. Následující příklad ukazuje operátor odčítání,
použitý nejprve jako unární, pak jako binární operátor.
trace(-3); // -3
trace(7 - 2); // 5
Přednost a asociativita operátorů
Přednost a asociativita operátorů stanoví pořadí, ve kterém jsou operátory zpracovány. I když může vypadat přirozené
všem, kteří jsou seznámeni s aritmetikou, že kompilátor zpracovává násobení (*) před sčítáním (+), vyžaduje
kompilátor specifické instrukce o tom, které operátory má zpracovat jako první. Takové pokyny jsou souhrnně
popisovány jako přednost operátorů. V jazyce ActionScript definuje výchozí operátor přednost, kterou můžete změnit
pomocí závorek (()). Například následující kód mění výchozí přednost z předchozího příklad tak, aby donutil
kompilátor zpracovat operátor sčítání před operátorem násobení:
var sumNumber:uint = (2 + 3) * 4; // uint == 20
Můžete se setkat se situacemi, ve kterých mají dva nebo více operátorů stejnou přednost a jsou uvedeny ve stejném
výrazu. V těchto případech kompilátor používá pravidlo asociativity ke stanovení, který operátor má být zpracován
jako první. Všechny binární operátor, kromě operátorů přiřazení, jsou asociativní zleva, což znamená, že operátory
vlevo jsou zpracovány před operátory vpravo. Operátory přiřazení a podmínkové operátory (?:) jsou zprava
asociativní, což znamená, že operátory vpravo jsou zpracovány před operátory vlevo.
Například uvažujme operátory menší než (<) a větší než (>), které mají stejnou přednost. Pokud jsou oba operátory
použity ve stejném výrazu, operátor na levé straně je zpracován jako první, protože oba operátory jsou asociativní
zleva. To znamená, že následující dva příkazy poskytnou stejný výsledek:
trace(3 > 2 < 1); // false
trace((3 > 2) < 1); // false
65
Operátor větší než je zpracován jako první, což vede k hodnotě true, protože operand 3 je větší než operand 2.
Hodnota true je pak předána operátoru menší než společně s operandem 1. Následující kód představuje tento
mezistav:
trace((true) < 1);
Operátor menší než převádí hodnotu true na numerickou hodnotu 1 a porovnává tuto numerickou hodnotu s
druhým operandem 1 a vrací hodnotu false (hodnota 1 není menší než 1).
trace(1 < 1); // false
Pomocí operátoru závorka můžete změnit výchozí asociativitu zleva. Kompilátoru můžete vydat pokyn zpracovat
operátor menší než nejprve jeho umístěním do závorek i s jeho operandy. Následující příklad používá operátor
závorka k dosažení jiného výsledku pomocí stejných čísel, jako v předchozím příkladu:
trace(3 > (2 < 1)); // true
Operátor menší než je zpracován jako první, což vede k hodnotě false, protože operand 2 není menší než operand 1.
Hodnota false je pak předána operátoru větší než společně s operandem 3. Následující kód představuje tento
mezistav:
trace(3 > (false));
Operátor větší než převede hodnotu false na numerickou hodnotu 0 a porovná tuto numerickou hodnotu s druhým
operandem 3 a vrátí hodnotu true (hodnota 3 je větší než 0).
trace(3 > 0); // true
Následující tabulka uvádí operátory pro jazyk ActionScript 3.0 v pořadí snižující se přednosti. Každá řádka v tabulce
obsahuje operátory stejné přednosti. Každý řádka operátorů má vyšší přednost, než řádka následující v tabulce za ní.
Skupina
Operátory
Primární operátory
[] {x:y} () f(x) new x.y x[y] <></> @ :: ..
Příponové operátory
x++ x--
Unární operátory
++x --x + - ~ ! delete typeof void
Multiplikativní operátory
* / %
Aditivní
+ -
Bitové operátory posunutí
<< >> >>>
Relační operátory
< > <= >= as in instanceof is
Rovnost
== != === !==
Bitový operátor AND
&
Bitový operátor XOR
^
Bitový operátor OR
|
Logický operátor AND
&&
Logický operátor OR
||
Podmíněný
?:
Přiřazení
= *= /= %= += -= <<= >>= >>>= &= ^= |=
Čárka
,
66
Primární operátory
Primární operátory zahrnují ty, které jsou použity pro vytvoření literálů Array a Object, seskupení výrazů, volání
funkcí, konkretizaci instancí třídy a pro přístup k vlastnostem.
Všechny primární operátory uvedené v následující tabulce mají stejnou přednost. Operátory, které jsou součástí
specifikace E4X, jsou označeny poznámkou (E4X).
Operátor
Provedená operace
[]
Inicializace pole
{x:y}
Inicializace objektu
()
Seskupení výrazů
f(x)
Volání funkce
new
Volání konstruktoru
x.y x[y]
Přístup k vlastnostem
<></>
Inicializace objektu XMLList (E4X)
@
Přístup k atributu (E4X)
::
Kvalifikace názvu (E4X)
..
Přistupuje k dceřinému prvku XML (E4X)
Příponové operátory
Příponové operátory vezmou jeden operand a provedou zvýšení nebo snížení jeho hodnoty. I když tyto operátory jsou
unárními operátory, jsou klasifikovány samostatně od zbytku unárních operátorů, díky jejich vyšší přednosti a
zvláštnímu chování. Když je použít příponový operátor jako součást větší výrazu, hodnota výrazu je vrácena před
zpracováním příponového operátoru. Například následující kód zobrazuje, jak je vracena hodnota xNum++ před svým
zvýšením:
var xNum:Number = 0;
trace(xNum++); // 0
trace(xNum); // 1
Všechny příponové operátory uvedené v následující tabulce mají stejnou přednost.
Operátor
Provedená operace
++
Zvýšení hodnoty (přípona)
--
Snížení hodnoty (přípona)
Unární operátory
Unární operátory pracující s jedním operandem. Operátory zvýšení hodnoty (++) a snížení hodnoty (--) v této
skupině jsou předponovéoperátory, což znamená, že se ve výrazu zobrazují před operandem. Předponové operátory se
liší od svých protějšků, příponových operátorů, a to v tom, že operace zvýšení nebo snížení hodnoty je dokončena
předtím, než je vrácena hodnota celkového výrazu. Například následující kód zobrazuje, jak je vracena hodnota
++xNum po svém zvýšení:
67
var xNum:Number = 0;
trace(++xNum); // 1
trace(xNum); // 1
Všechny unární operátory uvedené v následující tabulce mají stejnou přednost.
Operátor
Provedená operace
++
Zvýšení hodnoty (předpona)
--
Snížení hodnoty (předpona)
+
Unární operátor +
-
Unární operátor - (negace)
!
Logický operátor NOT
~
Bitový operátor NOT
delete
Odstranění vlastnosti
typeof
Vrácení typu informace
void
Vrací nedefinovanou hodnotu
multiplikativní operátory
Multiplikativní operátory vezmou dva operandy a provedou s nimi násobení, dělení nebo výpočty s operandem
modulu.
Všechny multiplikativní operátory uvedené v následující tabulce mají stejnou přednost.
Operátor
Provedená operace
*
Násobení
/
Dělení
%
Modulo
Aditivní operátory
Aditivní operátory vezmou dva operandy a provedou sčítání nebo odčítání. Všechny aditivní operátory uvedené v
následující tabulce mají stejnou přednost.
Operátor
Provedená operace
+
Sčítání
-
Odčítání
Bitové operátory posunutí
Bitové operátory posunutí vezmou dva operandy a provedou s nimi posunutí bitů prvního operandu v rozsahu
specifikovaném druhým operandem. Všechny bitové operátory posunutí uvedené v následující tabulce mají stejnou
přednost.
68
Operátor
Provedená operace
<<
Bitové posunutí vlevo
>>
Bitové posunutí vpravo
>>>
Bitové posunutí vpravo, bez znaménka
Relační operátory
Relační operátory vezmou dva operandy a provedou porovnání jejich hodnot a vrátí booleovskou hodnotu. Všechny
relační operátory uvedené v následující tabulce mají stejnou přednost.
Operátor
Provedená operace
<
Menší než
>
Větší než
<=
Menší než nebo rovno
>=
Větší než nebo rovno
as
Kontrola datového typu
in
Kontrola vlastností objektu
instanceof
Kontrola řetězu prototypu
is
Kontrola datového typu
Operátory rovnosti
Operátory rovnosti vezmou dva operandy a provedou porovnání jejich hodnot a vrátí booleovskou hodnotu. Všechny
relační operátory uvedené v následující tabulce mají stejnou přednost.
Operátor
Provedená operace
==
Rovnost
!=
Nerovnost
===
Přesná rovnost
!==
Přesná nerovnost
Bitové logické operátory
Bitové logické operátory vezmou dva operandy a provedou s nimi logické operace na úrovni bitů. Bitové logické
operátory se odlišují svou předností a jsou uvedeny v následující tabulce v pořadí snižující se přednosti:
Operátor
Provedená operace
&
Bitový operátor AND
^
Bitový operátor XOR
|
Bitový operátor OR
69
Logické operátory
Logické operátory vezmou dva operandy a vrátí booleovskou hodnotu. Logické operátory se odlišují svou předností a
jsou uvedeny v následující tabulce v pořadí snižující se přednosti:
Operátor
Provedená operace
&&
Logický operátor AND
||
Logické OR
Podmínečný operátor
Podmínečný operátor je ternární operátor, což znamená, že pracuje se třemi operandy. Podmínečný operátor je
rychlou metodou aplikace podmíněného příkazu if..else.
Operátor
Provedená operace
?:
Podmínečný
Operátory přiřazení
Operátory přiřazení vezmou dva operandy a přiřadí hodnotu jednomu z nich, na základě hodnoty druhého operandu.
Všechny operátory přiřazení uvedené v následující tabulce mají stejnou přednost.
Operátor
Provedená operace
=
Přiřazení
*=
Přiřazení násobení
/=
Přiřazení dělení
%=
Přiřazení modulo
+=
Přiřazení sčítání
-=
Přiřazení odečítání
<<=
Přiřazení bitového posunutí vlevo
>>=
Přiřazení bitového posunutí vpravo
>>>=
Přiřazení bitového posunutí vpravo, bez znaménka
&=
Přiřazení bitového operátoru AND
^=
Přiřazení bitového operátoru XOR
|=
Přiřazení bitového operátoru OR
Podmíněné příkazy
Jazyk ActionScript 3.0 poskytuje tři základní podmíněné příkazy, které můžete používat pro ovládání chodu
programu.
70
if..else
Podmíněný příkaz if..else umožňuje testovat podmínku a vykonávat blok kódu v případě, že podmínka existuje,
nebo vykonávat alternativní blok kódu, pokud podmínka neexistuje. Například následující kód testuje, zda hodnota x
přesahuje 20, a vygeneruje funkci trace() v případě, že ano, nebo vygeneruje jinou funkci trace(), pokud ne:
if (x > 20)
{
trace("x is > 20");
}
else
{
trace("x is <= 20");
}
Pokud nechcete vykonat alternativní blok kódu, můžete použít příkaz if bez příkazu else.
if..else if
Pomocí podmíněného příkazu if..else if můžete testovat více než jednu podmínku. Například následující kód
testuje nejenom, zda hodnota x přesahuje 20, ale také, zda hodnota x je záporná:
if (x > 20)
{
trace("x is > 20");
}
else if (x < 0)
{
trace("x is negative");
}
Pokud za příkazem if nebo else následuje pouze jeden příkaz, nemusí být tento příkaz vložen ve složených
závorkách. Například následující kód nepoužívá složené závorky:
if (x > 0)
trace("x
else if (x <
trace("x
else
trace("x
is positive");
0)
is negative");
is 0");
Společnost Adobe však doporučuje používat složené závorky vždy, protože pokud budou později příkazy přidány do
podmíněného příkazu bez složených závorek, může dojít k neočekávanému chování. Například v následujícím kódu
se hodnota positiveNums zvyšuje o 1 bez ohledu na to, zda je podmínka vyhodnocena true:
var x:int;
var positiveNums:int = 0;
if (x > 0)
trace("x is positive");
positiveNums++;
trace(positiveNums); // 1
71
switch
Příkaz switch je užitečný v případě, že máte několik cest vykonání kódu, které závisí na stejném podmíněném výrazu.
Poskytuje funkci podobnou dlouhé řadě příkazů if..else if, ale snáze se čte. Namísto testování podmínky s
ohledem na booleovskou hodnotu, příkaz switch vyhodnocuje výraz a používá výsledek ke stanovení, který blok kódu
je nutné vykonat. Bloky kódu začíná příkazem case a končí příkazem break. Například následující příkazy switch
vytisknou den v týdnu na základě čísla dne, vráceného metodou Date.getDay():
var someDate:Date = new Date();
var dayNum:uint = someDate.getDay();
switch(dayNum)
{
case 0:
trace("Sunday");
break;
case 1:
trace("Monday");
break;
case 2:
trace("Tuesday");
break;
case 3:
trace("Wednesday");
break;
case 4:
trace("Thursday");
break;
case 5:
trace("Friday");
break;
case 6:
trace("Saturday");
break;
default:
trace("Out of range");
break;
}
Opakování
Opakování příkazu umožňuje provádět specifické bloky kódu opakovaně pomocí řady hodnot nebo proměnných.
Společnost Adobe doporučuje vždy uzavřít blok kódu do složených závorek ({}). I když lze složené závorky vynechat
v případě, že blok kódu obsahuje pouze jeden příkaz, tento postup se nedoporučuje ze stejného důvodu, jako se
nedoporučuje pro podmíněné příkazy: zvyšuje pravděpodobnost, že posléze přidané příkazy budou z bloku kódu
neúmyslně vyloučeny. Pokud později přidáte příkaz, který chcete zahrnout do bloku kódu, ale zapomenete přidat
potřebné složené závorky, příkaz nebude vykonán jako součást opakování cyklu.
72
for
Opakování (cyklus) for umožňuje iterovat proměnnou ve specifickém rozsahu hodnot. Do příkazu for musíte zadat
tři výrazy: proměnnou, která je nastavena na počáteční hodnotu, podmíněný příkaz, který stanoví, když cyklus končí,
a výraz, který mění hodnotu proměnné po každém cyklu. Například následující příkaz se bude opakovat pětkrát.
Hodnota proměnné i začíná na hodnotě 0 a končí na hodnotě 4 a výstup je tvořen čísly 0 až 4, každým na vlastním
řádku.
var i:int;
for (i = 0; i < 5; i++)
{
trace(i);
}
příkaz for..in
Příkaz for..in iteruje vlastnosti objektu, nebo prvky pole. Například můžete použít cyklus for..in a iterovat
vlastnosti generického objektu (vlastnosti objektu nejsou žádným specifickým způsobem řazeny, takže se mohou
zobrazovat ve zdánlivě náhodném pořadí):
var myObj:Object = {x:20, y:30};
for (var i:String in myObj)
{
trace(i + ": " + myObj[i]);
}
// output:
// x: 20
// y: 30
Iterovat můžete také prvky pole:
var myArray:Array = ["one", "two", "three"];
for (var i:String in myArray)
{
trace(myArray[i]);
}
// output:
// one
// two
// three
Nelze však iterovat přes vlastnosti objektu, pokud se jedná o instanci uzavřené třídy (včetně vestavěných tříd a tříd
definovaných uživatelem). Iterovat lze pouze přes vlastnosti dynamické třídy. Také u instancí dynamických tříd lze
iterovat pouze přes vlastnosti, které jsou přidány dynamicky.
for each..in
Příkaz for each..in iteruje položky sbírky, což mohou být značky v objektu XML nebo XMLList, hodnoty
uchovávané vlastnostmi objektu, nebo prvky pole. Například následující výňatek ukazuje, že můžete použít cyklus for
each..in k iterování vlastností generického objektu, ale na rozdíl od cyklu for..in iterační proměnná v cyklu for
each..in obsahuje hodnotu uchovávanou vlastností namísto názvu vlastnosti:
73
var myObj:Object = {x:20, y:30};
for each (var num in myObj)
{
trace(num);
}
// output:
// 20
// 30
Můžete iterovat objekty XML nebo XMLList, jak ukazuje následující příkaz:
var myXML:XML = <users>
<fname>Jane</fname>
<fname>Susan</fname>
<fname>John</fname>
</users>;
for each (var item in myXML.fname)
{
trace(item);
}
/* output
Jane
Susan
John
*/
Můžete také iterovat prvky pole, jak ukazuje následující příkaz:
var myArray:Array = ["one", "two", "three"];
for each (var item in myArray)
{
trace(item);
}
// output:
// one
// two
// three
Nemůžete iterovat vlastnosti objektu, pokud je objekt instancí zapouzdřené třídy. Ani pro instance dynamických tříd
nemůžete iterovat žádnou pevnou vlastnosti, která je vlastností definovanou jako součást definice třídy.
while
Příkaz cyklu while je podobný příkazu if, který se opakuje, dokud má podmínka hodnotu true. Například
následující kód produkuje stejný výstup, jako příklad cyklu for:
var i:int = 0;
while (i < 5)
{
trace(i);
i++;
}
Jednou z nevýhod používání cyklu while místo cyklu for je to, že nekonečné cykly se zapisují snáze s cykly while.
Příklad kódu cyklu for se nezkompiluje v případě, že vynecháte výraz, který zajistí zvýšení hodnoty proměnné
counter, ale příklad cyklu while se zkompiluje, pokud tento krok vynecháte. Bez výrazu, který zajistí zvýšení hodnoty
i se cyklus stane nekonečným.
74
do..while
Příkaz cyklu do..while je cyklem while, který zaručuje, že blok kódu je vykonán alespoň jednou, protože podmínka
je kontrolována po vykonání bloku kódu. Následující kód zobrazuje jednoduchý příklad cyklu do..while, který
generuje výstup i v případě, že podmínka není splněna:
var i:int = 5;
do
{
trace(i);
i++;
} while (i < 5);
// output: 5
Funkce
Funkce jsou bloky kódu, které provádějí specifické úlohy a mohou být v programu použity opakovaně. V jazyce
ActionScript 3.0 existují dva typy funkcí: metody a uzavřené funkce. To, zda je funkce nazvaná metodou nebo
uzavřenou funkcí, závisí na kontextu, ve kterém je funkce definována. Funkce se nazývá metoda, pokud ji definujete
jako součást definice třídy nebo ji připojíte k instanci objektu. Funkce se nazývá uzavřenou funkcí, pokud je
definována jiným způsobem.
Funkce byly v jazyce ActionScript vždy extrémně důležité. V jazyce ActionScript 1.0 klíčové slovo class neexistovalo,
takže „třídy“ byly definovány funkcemi konstruktoru. I když klíčové slovo class byl od té doby do jazyka přidáno,
dobré porozumění funkcím je i nadále důležité, pokud chcete plně využít to, co jazyk nabízí. To může být výzvou
programátorům, kteří očekávají, že se funkce ActionScript budou chovat podobně, jako funkce v jazycích jako C++
nebo Java. Ačkoliv základní definice funkce a její volání by nemělo pro zkušené programátory představovat žádnou
výzvu, některé pokročilejší vlastnosti funkcí jazyka ActionScript vyžadují podrobnější vysvětlení.
Základní koncepty funkcí
Volání funkcí
Funkci voláte pomocí jejího identifikátoru, následovaného operátorem závorky (()). Operátor závorky použijete k
uzavření parametrů funkce, které chcete funkci odeslat. Například funkce trace() je v jazyce ActionScript 3.0 funkcí
nejvyšší úrovně:
trace("Use trace to help debug your script");
Pokud voláte funkci bez parametrů, musíte použít prázdný pár závorek. Můžete například použít metodu
Math.random(), která nepoužije žádný parametr, a vygenerovat náhodné číslo:
var randomNum:Number = Math.random();
Definování vlastních funkcí
Existují dva způsoby, jak definovat funkci v jazyce ActionScript 3.0: můžete použít příkaz funkce nebo výraz funkce.
Vybraná technika závisí na tom, zda dáváte přednost statickému nebo dynamickému stylu programování. Definujte
funkce s příkazy, pokud preferujete statický, nebo přísný režim programování. Definujte funkce s výrazy, pokud k
tomu máte specifický důvod. Výrazy funkce jsou častěji používaný v dynamickém, nebo standardním režimu
programování.
75
Příkazy funkce
Příkazy funkce jsou upřednostňovanou technikou definování funkcí v přísném režimu. Příkazy funkce začínají
klíčovým slovem function, za kterým následuje:
• Název funkce
• Parametry, ve formě seznamu odděleného čárkami v závorkách
• Tělo funkce, tj. kód v jazyce ActionScript, který má být proveden při volání funkce, uzavřený ve složených
závorkách
Například následující kód vytvoří funkci, která definuje parametr a pak volá funkci pomocí řetězce „hello“ jako
hodnoty parametru:
function traceParameter(aParam:String)
{
trace(aParam);
}
traceParameter("hello"); // hello
Výrazy funkce
Druhým způsobem, jak deklarovat funkci, je použití příkazu přiřazení s výrazem funkce, což se také někdy nazývá
literál funkce nebo anonymní funkce. Existuje kompletnější metoda, která byla široce používána v předchozích verzích
jazyka ActionScript.
Příkaz přiřazení s výrazem funkce začíná klíčovým slovem var, po kterém následuje:
• Název funkce
• Operátor dvojtečka (:)
• Třída function pro definování datového typu
• Operátor přiřazení (=)
• Klíčové slovo function
• Parametry, ve formě seznamu odděleného čárkami v závorkách
• Tělo funkce, tj. kód v jazyce ActionScript, který má být proveden při volání funkce, uzavřený ve složených
závorkách
Například následujíc kód deklaruje funkci traceParameter pomocí výrazu funkce:
var traceParameter:Function = function (aParam:String)
{
trace(aParam);
};
traceParameter("hello"); // hello
Povšimněte si, že nespecifikujete název funkce, jako v příkazu funkce. Dalším důležitým rozdílem mezi výrazy a
příkazy funkce je to, že výraz funkce je spíše výrazem než příkazem. To znamená, že výraz funkce nemůže stát
samostatně, jako může příkaz funkce. Výraz funkce může být použit pouze jako součást příkazu, obvykle jako
příkazu přiřazení. Následující příklad ukazuje výraz funkce, přiřazený prvku pole:
76
var traceArray:Array = new Array();
traceArray[0] = function (aParam:String)
{
trace(aParam);
};
traceArray[0]("hello");
Výběr mezi příkazy a výrazy
Všeobecné pravidlo zní používat příkaz funkce, pokud specifické okolnosti nevyžadují použití výrazu. Příkazy funkce
jsou méně kompletní a poskytují konzistentnější spolupráci mezi přísným a standardním režimem, než výrazy funkce.
Příkazy funkce se snáze čtou, než výrazy funkce, které obsahují výrazy. Příkazy funkce činí kód stručnějším; jsou méně
matoucí, než výrazy funkce, které vyžadují použití klíčových slov var i function.
Příkazy funkce umožňují konzistentnější spolupráci mezi dvěma režimy kompilátoru, neboť v přísném i standardním
režimu lze použít tečkovou syntaxi k volání metody deklarované pomocí příkazu funkce. To není nutné pravdivé pro
metody deklarované výrazem funkce. Například následující kód definuje třídu pojmenovanou Example dvěma
metodami: methodExpression(), která je deklarovaná výrazem funkce, a methodStatement(), která je deklarovaná
příkazem funkce. V přísném režimu nelze tečkovou syntaxi použít k volání metody methodExpression().
class Example
{
var methodExpression = function() {}
function methodStatement() {}
}
var myEx:Example = new Example();
myEx.methodExpression(); // error in strict mode; okay in standard mode
myEx.methodStatement(); // okay in strict and standard modes
Výrazy funkce jsou vhodnější k programování, které se zaměřuje n a chování programu během jeho spuštění
(dynamické). Pokud dáváte přednost použití přísného režimu, ale rovněž potřebujte volat metodu deklarovanou
výrazem funkce, použijte jednu z dvou technik. První, můžete zavolat metodu pomocí hranatých závorek ([]) namísto
tečky (.) operátor. Následující volání metody je úspěšné v přísném i standardním režimu:
myExample["methodLiteral"]();
Druhá, můžete deklarovat celou třídu jako dynamickou třídu. I když toto umožňuje volat metodu pomocí operátoru
tečka, nevýhodou je to, že obětujete část funkčnosti přísného režimu pro všechny instance dané třídy. Například
kompilátor negeneruje chybu při pokusu o přístup k nedefinované vlastnosti instance dynamické třídy.
Existují jisté okolnosti, za kterých jsou výrazy funkce užitečné. Běžné využití výrazu funkce je pro funkce, které jsou
používány pouze jednou a pak jsou vyřazeny. Dalším, méně běžným použitím, je připojení funkce k vlastnosti
prototypu. Více informací naleznete v části Objekt prototypu.
Existují dva drobné rozdíly mezi příkazem a výrazem funkce, které byste měli vzít v úvahu při volbě použité techniky.
První rozdíl spočívá v tom, že výrazy funkce neexistují nezávisle jako objekty, s ohledem na správu paměti a čištění
uvolněné paměti. Jinými slovy, když přiřadíte výraz funkce jinému objektu, například prvku pole nebo vlastnosti
objektu, vytvoříte pouze referenci na tento výraz funkce ve svém kódu. Pokud se pole nebo objekt, k němuž je výraz
funkce připojen, dostane mimo rozsah nebo je jinak nedostupný, nebudete již mít přístup k výrazu funkce. Dojde-li
k odstranění pole nebo objektu, paměť použitá výrazem funkce bude připravena k čištění uvolněné paměti, což
znamená, že paměť bude možné použít pro jiné účely.
77
Následující příklad ukazuje, že pro výraz funkce nebude tato funkce již dále dostupná, jakmile je odstraněna vlastnost,
ke které je výraz přiřazen. Třída Test je dynamická, což znamená, že můžete přidat vlastnosti pojmenovanou
functionExp, která uchovává výraz funkce. Funkce functionExp() může být volána operátorem tečka, ale jakmile
je vlastnost functionExp odstraněna, funkce již není přístupná.
dynamic class Test {}
var myTest:Test = new Test();
// function expression
myTest.functionExp = function () { trace("Function expression") };
myTest.functionExp(); // Function expression
delete myTest.functionExp;
myTest.functionExp(); // error
Pokud na druhou stranu bude funkce nejprve definována příkazem funkce, existuje jako vlastní objekt a existuje i poté,
co odstraníte vlastnost, ke které byla funkce připojena. Operátor delete je funkční pouze pro vlastnosti objektů, takže
i volání pro odstranění funkce stateFunc() samotné nepracuje.
dynamic class Test {}
var myTest:Test = new Test();
// function statement
function stateFunc() { trace("Function statement") }
myTest.statement = stateFunc;
myTest.statement(); // Function statement
delete myTest.statement;
delete stateFunc; // no effect
stateFunc();// Function statement
myTest.statement(); // error
Druhým rozdílem mezi výrazem a příkazem funkce je to, že výraz funkce existuje v rámci rozsahu, ve kterém je
definován, včetně příkazů in, které se objevují před příkazem funkce. Výrazy funkce jsou oproti tomu definovány
pouze pro následující příkazy. Například následující kód úspěšně volá funkci scopeTest() před jejím definováním:
statementTest(); // statementTest
function statementTest():void
{
trace("statementTest");
}
Výrazy funkce nejsou dostupné před definováním, takže následující kód vede k chybě při spuštění kódu:
expressionTest(); // run-time error
var expressionTest:Function = function ()
{
trace("expressionTest");
}
Vracení hodnot z funkcí
Chcete-li, aby funkce vrátila hodnotu, použijte příkaz return následovaný výrazem nebo literálovou hodnotou,
kterou chcete vrátit. Například následující kód vrací výraz, představující parametr:
function doubleNum(baseNum:int):int
{
return (baseNum * 2);
}
78
Všimněte si, že příkaz return funkci ukončí, takže jakékoliv příkazy pod příkazem return nebudou vykonány:
function doubleNum(baseNum:int):int {
return (baseNum * 2);
trace("after return"); // This trace statement will not be executed.
}
V přísném režimu musíte vrátit hodnotu vhodného typu, protože nevrací platnou hodnotu: Například následující kód
generuje v přísném režimu chybu, protože nevrací platnou hodnotu:
function doubleNum(baseNum:int):int
{
trace("after return");
}
Vnořené funkce
Funkce můžete vnořovat, což znamená, že funkce mohou být deklarovány uvnitř jiných funkcí. Vnořená funkce je
dostupná pouze ve své nadřazené funkci, pokud není odkaz na tuto funkci předán externímu kódu. Například
následující kód deklaruje dvě vnořené funkce uvnitř funkce getNameAndVersion():
function getNameAndVersion():String
{
function getVersion():String
{
return "10";
}
function getProductName():String
{
return "Flash Player";
}
return (getProductName() + " " + getVersion());
}
trace(getNameAndVersion()); // Flash Player 10
Když jsou vnořené funkce předány externímu kódu, jsou předány jako uzavřené funkce, což znamená, že funkce si
uchovává všechny definice, které jsou v rozsahu při definování funkce. Další informace, viz Rozsah funkce.
Parametry funkce
Jazyk ActionScript 3.0 poskytuje některé funkčnosti pro parametry funkcí, které mohou novým programátorům
tohoto jazyka připadat jako neobvyklé. I když princip předávání parametrů hodnotou nebo odkazem by měl být
většině programátorů znám, objekt arguments a parametr ... (rest) mohou být pro mnoho z nich nové.
Předávání argumentů hodnotou nebo odkazem
V mnoha programovacích jazycích je důležité porozumět odlišnosti mezi předáváním argumentů hodnotou nebo
odkazem; rozdíl může ovlivňovat způsob tvorby kódu.
Předání hodnotou znamená, že hodnota argumentu je kopírována do místní proměnné pro použití v rámci funkce.
Předání odkazem znamená, že je předán pouze odkaz na argument, místo skutečné hodnoty. Není zhotovena žádná
kopie stávajícího argumentu. Místo toho se vytvoří odkaz na proměnnou předaný jako argument a je přiřazen místní
proměnné pro použití v rámci funkce. Jako odkaz na proměnnou vně funkce umožňuje místní proměnné změnit
hodnotu původní proměnné.
79
V jazyce ActionScript 3.0 jsou všechny argumenty předávány formou odkazu, protože všechny hodnoty jsou uloženy
jako objekty. Nicméně objekty, které náleží primitivním datovým typům, což zahrnuje Boolean, Number, int, uint a
String, mají speciální operátory, které jim umožňují chovat se, jako by byly předány hodnotou. Například následující
kód vytvoří funkci pojmenovanou passPrimitives(), která definuje dva parametry pojmenované xParam a yParam,
obojí typu int. Tyto parametry jsou podobné místním proměnným, deklarovaným uvnitř těla funkce
passPrimitives(). Když je zavolána funkce s argumenty xValue a yValue, parametry xParam a yParam jsou
inicializovány s odkazy na objekty int zastoupené xValue a yValue. Protože argumenty jsou primitivní, chovají se jako
by předaly hodnotu. I když xParam a yParam v počátku obsahují pouze odkazy na hodnotu objektů xValue a yValue,
všechny změny proměnných v těle funkce generují nové kopie hodnoty v paměti.
function passPrimitives(xParam:int, yParam:int):void
{
xParam++;
yParam++;
trace(xParam, yParam);
}
var xValue:int = 10;
var yValue:int = 15;
trace(xValue, yValue);// 10 15
passPrimitives(xValue, yValue); // 11 16
trace(xValue, yValue);// 10 15
Ve funkci passPrimitives() jsou hodnoty xParam a yParam zvýšeny, to však neovlivňuje hodnoty xValue a yValue,
jak je znázorněno v posledním výrazu trace . To by bylo pravdivé v případě, že parametry byly pojmenovány shodně
s proměnnými, xValue a yValue, protože xValue a yValue uvnitř funkce by ukazovaly do nového umístění v paměti,
které existuje odděleně od proměnných stejného názvu vně funkce.
Všechny ostatní objekty, tj. objekty nenáležící primitivním datovým typům, jsou vždy předány odkazem, což
umožňuje změnit hodnotu původní proměnné. Například následující kód vytváří objekt pojmenovaný objVar se
dvěma vlastnostmi, x a y. Objekt je předán jako argument funkci passByRef(). Protože objekt není primitivním
typem, nejenom, že je předán jako odkaz, ale také tímto odkazem zůstane. To znamená, že změny provedené
v parametrech uvnitř funkce ovlivní vlastnosti objektu vně funkce.
function passByRef(objParam:Object):void
{
objParam.x++;
objParam.y++;
trace(objParam.x, objParam.y);
}
var objVar:Object = {x:10, y:15};
trace(objVar.x, objVar.y); // 10 15
passByRef(objVar); // 11 16
trace(objVar.x, objVar.y); // 11 16
Parametr objParam odkazuje na stejný objekt, jako globální proměnná objVar. Jak je možné vidět na příkazech trace
v příkladu, změny vlastností x a y objektu objParam se odrazí v objektu objVar.
Výchozí hodnoty parametru
V jazyce ActionScript 3.0 lze pro funkci deklarovat výchozí hodnoty parametru. Pokud volání funkce s výchozími
hodnotami parametrů vynechá parametr s výchozími hodnotami, použije se hodnota uvedená v definice funkce pro
daný parametr. Všechny parametry s výchozími hodnotami musí být umístěny na konci seznamu parametrů. Hodnoty
přiřazené jako výchozí hodnoty musí být konstanty z času kompilace. Existence výchozí hodnoty pro parametr
efektivně činí tento parametr volitelným parametrem. Parametr bez výchozí hodnoty je považován za vyžadovaný
parametr.
80
Například následující kód vytváří funkci se třemi parametry, dva z nich mají výchozí hodnoty. Když je funkce volaná
pouze jedním parametrem, použijí se pro parametry výchozí hodnoty.
function defaultValues(x:int, y:int = 3, z:int = 5):void
{
trace(x, y, z);
}
defaultValues(1); // 1 3 5
Objekt arguments
Když jsou funkci předány parametry, můžete použít objekt arguments pro přístup k informacím o parametrech
předaných vaší funkci. Některé důležité aspekty objektu arguments zahrnují následující:
• Objekt arguments je polem, které zahrnuje všechny parametry předané funkci.
• Vlastnost arguments.length hlásí počet parametrů předaných funkci.
• Vlastnost arguments.callee poskytuje odkaz na samotnou funkci, což je užitečné pro rekurzivní volání výrazů
funkce.
Poznámka: Objekt arguments není dostupný v případě, že některý parametr je pojmenován arguments, nebo pokud
použijete parametr ... (zbytek).
Jestliže je objekt arguments odkazován v těle funkce, jazyk ActionScript 3.0 umožňuje, aby volání funkce
zahrnovala více parametrů, než je definováno v definici funkce, ale v přísném režimu vygeneruje chybu
kompilátoru, pokud počet parametrů neodpovídá počtu vyžadovaných parametrů (a volitelně i libovolných
volitelných parametrů). Můžete použít aspekt pole objektu arguments a přistupovat k libovolnému parametru
předanému funkci, bez ohledu na to, zda je funkce definovaná v definici funkce, nebo nikoliv. Následující příklad,
který se kompiluje pouze ve standardním režimu, používá pole arguments společně s vlastností
arguments.length ke sledování všech parametrů předaných funkci traceArgArray():
function traceArgArray(x:int):void
{
for (var i:uint = 0; i < arguments.length; i++)
{
trace(arguments[i]);
}
}
traceArgArray(1, 2, 3);
//
//
//
//
output:
1
2
3
Vlastnost arguments.callee je často používána v anonymních funkcí pro vytvoření rekurze. Můžete ji používat
ke zvýšení flexibility svého kódu. Pokud se název rekurzivní funkce změní v průběhu cyklu vývoje, nemusíte se
starat o změnu rekurzivního volání ve své funkci, pokud použijete arguments.callee místo názvu funkce.
Vlastnost arguments.callee se používá v následujícím výrazu funkce pro umožnění rekurze:
81
var factorial:Function = function (x:uint)
{
if(x == 0)
{
return 1;
}
else
{
return (x * arguments.callee(x - 1));
}
}
trace(factorial(5)); // 120
Pokud ve své deklaraci funkce použijete parametr ... (zbytek), objekt arguments vám nebude dostupný. Místo toho
je nutné přistupovat k parametrům pomocí názvů, které pro ně deklarujete.
Rovněž je třeba dbát na to, aby se řetězec „arguments“ nepoužíval jako název parametru, protože stínuje objekt
arguments. Pokud je například funkce traceArgArray()přepsána tak, aby byl přidán parametr arguments,
odkazy na arguments v těle funkce odkazují na parametr, spíše než na objekt arguments. Následující kód nevytváří
žádný vstup:
function traceArgArray(x:int, arguments:int):void
{
for (var i:uint = 0; i < arguments.length; i++)
{
trace(arguments[i]);
}
}
// no output
Objekt arguments v předchozí verzi jazyka ActionScript také obsahoval vlastnost pojmenovanou caller, která je
odkazem na funkci volanou stávající funkcí. Vlastnost caller není v jazyce ActionScript 3.0 zastoupena, ale pokud
potřebujete odkaz na volající funkci, můžete ji změnit tak, aby předala dodatečný parametr, který je odkazem na
sebe samotný.
Parametr ... (zbytek)
Jazyk ActionScript 3.0 zavádí novou deklaraci parametru nazvanou parametr ... (zbytek). Tento parametr umožňuje
specifikovat parametr pole, který přijímá jakýkoliv počet argumentů oddělených čárkou. Parametr může mít libovolný
název, pokud se nejedná o vyhrazené slovo. Tato deklarace parametru musí být posledním specifikovaným
parametrem. Při použití tohoto parametru není k dispozici objekt arguments. I když parametr ... (zbytek) poskytuje
stejnou funkčnost, jako pole arguments a vlastnost arguments.length, neposkytuje funkčnost podobnou té, kterou
nabízí arguments.callee. Měli byste zajistit, že nebudete muset použít arguments.callee před použitím
parametru ... (zbytek).
Následující příklad přepisuje funkci traceArgArray() pomocí parametru ... (zbytek) namísto objektu arguments:
82
function traceArgArray(... args):void
{
for (var i:uint = 0; i < args.length; i++)
{
trace(args[i]);
}
}
//
//
//
//
output:
1
2
3
Parametr ... (zbytek) může být také použit s ostatními parametry, pokud se jedná o poslední parametr v seznamu.
Následující příklad modifikuje funkci traceArgArray() tak, aby její první parametr x byl typu int a druhý parametr
používal parametr ... (zbytek). Výstup vynechává první hodnotu, protože první parametr již není součástí pole
vytvořeného parametrem ... (zbytek).
function traceArgArray(x: int, ... args)
{
for (var i:uint = 0; i < args.length; i++)
{
trace(args[i]);
}
}
// output:
// 2
// 3
Funkce jako objekty
Funkce v jazyce ActionScript 3.0 jsou objekty. Když vytvoříte funkci, vytváříte objekt, který nejen že může být předán
jako parametr do jiné funkce, ale také k sobě může mít připojeny vlastnosti a metody.
Funkce předané jako argumenty jiné funkci jsou předány formou odkazu a nikoliv hodnotou. Když předáte funkci
jako argument, použijete pouze identifikátor a nikoliv operátor závorky, který používáte k zavolání metody. Například
následující kód předává funkci pojmenovanou clickListener() jako argument metody addEventListener():
addEventListener(MouseEvent.CLICK, clickListener);
I když se to může zdát novým programátorům jazyka ActionScript podivné, funkce mohou mít vlastnosti a metody,
stejně jako kterékoliv ostatní objekty. Ve skutečnosti každá funkce má vlastnost pouze ke čtení, pojmenovanou
length, která ukládá několik parametrů definovaných pro funkci. To je odlišné od vlastnosti arguments.length,
která hlásí počet argumentů odeslaných funkci. Vzpomeňte si, že v jazyce ActionScript počet argumentů odeslaných
funkci může překročit počet parametrů definovaných pro tuto funkci. Následující příklad, který se kompiluje pouze
ve standardním režimu, protože přísný režim vyžaduje přesnou shodu mezi počtem předaných argumentů a počtem
argumentů definovaných, zobrazuje rozdíl mezi dvěma vlastnostmi:
83
// Compiles only in standard mode
function traceLength(x:uint, y:uint):void
{
trace("arguments received: " + arguments.length);
trace("arguments expected: " + traceLength.length);
}
traceLength(3, 5, 7, 11);
/* output:
arguments received: 4
arguments expected: 2 */
Ve standardním režimu lze definovat vlastní vlastnosti funkce jejich nadefinováním vně těla funkce. Vlastnosti funkce
mohou sloužit jako kvazi-statické vlastnosti, umožňující uložit stav proměnné, související s funkcí. Například můžete
chtít sledovat počet volání specifické funkce. Taková funkce může být užitečná v případě, že píšete hru a chcete
sledovat počet použití specifického příkazu uživatelem, i když proto můžete také použít vlastnost třídy static.
Následující příklad, který se kompiluje pouze ve standardním režimu, protože přísný režim neumožňuje přidávat k
funkci dynamické vlastnosti, vytváří vlastnost funkce mimo deklarování funkce a zajišťuje zvýšení hodnoty vlastnosti
při každém zavolání funkce:
// Compiles only in standard mode
var someFunction:Function = function ():void
{
someFunction.counter++;
}
someFunction.counter = 0;
someFunction();
someFunction();
trace(someFunction.counter); // 2
Rozsah funkce
Rozsah funkce stanoví nejenom to, kde může být program zavolán, ale také k jakým definicím může funkce
přistupovat. Stejný rozsah pravidel, který platí pro identifikátory proměnné, platí také pro identifikátory funkce.
Funkce deklarované v globálním rozsahu je přístupná prostřednictvím vašeho kódu. Například jazyk ActionScript 3.0
obsahuje globální funkce, například isNaN() a parseInt(), které jsou dostupné kdekoliv ve vašem kódu. Vnořená
funkce - funkce deklarovaná v jiné funkci - může být použita kdekoliv ve funkci, ve které byla deklarovaná.
Řetěz rozsahu
Při každém spuštění vykonávání funkce je vytvořeno několik objektů a vlastností. Za prvé je vytvořen speciální objekt
nazvaný aktivační objekt, který uloží parametr a všechny místní proměnné nebo funkce deklarované v těle funkce.
Nemůžete přistupovat k objektu aktivace přímo, protože se jedná i interní mechanismu. Za druhé je vytvořen řetězec
rozsahu, který obsahuje uspořádaný seznam objektů, u nichž běhový modul kontroluje, zda obsahují deklarace
identifikátoru. Každá funkce, která je spouštěna, má řetěz rozsahu, který je uložen ve vnitřní vlastnosti. Pro vnořené
funkce řetěz rozsahu začíná vlastní aktivací objektu, následovanou aktivačním objektem nadřazené funkce. Řetěz
pokračuje tímto způsobem, dokud nedosáhne globálního objektu. Spustí se globální objekt, který je vytvořen v
programu v jazyce ActionScript, a obsahuje všechny globální proměnné a funkce.
84
Uzavřené funkce
Uzavřená funkce je objektem, který obsahuje snímek funkce a jeho lexikální prostředí. Lexikální prostředí funkce
zahrnuje všechny proměnné, vlastnosti, metody a objekty v řetězu rozsahu funkce, společně s jejich hodnotami.
Uzavřené funkce jsou vytvořeny vždy při vykonání funkce, odloučeně od objektu nebo třídy. Skutečnost, že uzavřené
funkce si uchovávají rozsah, ve kterém byly definovány, vytváří zajímavé výsledky, když je funkce předána jako
argument nebo vrací hodnotu jinému rozsahu.
Například následující kód vytváří dvě funkce: foo(), která vrací vnořenou funkci pojmenovanou rectArea(), která
vypočítává plochu trojúhelníku a funkci bar(), která volá foo() a ukládá vrácenou uzavřenou funkci do proměnné
nazvané myProduct. I když funkce bar() definuje vlastní místní proměnnou x (s hodnotou 2), když je zavolána
uzavřená funkce myProduct(), uchovává proměnnou x (s hodnotou 40) definovanou ve funkci foo(). Funkce
bar() proto vrací hodnotu 160 místo 8.
function foo():Function
{
var x:int = 40;
function rectArea(y:int):int // function closure defined
{
return x * y
}
return rectArea;
}
function bar():void
{
var x:int = 2;
var y:int = 4;
var myProduct:Function = foo();
trace(myProduct(4)); // function closure called
}
bar(); // 160
Metody se chovají podobně v tom, že si uchovávají informace o lexikálním prostředí, ve kterém byly vytvořeny. Tato
charakteristika je nejznatelnější v případě, že metoda je extrahována ze své instance, což vytvoří vázanou metodu.
Hlavní rozdíl mezi uzavřenou funkcí a vázanou metodou je v tom, že hodnota klíčového slova this ve vázané metodě
vždy odkazuje na instanci, ke které byla původně připojena, zatímco v uzavřené funkci se hodnota klíčového slova
this může měnit.
85
Kapitola 4: Objektově orientované
programování v jazyce ActionScript
Úvod k objektově orientovanému programování
Objektově orientované programování je způsob organizování kódu v programu jeho seskupením do objektů. Výraz
objekt v tomto významu znamená samostatný element, který zahrnuje informace (datové hodnoty) a funkce. Při
objektově orientovaném přístupu k organizování programu se seskupují určité kusy informací spolu s běžnými
funkcemi nebo akcemi spojenými s danou informací. Lze například seskupit informace o hudbě, např. název alba,
název skladby či jméno interpreta, s funkcí jako „přidat skladbu do seznamu skladeb“ nebo „přehrát všechny skladby
tohoto interpreta“. Tyto kusy informací se zkombinují do jediné položky, a to do objektu (například „Album” nebo
„MusicTrack”). Sbalení hodnot a funkcí dohromady poskytuje celou řadu výhod. K hlavním výhodám patří především
to, že místo několika proměnných stačí použít jen jednu. Kromě toho tento systém uchovává příbuzné funkce
pohromadě. A konečně díky kombinování informací a funkcí lze strukturovat programy způsobem, který lépe
odpovídá skutečnosti.
Třídy
Třída je abstraktní reprezentací objektu. Třída uchovává informace o typech dat, které objekt může mít a o chování,
které může objekt vykazovat. Užitečnost této abstrakce nemusí být zřejmá při psaní malých skriptů, jež obsahují pouze
několik navzájem reagujících objektů. Nicméně s rostoucím rozsahem programu vzrůstá i počet objektů, které je třeba
spravovat. V takovém případě lze pomocí tříd lépe řídit, jakým způsobem se budou objekty vytvářet a jak budou
navzájem reagovat.
Již od jazyka ActionScript 1.0 mohli programátoři využívající jazyk ActionScript použít objekty funkce pro vytvoření
konstruktů, které se podobaly třídám. Jazyk ActionScript 2.0 přidal formální podporu tříd pomocí klíčových slov,
například class a extends. Verze jazyka ActionScript 3.0 nejen že nadále podporuje klíčová slova zavedená ve verzi
ActionScript 2.0, ale také přidává nové schopnosti. Jazyk ActionScript 3.0 například zahrnuje lepší řízení přístupu
s atributy protected a internal. Také poskytuje lepší kontrolu nad přebíráním vlastností pomocí klíčových slov
final a override.
Vývojářům, kteří již vytvářeli třídy například v programovacích jazycích Java, C++ nebo C#, poskytuje jazyk
ActionScript podobné prostředí. Jazyk ActionScript používá řadu stejných klíčových slov a názvů atributů, např.
class, extends a public.
Poznámka: V dokumentaci jazyka Adobe ActionScript označuje pojem vlastnost jakýkoliv člen objektu nebo třídy,
včetně proměnných, konstant a metod. Dále ačkoliv jsou pojmy třída a statický často navzájem zaměňovány, zde se liší.
Například fráze „vlastnosti třídy“ se vztahuje na všechny členy třídy, nikoliv pouze na statické členy.
Definice třídy
Definice třídy jazyka ActionScript 3.0 používají syntaxi, která je podobná syntaxi používané v definici tříd jazyka
ActionScript 2.0. Správná syntaxe pro definici třídy vyvolá klíčové slovo class následované názvem třídy. Za názvem
třídy následuje tělo třídy, které je obklopeno složenými závorkami ({}). Například následující kód vytvoří třídu
pojmenovanou Shape, která obsahuje jednu proměnnou pojmenovanou visible:
86
Objektově orientované programování v jazyce ActionScript
public class Shape
{
var visible:Boolean = true;
}
Jedna důležitá změna syntaxe zahrnuje definice třídy, které jsou uvnitř balíku. Jestliže je v jazyce ActionScript 2.0 třída
uvnitř balíku, musí být název balíku obsažen v deklaraci třídy. V jazyce ActionScript 3.0, který zahrnuje příkaz
package, musí být název balíku zahrnut do deklarace balíku namísto zahrnutí v deklaraci třídy. Například následující
deklarace třídy ukazuje, jak je třída BitmapData, která je součástí balíku flash.display, definována v jazycích
ActionScript 2.0 a ActionScript 3.0:
// ActionScript 2.0
class flash.display.BitmapData {}
// ActionScript 3.0
package flash.display
{
public class BitmapData {}
}
Atributy třídy
Jazyk ActionScript 3.0 vám umožňuje úpravu definicí třídy pomocí jednoho z následujících čtyř atributů:
Atribut
Definice
dynamic
Umožňuje přidávání vlastností k instancím v čase zpracování.
final
Nesmí být rozšířeno jinou třídou.
internal (výchozí)
Viditelné pro reference uvnitř aktuálního balíku.
public
Viditelné pro odkazy kdekoliv.
Každý z těchto atributů, s výjimkou atributu internal, je nutné pro získání přiřazeného chování výslovně zahrnout.
Pokud například při definování třídy nezahrnete atribut dynamic, nebude možné do instance třídy přidávat za běhu
vlastnosti. Atribut výslovně přiřadíte jeho umístěním na začátek definice třídy, dle příkladu v následujícím kódu:
dynamic class Shape {}
Všimněte si, že seznam nezahrnuje atribut nazvaný abstract. Abstraktní třídy nejsou v jazyce ActionScript 3.0
podporovány. Všimněte si také, že seznam nezahrnuje atributy pojmenované private a protected. Tyto atributy
mají význam pouze uvnitř definice třídy a nelze je použít na samotné třídy. Jestliže nechcete, aby byla třída mimo balík
veřejně viditelná, umístěte jí dovnitř balíku a označte třídu atributem internal. Případně můžete vypustit atribut
internal i public a kompilátor přidá atribut internal automaticky. Rovněž lze definovat třídu tak, aby byla
viditelná pouze ve zdrojovém souboru, ve kterém je definována. Umístěte třídu na konec zdrojového souboru pod
koncovou složenou závorku definice balíku.
Tělo třídy
Tělo třídy je obklopeno složenými závorkami. Definuje proměnné, konstanty a metody dané třídy. Následující příklad
znázorňuje deklaraci pro třídu Usnadnění přístupu v jazyce ActionScript 3.0:
public final class Accessibility
{
public static function get active():Boolean;
public static function updateProperties():void;
}
87
Jmenný prostor můžete definovat také uvnitř těla třídy. Následující příklad ukazuje, jak lze definovat jmenný prostor
v těle třídy, a jak je použít jako atribut metody v dané třídě:
public class SampleClass
{
public namespace sampleNamespace;
sampleNamespace function doSomething():void;
}
Jazyk ActionScript 3.0 vám umožňuje do těla třídy zahrnout nejen definice, ale také příkazy. Příkazy, které jsou
umístěny uvnitř těla třídy, ale vně definice metody, budou provedeny přesně jednou. K jejich provedení dojde při
prvním nalezení definice třídy a vytvoření přidruženého objektu třídy. Následující příklad zahrnuje volání externí
funkce hello()a příkaz trace, který vytvoří hlášení o potvrzení při definování třídy:
function hello():String
{
trace("hola");
}
class SampleClass
{
hello();
trace("class created");
}
// output when class is created
hola
class created
V jazyce ActionScript 3.0 je povoleno definovat statickou vlastnost a vlastnost instance se stejným názvem v těle stejné
třídy. Například následující kód deklaruje statickou proměnnou nazvanou message a proměnnou instance stejného
názvu:
class StaticTest
{
static var message:String = "static variable";
var message:String = "instance variable";
}
// In your script
var myST:StaticTest = new StaticTest();
trace(StaticTest.message); // output: static variable
trace(myST.message); // output: instance variable
Atributy vlastnosti třídy
Mluvíme-li o modelu objektu jazyka ActionScript, pojem vlastnost znamená cokoliv, co může být členem třídy, včetně
proměnných, konstant a metod. Nicméně v Referenční příručce jazyka Adobe ActionScript 3.0 pro řešení Adobe Flash
Platform se tento pojem používá v užším významu. V tomto kontextu se pojem vlastnost vztahuje pouze k členům
třídy, jež jsou proměnnou, nebo jsou definovány metodou pro získání nebo pro nastavení. V jazyce ActionScript 3.0
existuje množina atributů, které lze použít s jakoukoliv vlastností třídy. Následující tabulka uvádí tuto množinu
atributů.
Atribut
Definice
internal (výchozí)
Viditelné pro odkazy uvnitř stejného balíku.
private
Viditelné pro odkazy ve stejné třídě.
protected
Viditelné pro odkazy ve stejné a v odvozených třídách.
88
Atribut
Definice
public
Viditelné pro odkazy kdekoliv.
static
Narozdíl od instancí třídy určuje, že vlastnost patří do příslušné třídy.
UserDefinedNamespace
Název vlastního jmenného prostoru definovaného uživatelem.
Atributy jmenného prostoru pro ovládání přístupu
Jazyk ActionScript 3.0 nabízí čtyři speciální atributy, které ovládají přístup k vlastnostem definovaných uvnitř třídy:
public, private, protected a internal.
Atribut public zviditelní vlastnost kdekoliv ve vašem skriptu. Například pro to, aby byla metoda dostupná pro kód
mimo svůj balík, musíte deklarovat metodu s atributem public. To platí pro jakoukoliv vlastnost, ať už je deklarována
pomocí klíčových slov var, const nebo function.
Atribut private zviditelní vlastnost pouze pro volání v rámci třídy definující danou vlastnost. Toto chování se
odlišuje od chování atributu private v jazyce ActionScript 2.0, který umožňoval přístup podtřídy k soukromé
vlastnosti v nadřazené třídě. Další důležitá změna v chování se týká přístupu v čase zpracování. V jazyce ActionScript
2.0 klíčové slovo private zakazovalo přístup pouze v čase sestavování a v čase zpracování jej šlo snadno obejít. V
jazyce ActionScript 3.0 toto již neplatí. Vlastnosti označené jako private jsou nedostupné v čase kompilace i v čase
zpracování.
Například následující kód vytvoří jednoduchou třídu pojmenovanou PrivateExample s jednou soukromou
proměnnou a poté se pokusí o přístup k soukromé proměnné z vnějšku třídy.
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.
V jazyce ActionScript 3.0 má pokus o přístup k soukromé vlastnosti pomocí operátoru tečky (myExample.privVar)
v případě použití přísného režimu za následek chybu v čase kompilace. V jiném případě je chyba nahlášena v čase
zpracování, stejně jako při použití operátoru pro přístup k vlastnosti (myExample["privVar"]).
Následující tabulka uvádí přehled výsledku přístupu k soukromé vlastnosti, která náleží k uzavřené (nikoliv dynamické
) třídě:
Přísný režim
Standardní režim
operátor tečky (.)
chyba v čase kompilace
chyba v čase zpracování
operátor závorky ([])
Ve třídách deklarovaných s atributem dynamic nebudou mít pokusy o přístup k soukromé proměnné za následek
chybu v době běhu. Místo toho nebude proměnná viditelná, takže bude vrácena hodnota nedefinováno. K chybě v
čase kompilace nicméně dojde, pokud používáte operátor tečky v přísném režimu. Následující příklad je stejný jako
předcházející příklad, pouze s výjimkou, že třída PrivateExample je deklarována jako dynamická:
89
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
Dynamické třídy obecně vrací hodnotu undefined namísto vygenerování chyby v případě, kdy se kód externí ke třídě
pokouší o přístup k soukromé vlastnosti. Následující tabulka ukazuje, že chyba je vygenerována pouze tehdy, je-li
operátor tečky používán pro přístup k soukromé vlastnosti v přísném režimu.
Přísný režim
Standardní režim
operátor tečky (.)
chyba v čase kompilace
undefined
operátor závorky ([])
undefined
undefined
Atribut protected, který je v jazyce ActionScript 3.0 nový, zviditelní vlastnost pro volající v rámci vlastní třídy nebo
podtřídy. Jinými slovy, chráněná vlastnost je dostupná v rámci vlastní třídy nebo pro třídy, které leží kdekoliv pod ní
v hierarchii dědičnosti. To je pravdivé pro podtřídu ve stejném i v odlišném balíku.
Pro ty, kdo jsou obeznámeni s jazykem ActionScript 2.0, je tato funkce podobná jako atribut private v jazyce
ActionScript 2.0. Atribut protected jazyka ActionScript 3.0 se rovně podobá atributu protected v jazyce Java. Liší
se v tom, že verze v jazyce Java rovněž povoluje přístup k volajícím v rámci stejného balíku. Atribut protected je
užitečný, jestliže máte proměnnou nebo metodu, kterou vaše podtřídy potřebují skrýt z kódu mimo řetězec dědičnosti.
Atribut internal, který je v jazyce ActionScript 3.0 nový, zviditelní vlastnost pro volající v rámci svého vlastního
balíku. Jedná se o výchozí atribut pro kód uvnitř balíku a použije se na jakoukoliv vlastnost, která nemá žádný z
následujících atributů:
•
public
•
private
•
protected
• uživatelem definovaný jmenný prostor
Atribut internal je podobný výchozímu ovládání přístupu v aplikaci Java, ačkoliv v Javě není pro tuto úroveň
přístupu žádný explicitní název a lze jej dosáhnou pouze prostřednictvím vynechání žádného jiného modifikátoru
přístupu. Atribut internal je dostupný v jazyce ActionScript 3.0 a umožňuje vám výslovně zvýraznit váš záměr
zviditelnění vlastnosti pouze pro volající v rámci vlastního balíku.
Atribut static
Atribut static, který lze použít s vlastnostmi deklarovanými pomocí klíčových slov var, const nebo function, vám
umožňuje přiřadit vlastnost ke třídě, spíše než k instancím dané třídy. Kód mimo danou třídu musí vyvolat statické
vlastnosti pomocí názvu třídy namísto názvu instance.
Statické vlastnosti nejsou zděděny podtřídami, ale dané vlastnosti jsou součástí řetězce rozsahu podtřídy. To znamená,
že v rámci těla podtřídy lze statickou proměnnou nebo metodu použít bez odkazu na třídu, ve které byla definována.
Atributy jmenného prostoru definované uživatelem
Jako alternativu k předdefinovaným atributům ovládání přístupu můžete vytvořit vlastní jmenný prostor, který bude
použit jako atribut. Na každou definici může být použit pouze jeden atribut oboru názvů a takový atribut nemůže být
použit v kombinaci s jakýmikoliv atributy ovládání přístupu (public, private, protected, internal).
90
Proměnné
Proměnné mohou být deklarovány buď pomocí klíčového slova var nebo const. U proměnných deklarovaných
pomocí klíčového slova var lze jejich hodnoty několikrát změnit, a to kdykoliv při provádění skriptu. Proměnné
deklarované pomocí klíčového slova const jsou vyvolané konstanty a hodnoty k nim můžete přiřadit pouze jednou.
Pokus o přiřazení nové hodnoty ke konkretizované konstantě vyvolá chybu.
Statické proměnné
Statické proměnné jsou deklarovány pomocí kombinace klíčového slova static a buďto příkazem var nebo const.
Statické proměnné, které jsou připojeny ke třídě spíše než k instanci třídy, jsou používány pro ukládání a sdílení
informací používaných na celou třídu objektů. Statická proměnná je například vhodná, jestliže si přejete zachovat čítač
toho, kolikrát je třída konkretizovaná, nebo jestliže si přejete uchovat maximální počet instancí tříd, které jsou
povoleny.
Následující příklad vytváří proměnnou totalCount, která bude sledovat počet konkretizací třídy a konstantu
MAX_NUM pro uchování maximálního počtu konkretizací. Proměnné totalCount a MAX_NUM jsou statické, protože
obsahují hodnoty, které se vztahují ke třídě jako celku, spíše než k určité instanci.
class StaticVars
{
public static var totalCount:int = 0;
public static const MAX_NUM:uint = 16;
}
Kód, který je externí ke třídě StaticVars a jakékoliv z jejích podtříd, může odkazovat vlastnosti totalCount a MAX_NUM
pouze prostřednictvím samotné třídy. Správný je například následující kód:
trace(StaticVars.totalCount); // output: 0
trace(StaticVars.MAX_NUM); // output: 16
Ke statickým proměnným nemáte přístup prostřednictvím instance třídy, takže následující kód vrátí chyby:
var myStaticVars:StaticVars = new StaticVars();
trace(myStaticVars.totalCount); // error
trace(myStaticVars.MAX_NUM); // error
Proměnné, které jsou deklarovány pomocí klíčového slova static i const, musí být iniciovány v čase deklarace
konstanty, jako to třída StaticVars provádí pro MAX_NUM. K MAX_NUM uvnitř konstruktoru nebo metody instance
nemůžete přiřadit hodnotu. Následující kód generuje chybu, protože se nejedná o platný způsob inicializace statické
konstanty:
// !! Error to initialize static constant this way
class StaticVars2
{
public static const UNIQUESORT:uint;
function initializeStatic():void
{
UNIQUESORT = 16;
}
}
Proměnné instance:
Proměnné instance zahrnují vlastnosti deklarované pomocí klíčových slov var a const, ale bez klíčového slova
static. Proměnné instance připojené k instancím třídy spíše než k celé třídě jsou užitečné pro uchovávání hodnot,
které jsou specifické pro instanci. Například třída Array má vlastnost instance pojmenovanou length uchovávající
počet prvků pole, které vlastní určitá instance třídy Array.
91
Proměnné instance, ať už deklarovány jako var nebo const, nemohou být potlačeny v podtřídě. Funkce podobné
potlačení proměnných můžete nicméně dosáhnout potlačením metod mechanismů získání a nastavení.
Metody
Metody jsou funkce, které jsou součástí definice třídy. Po vytvoření instance třídy je k dané instanci připojena metoda.
Narozdíl od funkce deklarované mimo třídu nelze metodu použít mimo instance, ke které byla připojena.
Metody jsou definovány pomocí klíčového slova function. Jako u každé vlastnosti třídy lze na metody aplikovat
jakékoliv atributy této vlastnosti třídy, včetně atributů „private“, „protected“, „public“, „internal“, „static“ nebo
„custom namespace“. Můžete použít například následující příkaz funkce:
public function sampleFunction():String {}
Nebo můžete použít proměnnou, ke které připojíte výraz funkce, a to následovně:
public var sampleFunction:Function = function () {}
Ve většině případů použijete z následujících důvodů příkaz funkce namísto výrazu funkce:
• Příkazy funkce jsou stručnější a snadněji se čtou.
• Příkazy funkce vám umožňují použít klíčová slova override a final.
• Příkazy funkce vytvářejí pevnější vazbu mezi identifikátorem (název funkce) a kódem uvnitř těla metody. Protože
hodnota proměnné může být změněna pomocí příkazu přiřazení, může být spojení mezi proměnnou a výrazem její
funkce kdykoliv přerušeno. Ačkoliv se tomuto problému můžete vyhnout deklarováním proměnné pomocí const
namísto var, tato technika není považována za nejlepší postup, neboť znesnadňuje čtení kódu a brání použití
klíčových slov override a final.
Jedním případem, kdy musíte použít výraz funkce, je situace, kdy si přejete připojit funkci k objektu prototypu.
Metody konstruktoru
Metody konstruktoru, někdy nazývané konstruktory, jsou funkce, které sdílejí stejný název jako třídy, ve kterých jsou
definovány. Každý kód, který zahrnete do metody konstruktoru je proveden, kdykoliv je instance dané třídy vytvořena
pomocí klíčového slova new. Následující kód například definuje jedinou třídu nazvanou Example, která obsahuje
jedinou vlastnost pojmenovanou status. Počáteční hodnota proměnné status je množina uvnitř funkce
konstruktoru.
class Example
{
public var status:String;
public function Example()
{
status = "initialized";
}
}
var myExample:Example = new Example();
trace(myExample.status); // output: initialized
Metody konstruktoru mohou být pouze veřejné, ale použití atributu public je volitelné. Na konstruktoru nemůžete
použít žádný z jiných specifikátorů přístupu, včetně private, protected nebointernal. S metodou konstruktoru
také nemůžete použít uživatelem definovaný jmenný prostor.
92
Konstruktor může provést explicitní volání ke konstruktoru své přímé nadřazené třídy pomocí příkazu super().
Jestliže konstruktor nadřazené třídy není explicitně vyvolán, kompilátor automaticky vloží volání před první příkaz do
těla konstruktoru. Metody nadřazené třídy můžete také vyvolat pomocí předpony super jako odkazu na nadřazenou
třídu. Jestliže se rozhodnete použít super() i super v těle stejného konstruktoru, volejte nejprve super(). V opačném
případě se odkaz super nebude chovat dle očekávání. Konstruktor super() by měl být také vyvolán před příkazem
throw nebo return.
Následující příklad demonstruje, co se stane, jestli se pokusíte použít odkaz super před vyvoláním konstruktoru
super(). Nová třída ExampleEx rozšiřuje třídu Example. Konstruktor ExampleEx se pokusí o přístup k proměnné
stavu definované ve své nadřazené třídě, ale tento pokus provede před vyvoláním super(). Příkaz trace() uvnitř
konstruktoru ExampleEx vytvoří hodnotu null, protože proměnná status není dostupná, dokud není konstruktor
super() proveden.
class ExampleEx extends Example
{
public function ExampleEx()
{
trace(super.status);
super();
}
}
var mySample:ExampleEx = new ExampleEx(); // output: null
Ačkoliv je uvnitř konstruktoru povoleno použít příkaz return, není povoleno vrátit hodnotu. Jinými slovy, příkazy
return nesmí mít přiřazené výrazy nebo hodnoty. Následně pak metodám konstruktoru není povoleno vracet
hodnoty, což znamená, že nelze specifikovat žádný typ návratu.
Jestliže v dané třídě nedefinujete metodu konstruktoru, kompilátor automaticky vytvoří prázdný konstruktor. Pokud
daná třída rozšiřuje jinou třídu, kompilátor zahrne do konstruktoru, kterého vytvoří, volání metody super().
Statické metody
Statické metody, označované také metody třídy , jsou metody deklarované pomocí klíčového slova static. Statické
metody, které jsou připojeny ke třídě spíše než k instanci třídy, jsou užitečné pro funkci zapouzdření, která ovlivňuje
něco jiného než stav jednotlivé instance. Protože jsou statické metody přiřazeny ke třídě jako celek, jsou přístupné
pouze prostřednictvím třídy, ale nikoliv prostřednictvím instance třídy.
Statické metody jsou užitečné pro funkci zapouzdření, která neovlivňuje pouze stav instancí třídy. Jinými slovy,
metoda by měla být statická, jestliže poskytuje funkčnost, která přímo neovlivňuje hodnotu instance třídy. Například
třída Date má statickou metodu pojmenovanou parse(), která přebírá řetězec a převádí jej na číslo. Metoda je
statická, protože neovlivňuje jednotlivé instance třídy. Místo toho metoda parse() převezme řetězec, který
představuje hodnotu dat, analyzuje jej a vrátí několik formátů kompatibilních s interní reprezentací objektu Date. Tato
metoda není metoda instance, protože použití dané metody pro instanci třídy Date nedává smysl.
Porovnejte statickou metodu parse() s jednou z metod instance třídy Date, například s metodou getMonth().
Metoda getMonth() je metoda instance, protože operuje přímo na hodnotě instance, a to dosazením určité
komponenty (měsíce) instance Date.
Protože statické metody nejsou svázány s jednotlivými instancemi, nemůžete použít klíčová slova this nebo super v
rámci těla statické metody. Reference this i reference super mají význam pouze v rámci daného kontextu metody
instance.
V kontrastu k některým jiným programovacím jazykům založeným na třídě nejsou statické metody v jazyce
ActionScript 3.0 zděděné.
93
Metody instance
Metody instance jsou metody, které jsou prohlášeny bez klíčového slova static. Metody instance, které jsou
připojeny k instancím třídy namísto třídy jako celku, jsou užitečné pro implementaci funkčnosti, která ovlivňuje
jednotlivé instance třídy. Například třídy Array obsahuje metodu instance pojmenovanou sort(), která operuje
přímo na instancích Array.
V rámci těla metody instance jsou jak statické tak proměnné instance v rozsahu, což znamená, že proměnné
definované ve stejné třídě mohou být odkazovány pomocí jednoho identifikátoru. Například následující třída
CustomArray rozšiřuje třídu Array. Třída CustomArray definuje statickou proměnnou pojmenovanou
arrayCountTotal pro sledování celkového počtu instancí tříd, instanci pojmenovanou arrayNumber, která sleduje
pořadí, ve kterém jsou instance vytvářeny a metodu instance pojmenovanou getPosition(), která vrátí hodnoty
těchto proměnných.
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);
}
}
Ačkoliv kód, který je umístěn mimo třídu, musí přistupovat ke statické proměnné arrayCountTotal přes objekt třídy
pomocí vlastnosti CustomArray.arrayCountTotal, kód umístěný uvnitř těla metody getPosition() může přímo
odkazovat ke statické proměnné arrayCountTotal. Toto je pravda dokonce pro statické proměnné v nadřazených
třídách. Ačkoliv statické vlastnosti nejsou zděděny v jazyce ActionScript 3.0, statické vlastnosti v nadřazené třídě jsou
v rozsahu. Například třída Array má několik málo statických proměnných. Jednou z nich je konstanta pojmenovaná
DESCENDING. Kód v nadřazené třídě může dosáhnout přístupu ke statické konstantě DESCENDING pomocí
jednoduchého identifikátoru:
public class CustomArray extends Array
{
public function testStatic():void
{
trace(DESCENDING); // output: 2
}
}
Hodnota reference this uvnitř těla metody instance je odkazem na instanci, ke které je metoda připojena. Následující
kód ukazuje, že odkaz this ukazuje k instanci, která obsahuje danou metodu:
94
class ThisTest
{
function thisValue():ThisTest
{
return this;
}
}
var myTest:ThisTest = new ThisTest();
trace(myTest.thisValue() == myTest); // output: true
Dědičnost metody instance lze ovládat pomocí klíčových slov override a final. Atribut override můžete použít pro
novou definici zděděné metody a atribut final zabraňuje podtřídám v potlačení metody.
Získání a nastavení metod mechanismů přístupu
Funkce získání a nastavení mechanismů přístupu se nazývají mechanismy získání a mechanismy nastavení. Umožňují
vám zachovat programovací principy skrývání informací a zapouzdření a pro vámi vytvářené třídy poskytují snadno
použitelné programovací rozhraní. Funkce získání a nastavení vám umožňují zachovat vlastnosti vaší třídy pouze pro
danou třídu, ale umožňují uživatelům vaší třídy přístup k těmto vlastnostem, jako v případě přístupu k proměnné třídy
namísto vyvolání metody třídy.
Výhodou tohoto přístupu je to, že vám umožňuje vyhnout se tradičním funkcím přístupových mechanismů s
nepraktickými jmény, například getPropertyName() a setPropertyName(). Další výhodou mechanismů získání a
nastavení je to, že pro každou vlastnost nemusíte mít dvě veřejné funkce, které umožňují čtení a zápis.
Následující příklad třídy pojmenovaný GetSet zahrnuje funkce získání a nastavení mechanismů přístupu
pojmenované publicAccess(), které poskytují přístup k soukromé proměnné pojmenované privateProperty:
class GetSet
{
private var privateProperty:String;
public function get publicAccess():String
{
return privateProperty;
}
public function set publicAccess(setValue:String):void
{
privateProperty = setValue;
}
}
Při pokusu o přímý přístup k vlastnosti privateProperty dojde k chybě:
var myGetSet:GetSet = new GetSet();
trace(myGetSet.privateProperty); // error occurs
Namísto toho uživatel třídy GetSet použije něco, co se jeví jako vlastnost pojmenovaná publicAccess, ale ve
skutečnosti se jedná o dvojici funkcí získání a nastavení mechanismu přístupu, které operují na soukromé vlastnosti
s názvem privateProperty. Následující příkaz konkretizuje třídu GetSet a poté nastaví hodnotu privateProperty
pomocí veřejného mechanismu přístupu s názvem publicAccess:
var myGetSet:GetSet = new GetSet();
trace(myGetSet.publicAccess); // output: null
myGetSet.publicAccess = "hello";
trace(myGetSet.publicAccess); // output: hello
95
Funkce mechanismů získání a nastavení také umožňují potlačení vlastností, které jsou zděděny z nadřazené třídy. To
není možné při použití běžných proměnných členů tříd. Proměnné členů třídy, které jsou deklarovány pomocí
klíčového slova var nelze v podtřídě potlačit. Vlastnosti vytvořené pomocí funkcí mechanismů získání a nastavení toto
omezení nicméně nemají. Atribut override můžete použít na funkcích mechanismů získání a nastavení, které jsou
zděděny z nadřazené třídy.
Metody vazeb
Metoda vazby, někdy nazvaná metoda ohraničení, je jednoduše metoda vyjmutá ze své instance. Příklady metod vazby
zahrnují metody, které jsou předány jako argumenty funkci nebo navráceny jako hodnoty z funkce. Nově v jazyce
ActionScript 3.0 je metoda vazby podobná metodě ohraničení v tom, že zachovává své lexikální prostředí i v případě,
že je vyjmuta ze své instance. Klíčovým rozdílem mezi metodou vazby a funkcí ohraničení je nicméně to, že reference
this pro metodu vazby zůstává propojena s instancí, která danou metodu implementuje. Jinými slovy reference this
v metodě vazby vždy poukazuje na původní objekt, který danou metodu implementoval. Pro funkci ohraničení je
reference this generická, což znamená, že ukazuje na jakýkoliv objekt, ke kterému je funkce v době svého volání
připojena.
Jestliže používáte klíčové slovo this, je důležité, abyste porozuměli metodám vazeb. Vzpomeňte si, že klíčové slovo
this poskytuje odkaz na nadřazený objekt metody. Většina programátorů jazyka ActionScript očekává, že klíčové
slovo this vždy odkazuje na objekt nebo třídu obsahující definici metody. Bez provázání metod by toto nicméně
neplatilo vždy. V předchozích verzích jazyka ActionScript například reference this neodkazovala vždy k instanci,
která danou metodu implementovala. Při vyjmutí metod z instance v jazyce ActionScript 2.0 je reference this nejen
nepropojena s původní instancí, ale ani proměnné členů a metody třídy instance nejsou dostupné. To v jazyce
ActionScript 3.0 nepředstavuje problém, protože metody provázání jsou automaticky vytvořeny při odeslání metody
jako parametru. Metody vazeb zajišťují, že klíčové slovo this vždy odkazuje na objekt nebo třídu, ve které je
definována metoda.
Následující kód definuje třídu pojmenovanou ThisTest, která obsahuje metodu s názvem foo() definující metodu
vazby a metodu pojmenovanou bar(), která metodu vazby vrátí. Kód externí ke třídě vytvoří instanci třídy ThisTest,
vyvolá metodu bar() a uchová vrácenou hodnotu v proměnné pojmenované 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 */
96
Poslední dva řádky kódu ukazují, že reference this v metodě vazby foo() stále ukazuje na instanci třídy ThisTest,
ačkoliv reference this v předcházejícím řádku ukazuje na globální objekt. Navíc metoda vazby uchovaná v proměnné
myFunc má stále přístup k proměnným, které jsou členy třídy ThisTest. Jestliže je stejný kód spuštěn v jazyce
ActionScript 2.0, reference this bude odpovídat a proměnná num bude undefined.
Jedna oblast, kde je přidání metody vazby nejvíce zřejmé, je zpracovávání událostí, protože metoda
addEventListener() vyžaduje, abyste funkci nebo metodu odeslali jako argument.
Výčet s třídami
Výčty jsou vlastní typy dat, které vytváříte za účelem zapouzdření malé množiny hodnot. Jazyk ActionScript 3.0
nepodporuje na rozdíl od jazyka C++ s klíčovým slovem enum nebo jazyka Java s rozhraním výčtu specifické možnosti
výčtu. Výčty můžete nicméně vytvořit pomocí tříd a statických konstant. Například třída PrintJob v jazyce
ActionScript 3.0 používá výčet s názvem PrintJobOrientation k uchovávání hodnot „landscape" a „portrait", jak
je znázorněno v následujícím kódu:
public final class PrintJobOrientation
{
public static const LANDSCAPE:String = "landscape";
public static const PORTRAIT:String = "portrait";
}
Dle úmluvy je třída výčtu deklarována s atributem final, protože není třeba danou třídu rozšířit. Třída obsahuje
pouze statické členy, což znamená, že nevytváříte instance dané třídy. Namísto toho přistupujete k hodnotám výčtu
přímo prostřednictvím objektu třídy, jak je ukázáno v následujícím výpise kódu.
var pj:PrintJob = new PrintJob();
if(pj.start())
{
if (pj.orientation == PrintJobOrientation.PORTRAIT)
{
...
}
...
}
Všechny třídy výčtu v jazyce ActionScript 3.0 obsahují pouze proměnné typu Řetězec, int nebo uint. Výhodou použití
výčtu namísto řetězce literálu nebo číselných hodnot je to, že pomocí výčtu naleznete snadněji typografické chyby.
Jestliže špatně zadáte název výčtu, kompilátor jazyka ActionScript vygeneruje chybu. Jestliže používáte hodnoty
literálu, kompilátor nezjistí chybu, jestliže slovo špatně napíšete nebo použijete špatné číslo. V předchozím příkladu
kompilátor vygeneruje chybu, jestliže je název konstanty výčtu nesprávný:
if (pj.orientation == PrintJobOrientation.PORTRAI) // compiler error
Nicméně kompilátor nevygeneruje chybu, jestliže špatně napíšete hodnotu řetězce literálu:
if (pj.orientation == "portrai") // no compiler error
Druhá technika pro vytvoření výčtů také zahrnuje vytvoření samostatné třídy se statickými vlastnostmi pro výčet. Tato
technika se nicméně liší v tom, že každá ze statických vlastností obsahuje instanci dané třídy, namísto řetězce nebo
celočíselné hodnoty. Například následující kód vytvoří třídu výčtu pro dny v týdnu:
97
public final class Day
{
public static const
public static const
public static const
public static const
public static const
public static const
public static const
}
MONDAY:Day = new Day();
TUESDAY:Day = new Day();
WEDNESDAY:Day = new Day();
THURSDAY:Day = new Day();
FRIDAY:Day = new Day();
SATURDAY:Day = new Day();
SUNDAY:Day = new Day();
Tato technika není používána jazykem ActionScript 3.0, ale je používána mnoha vývojáři, kteří upřednostňují
vylepšený typ kontroly, který tato technika nabízí. Například metoda, která vrátí hodnotu výčtu, může omezit
vrácenou hodnotu na datový typ výčtu. Následující kód ukazuje nejen funkci, která vrátí den v týdnu, ale také volání
funkce, které používá typ výčtu jako typ anotace:
function getDay():Day
{
var date:Date = new Date();
var retDay:Day;
switch (date.day)
{
case 0:
retDay = Day.MONDAY;
break;
case 1:
retDay = Day.TUESDAY;
break;
case 2:
retDay = Day.WEDNESDAY;
break;
case 3:
retDay = Day.THURSDAY;
break;
case 4:
retDay = Day.FRIDAY;
break;
case 5:
retDay = Day.SATURDAY;
break;
case 6:
retDay = Day.SUNDAY;
break;
}
return retDay;
}
var dayOfWeek:Day = getDay();
Třídu Day můžete také vylepšit tak, aby propojila celé číslo s každým dnem v týdnu a poskytla metodu toString(),
která vrátí reprezentaci řetězce daného dne.
98
Třídy vloženého datového zdroje
Jazyk ActionScript 3.0 používá speciální třídy, nazvané třídy vloženého datového zdroje, pro reprezentaci vložených
datových zdrojů. vložený datový zdroj je zdroj, jako například zvuk, obraz, nebo typ písma, který je zahrnut do souboru
SWF v čase kompilace. Vložení datového zdroje místo jeho dynamického načtení zajistí jeho dostupnost za běhu, ale
na druhou stranu také zvýší velikost souboru SWF.
Použití tříd vloženého datového zdroje v aplikaci Flash Professional
Pro vložení datového zdroje nejprve umístěte zdroj do knihovny souboru FLA. Poté pomocí vlastnosti propojení
datového zdroje poskytněte název pro třídu vloženého datového zdroje. Jestliže nemůže být třída dle daného názvu
nalezena v cestě třídy, je pro vás automaticky vygenerována. Poté můžete vytvořit instanci třídy vloženého datového
zdroje a použít jakékoliv vlastnosti a metody definované nebo zděděné danou třídou. Například následující kód lze
použít pro přehrání vloženého zvuku, který je propojen s třídou vloženého datového zdroje s názvem PianoMusic:
var piano:PianoMusic = new PianoMusic();
var sndChannel:SoundChannel = piano.play();
K vložení datových zdrojů do projektu aplikace Flash Professional lze rovněž použít tag metadat [Embed] (popsáno
v následující části). Při použití tagu metadat [Embed] ve vytvořeném kódu provede aplikace Flash Professional
kompilaci projektu pomocí kompilátoru Flex místo kompilátoru Flash Professional.
Použití tříd vloženého datového zdroje pomocí kompilátoru Flex
Jestliže kompilujete kód pomocí kompilátoru Flex, vložte datový zdroj do kódu jazyka ActionScript pomocí tagu
metadat [Embed]. Umístěte datový zdroj do hlavní složky zdroje nebo do jiné složky, která je v cestě k sestavení vašeho
projektu. Když se kompilátor Flex setká se značkou metadat Embed, vytvoří třídu vloženého datového zdroje. Třída je
přístupná pomocí proměnné s datovým typem Class, kterou deklarujete ihned po příznaku metadat [Embed].
Například následující kód vloží zvuk pojmenovaný sound1.mp3 a použije proměnnou nazvanou soundCls pro
uchování odkazu na třídu vloženého datového zdroje propojenou s daným zvukem. Příklad poté vytvoří instanci třídy
vloženého datového zdroje a na dané instanci vyvolá metodu play():
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();
}
}
}
99
Adobe Flash Builder
Aby bylo možné použít v projektu Flex Builder jazyka ActionScript tag metadat [Embed], je třeba importovat všechny
nezbytné třídy z rámce Flex. Pro vkládání zvuků je například nutné importovat třídu mx.core.SoundAsset. Pro použití
rámce Flex začleňte soubor framework.swc do cesty k sestavení jazyka ActionScript. Tím se zvětší velikost souboru SWF.
Adobe Flex
V rozhraní Flex lze vložit datový zdroj také pomocí příkazu @Embed() v definici tagu MXML.
Rozhraní
Rozhraní je skupinou deklarací metody, které umožňují nesouvisejícím objektům navzájem komunikovat. Například
jazyk ActionScript 3.0 definuje rozhraní IEventDispatcher, které obsahuje deklarace metody, kterou třída používá pro
zpracování objektů události. Rozhraní IEventDispatcher zavádí standardní způsob pro vzájemné předání objektů
událostí. Následující kód ukazuje definici rozhraní IEventDispatcher interface:
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;
}
Rozhraní jsou založena na rozdílu mezi rozhraním metody a její implementací. Rozhraní metody obsahuje všechny
potřebné informace pro volání dané metody, včetně názvu metody, všech její parametrů a jejího typu návratu.
Implementace metody nezahrnuje pouze informace o rozhraní, ale také proveditelné příkazy, které provedou chování
metody. Definice rozhraní obsahuje pouze rozhraní metody a jakákoliv třída, která implementuje dané rozhraní, je
odpovědná za definici implementací metody.
V jazyce ActionScript 3.0 implementuje třída EventDispatcher rozhraní IEventDispatcher definováním všech metod
rozhraní IEventDispatcher a přidáním těl metod ke každé z těchto metod. Následující kód je výpisem z definice třídy
EventDispatcher:
public class EventDispatcher implements IEventDispatcher
{
function dispatchEvent(event:Event):Boolean
{
/* implementation statements */
}
...
}
Rozhraní IEventDispatcher slouží jako protokol, který instance EventDispatcher používají pro zpracování objektů
události a jejich předání k jiným objektům, které také mají implementováno rozhraní IEventDispatcher.
100
Dalším způsobem popsání rozhraní je to, že stejně jako třída definuje datový typ. Podle toho může být rozhraní
použito jako typ anotace i jako třída. Jako datový typ lze rozhraní použít s operátory, jako například is a as, které
vyžadují datový typ. Narozdíl od třídy nemůže být rozhraní konkretizováno. Tento rozdíl donutil mnoho
programátorů přemýšlet o rozhraních jako o abstraktních datových typech a třídách jako o konkrétních datových
typech.
Definice rozhraní
Struktura definice rozhraní je podobná struktuře definice třídy s výjimkou, že rozhraní může obsahovat pouze metody
bez těl. Rozhraní nemůže zahrnovat proměnné nebo konstanty, ale může obsahovat mechanismy získání a nastavení.
Pro definování rozhraní použijte klíčové slovo interface. Například následující rozhraní, IExternalizable, je součástí
balíku ActionScript 3.0. Rozhraní IExternalizable definuje protokol pro serializaci objektu, což znamená jeho
převedení do formátu vhodného k uložení na zařízení nebo pro přesun po síti.
public interface IExternalizable
{
function writeExternal(output:IDataOutput):void;
function readExternal(input:IDataInput):void;
}
Dané rozhraní IExternalizable je deklarováno pomocí modifikátoru řízení přístupu public. Definice rozhraní lze
upravit pouze pomocí specifikátorů řízení přístupu public a internal. Deklarace metody uvnitř definice rozhraní
nemohou mít žádné specifikátory ovládání přístupu.
Jazyk ActionScript 3.0 se řídí ustanovením, kde názvy rozhraní začínají velkým I, ale jako název rozhraní můžete
použít jakýkoliv povolený identifikátor. Definice rozhraní jsou často umístěny na nevyšší úrovni balíku. Definice
rozhraní nelze umístit dovnitř definice třídy nebo dovnitř jiné definice rozhraní.
Rozhraní mohou rozšířit jedno nebo více jiných rozhraní. Například následující rozhraní IExample rozšiřuje rozhraní
IExternalizable:
public interface IExample extends IExternalizable
{
function extra():void;
}
Jakákoliv třída, která implementuje rozhraní, musí zahrnovat implementace nejen pro metodu extra(), ale také pro
metodywriteExternal() a readExternal() zděděné z rozhraní IExternalizable.
Implementace rozhraní ve třídě
Třída je jediným prvkem jazyka ActionScript 3.0, který může implementovat rozhraní. Pomocí klíčového slova
implements v deklaraci třídy implementujete jedno nebo více rozhraní. Následující příklad definuje dvě rozhraní
IAlpha a IBeta a třídu Alfa, která je obě implementuje.
101
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 {}
}
Ve třídě, která implementuje rozhraní, musí implementovaná metoda provést následující:
• Použijte identifikátor ovládání přístupu public.
• Použijte stejný název jako má metoda rozhraní.
• Mají stejný počet parametrů s typy dat, které odpovídají datovým typům parametrů metody rozhraní.
• Použijte stejný typ návratu.
public function foo(param:String):String {}
Jistou flexibilitu máte nicméně v tom, jak pojmenujete parametry metody, kterou implementujete. Ačkoliv počet
parametrů a datový typ každého parametru v dané implementované metodě musí odpovídat parametru metody
rozhraní, názvy parametrů odpovídat nemusí. Například v předchozím příkladě je parametr metody Alpha.foo()
pojmenovaný param:
Nicméně parametr je pojmenovaný str v metodě rozhraní IAlpha.foo():
function foo(str:String):String;
Určitou flexibilitu máte také s výchozími hodnotami parametru. Definice rozhraní může zahrnovat deklarace funkce
s výchozími hodnotami parametrů. Metoda, která implementuje takovou deklaraci funkce, musí mít výchozí hodnotu
parametru, který je členem stejného datového typu, shodnou s hodnotou určenou v definici rozhraní, ale skutečná
hodnota nemusí odpovídat. Například následující kód definuje rozhraní, které obsahuje metodu s výchozí hodnotou
parametru 3:
interface IGamma
{
function doSomething(param:int = 3):void;
}
Následující definice třídy implementuje rozhraní IGamma, ale používá odlišnou výchozí hodnotu parametru:
class Gamma implements IGamma
{
public function doSomething(param:int = 4):void {}
}
Důvodem pro tuto flexibilitu je to, že pravidla pro implementování rozhraní jsou navržena specificky pro zajištění
kompatibility typu dat a vyžadování identických názvů parametrů a výchozích hodnot parametrů není pro dosažení
daného cíle nezbytné.
102
Zdědění
Dědičnost je formou opětovného použití kódu, které programátorům umožňuje vyvinout nové třídy, které jsou
založeny na stávajících třídách. Stávající třídy jsou často označovány jako základní třídy nebo nadřazené třídy, zatímco
nové třídy se obvykle nazývají podtřídy. Klíčovou výhodou dědičnosti je to, že vám umožňuje znovu použít kód ze
základní třídy a přesto ponechat stávající kód bez změn. A navíc, dědičnost nevyžaduje žádné změny způsobu, kterým
jiné třídy reagují se základní třídou. Spíše než úpravou stávající třídy, která mohla být řádně testována nebo může již
být používána, můžete pomocí dědičnosti manipulovat s danými třídami jako s integrovaným modulem, který můžete
rozšířit o dodatečné vlastnosti nebo metody. Stejně tak pomocí klíčového slova extends určíte, že třída dědí z jiné
třídy.
Dědičnost vám také umožňuje využít ve svém kódu polymorfismus. Polymorfismus je schopnost použít jediný název
metody pro metodu, která se chová jinak při použití jiných typů dat. Jednoduchým příkladem je základní třída
pojmenovaná Shape s dvěma podtřídami pojmenovanými Circle a Square. Třída Shape definuje metodu
pojmenovanou area(), která vrací prostor tvaru. Jestliže je implementován polymorfismus, můžete metodu area()
vyvolat na objekty typu Circle a Square a provést správné výpočty. Dědičnost aktivuje polymorfismus umožněním
podtřídám zdědit, předefinovat nebo potlačit metody ze základní třídy. V následujícím příkladě je metoda area()
předefinována třídami Circle a Square:
class Shape
{
public function area():Number
{
return NaN;
}
}
class Circle extends Shape
{
private var radius:Number = 1;
override public function area():Number
{
return (Math.PI * (radius * radius));
}
}
class Square extends Shape
{
private var side:Number = 1;
override public function area():Number
{
return (side * side);
}
}
var cir:Circle = new Circle();
trace(cir.area()); // output: 3.141592653589793
var sq:Square = new Square();
trace(sq.area()); // output: 1
Protože každá třída definuje typ dat, vytvoří použití dědičnosti zvláštní vztah mezi základní třídou a třídou, která jí
prodlužuje. Podtřída vlastní všechny vlastnosti své základní třídy, což znamená, že instance podtřídy může být vždy
nahrazena za instanci základní třídy. Například jestliže metoda definuje parametr typu Shape, je možné předat
argument typu Circle, protože Circle rozšiřuje Shape, a to následovně:
103
function draw(shapeToDraw:Shape) {}
var myCircle:Circle = new Circle();
draw(myCircle);
Vlastnosti a dědičnost instancí
Vlastnost instance, ať už definovaná pomocí klíčových slov function, var nebo const, je děděna všemi podtřídami,
pokud daná vlastnost není v základní třídě deklarována s atributem private. Například třída Event v jazyce
ActionScript 3.0 má několik podtříd, které dědí vlastnosti společné pro všechny objekty události.
Pro některé typy událostí třída Event obsahuje všechny vlastnosti nezbytné pro definici události. Tyto typy událostí
nevyžadují vlastnosti instancí mimo těch definovaných ve třídě Event. Příklady takových událostí jsou událost
complete, ke které doje při úspěšném načtení dat a událost connect, ke které dojde při navázání síťového spojení.
Následující příklad je výpisem ze třídy Event, která vykazuje některé z vlastností a metod, které jsou zděděny
podtřídou. Protože jsou vlastnosti zděděné, má k těmto vlastnostem přístup instance jakékoliv podtřídy.
public class Event
{
public function get type():String;
public function get bubbles():Boolean;
...
public
public
public
public
...
function
function
function
function
stopPropagation():void {}
stopImmediatePropagation():void {}
preventDefault():void {}
isDefaultPrevented():Boolean {}
}
Jiné typy události vyžadují jedinečné vlastnosti, které nejsou dostupné ve třídě Event. Tyto události jsou definovány
pomocí podtříd třídy Event, takže nové vlastnosti lze přidat k vlastnostem definovaným ve třídě Event. Příkladem
takové podtřídy je třída MouseEvent, která přidává vlastnosti jedinečné k události spojené s pohybem nebo klepnutím
myši, například k události mouseMove a click. Následující příklad je výpisem z třídy MouseEvent, která ukazuje
definici vlastností, které existují na dané podtřídě, ale nikoliv na základní třídě:
public class MouseEvent extends Event
{
public static const CLICK:String= "click";
public static const MOUSE_MOVE:String = "mouseMove";
...
public function get stageX():Number {}
public function get stageY():Number {}
...
}
Specifikátory ovládání přístupu a dědičnost
Jestliže je vlastnost deklarována pomocí klíčového slova public, je vlastnost pro kód viditelná kdekoliv. To znamená,
že klíčové slovo public, narozdíl od klíčových slov private, protected a internalneuplatňuje na dědičnost
vlastnosti žádná omezení.
Jestliže je vlastnost deklarována pomocí klíčového slova private, je viditelná pouze ve třídě, která je definuje, což
znamená, že není děděná žádnou podtřídou. Toto chování je odlišné od předchozích verzí jazyka ActionScript, kde se
klíčové slovo private chovalo více jako klíčové slovo jazyka ActionScript protected.
104
Klíčové slovo protected udává, že je vlastnost viditelná nejen v rámci třídy, která ji definuje, ale také pro všechny
podtřídy. Narozdíl od klíčového slova protected v programovacím jazyce Java, klíčové slovo protected v jazyce
ActionScript 3.0 nezviditelňuje vlastnost pro všechny jiné třídy ve stejném balíku. V jazyce ActionScript 3.0 mají k
vlastnosti s klíčovým slovem protected přístup pouze podtřídy. Chráněná vlastnost je navíc viditelná pro podtřídy,
ať je podtřída ve stejném balíku jako daná třída, nebo v balíku odlišném.
Chcete-li omezit viditelnost vlastnosti na balík, ve kterém je definovaná, použijte klíčové slovo internal, nebo
nepoužijte žádný specifikátor ovládání přístupu. Specifikátor ovládání přístupu internal je výchozím specifikátorem
ovládání přístupu, který bude použit v případě, že jiný specifikátor určen není. Vlastnost označenou jako internal
zdědí pouze podtřída, která se nachází ve stejném balíku.
Pomocí následujícího příkladu zjistíte, jak každý ze specifikátorů ovládání přístupu ovlivní dědičnost napříč hranicemi
balíku. Následující kód definuje hlavní třídu aplikace nazvanou AccessControl a dvě další třídy pojmenované Base a
Extender. Třída Base se nachází v balíku pojmenovaném foo a třída Extender, která je podtřídou třídy Base, je
umístěna v balíku pojmenovaném bar. Třída AccessControl importuje pouze třídu Extender a vytvoří instanci
Extender, která se pokusí o přístup k proměnné pojmenované str definované ve třídě Base. Proměnná str je
deklarovaná jako public, takže kód je sestaven a běží tak, jak je ukázáno v následujícím výpise:
// Base.as in a folder named foo
package foo
{
public class Base
{
public var str:String = "hello"; // change public on this line
}
}
// Extender.as in a folder named bar
package bar
{
import foo.Base;
public class Extender extends Base
{
public function getString():String {
return str;
}
}
}
// main application class in file named AccessControl.as
package
{
import bar.Extender;
public class AccessControl extends MovieClip
{
public function AccessControl()
{
var myExt:Extender = new Extender();
trace(myExt.str);// error if str is not public
trace(myExt.getString()); // error if str is private or internal
}
}
}
105
Chcete-li vědět, jak jiné specifikátory ovládání přístupu ovlivňují kompilaci a provedení předchozího příkladu, změňte
specifikátor ovládání přístupu proměnné str na private, protected nebo internal, a to po odstranění nebo
okomentování následujícího řádku ze třídy AccessControl:
trace(myExt.str);// error if str is not public
Potlačení proměnných není povoleno
Vlastnosti deklarované s klíčovými slovy var nebo const jsou zděděny, ale nemohou být potlačeny. Potlačit vlastnost
znamená předefinovat danou vlastnost v podtřídě. Jediným typem vlastnosti, který může být potlačen, jsou přístupové
mechanismy získání a nastavení (vlastnosti deklarované pomocí klíčového slova function). Ačkoliv nelze potlačit
proměnnou instance, podobné funkce můžete dosáhnout vytvořením metod získání a nastavení pro proměnou
instance a potlačením metod.
Potlačování metod
Potlačení metody znamená nové definování chování zděděné metody. Statické metody nejsou zděděné a nelze je
potlačit. Metody instance jsou nicméně zděděny podtřídami a lze je potlačit pokud jsou splněna dvě kritéria:
• Metoda instance není deklarována pomocí klíčového slova final v základní třídě. Je-li používáno s metodou
instance, určuje klíčové slovo final záměr programátora zabránit podtřídám potlačit danou metodu.
• Metoda instance není deklarována pomocí specifikátoru ovládání private v základní třídě. Jestliže je metoda
v základní třídě označena jako private, potom při definování metody se stejným názvem v podtřídě není nutné
použít klíčové slovo override, protože metoda základní třídy nebude pro podtřídu viditelná.
Chcete-li potlačit metodu instance, která splňuje tato kritéria, definice metody v podtřídě musí použít klíčové slovo
override a musí odpovídat verzi metody nadřazené třídy, a to následovně:
• Metoda potlačení musí mít stejnou úroveň ovládání přístupu, jako metoda základní třídy. Metoda označená jako
interní má stejnou úroveň ovládání přístupu jako metody, které nemají žádný specifikátor ovládání přístupu.
• Metoda potlačení musí mít stejný počet parametrů jako metoda základní třídy.
• Parametry metody potlačení musí mít stejné anotace typu dat, jako mají parametry v metodě základní třídy.
• Metoda potlačení musí mít stejný typ vrácení jako metoda základní třídy.
Názvy parametrů v dané metodě potlačení nicméně nemusí odpovídat názvům parametrů v základní třídě, jestliže
počet parametrů a typ dat každého parametru souhlasí.
Příkaz super
Při potlačování metody si programátoři často přejí přidat k chování metody nadřazené třídy, kterou potlačují, namísto
úplného nahrazení chování. To vyžaduje mechanismus, který umožňuje metodě podtřídy vyvolat vlastní verzi
nadřazené třídy. Příkaz super takový mechanismus poskytuje, protože obsahuje odkaz na další nadřazenou třídu.
Následující příklad definuje třídu pojmenovanou Base, která obsahuje metodu pojmenovanou thanks() a podtřídu
třídy Base pojmenovanou Extender, která potlačí metodu thanks(). Metoda Extender.thanks() používá příkaz
super pro vyvolání Base.thanks().
106
package {
public class SuperExample extends MovieClip
{
public function SuperExample()
{
var myExt:Extender = new Extender()
trace(myExt.thanks()); // output: Mahalo nui loa
}
}
}
class Base {
public function thanks():String
{
return "Mahalo";
}
}
class Extender extends Base
{
override public function thanks():String
{
return super.thanks() + " nui loa";
}
}
Potlačení mechanismů získání nebo nastavení
Ačkoliv nemůžete potlačit proměnné definované v nadřazené třídě, můžete potlačit mechanismy získání a nastavení.
Například následující kód potlačí mechanismus získání currentLabel, který je definován ve třídě MovieClip v jazyce
ActionScript 3.0:
package
{
public class OverrideExample extends MovieClip
{
public function OverrideExample()
{
trace(currentLabel)
}
override public function get currentLabel():String
{
var str:String = "Override: ";
str += super.currentLabel;
return str;
}
}
}
Výstup příkazu trace() v konstruktoru třídy OverrideExample je Override: null, který ukazuje, že daný příklad
byl schopen potlačit zděděnou vlastnost currentLabel.
107
Statické vlastnosti nezděděné
Statické vlastnosti nejsou zděděny podtřídami. To znamená, že statistické vlastnosti nejsou přístupné prostřednictvím
instance nadřazené třídy. Statická vlastnost je přístupná pouze prostřednictvím objektu třídy, na které je definovaná.
Například následující kód definuje základní třídu pojmenovanou Base a podtřídu, která rozšiřuje základní třídu,
pojmenovanou Extender. Statická proměnná pojmenovaná test je definována ve třídě Base. Kód, jak je zapsán v
následujícím výpise, není slučitelný s přísným režimem a ve standardním režimu vytvoří chybu za běhu programu.
package {
public class StaticExample extends MovieClip
{
public function StaticExample()
{
trace(myExt.test);// error
}
}
}
class Base {
public static var test:String = "static";
}
class Extender extends Base { }
Jediný způsob přístupu ke statické proměnné test je prostřednictvím objektu třídy, jak je ukázáno v následujícím
kódu:
Base.test;
Nicméně je povolené definovat vlastnost instance použitím stejného názvu jako statické vlastnosti. Taková vlastnost
instance může být definována ve stejné třídě jako statická vlastnost nebo v podtřídě. Například základní třída v
předcházejícím příkladě by mohla mít vlastnost instance pojmenovanou test. Následující kód je sestaven a proveden,
protože vlastnost instance je zděděna třídou Extender. Kód by byl také sestaven a proveden, pokud by byla definice
testové proměnné instance přesunuta, ale nikoliv zkopírována, do třídy Extender.
package
{
{
{
trace(myExt.test);// output: instance
}
}
}
class Base
{
public var test:String = "instance";
}
class Extender extends Base {}
108
Statistické vlastnosti a řetězec rozsahu
Ačkoliv statické vlastnosti nejsou zděděny, existují v rámci řetězce rozsahu třídy, která definuje tyto vlastnosti a
jakékoliv podtřídy dané třídy. Jako takové jsou statické vlastnosti v rozsahu třídy, ve které jsou definovány, i jakékoliv
podtřídy. To znamená, že statická vlastnost je přímo přístupná v rámci těla třídy, která definuje statickou vlastnost a v
jakékoliv podtřídě dané třídy.
Následující příklad upravuje třídy definované v předchozím příkladě a ukazuje, že statická proměnná test definovaná
v základní třídě je v rozsahu třídy Extender. Jinými slovy třída Extender má přístup k statické proměnné test bez toho,
aby byla proměnná opatřena předponou s názvem třídy, která definuje test.
package
{
{
{
}
}
}
class Base {
}
{
public function Extender()
{
trace(test); // output: static
}
}
Jestliže je definovaná vlastnost instance, která používá stejný název jako statická vlastnost ve stejné třídě nebo
nadřazené třídě, vlastnost instance má v řetězci rozsahu vyšší prioritu. Vlastnost instance stíní statickou vlastnost, což
znamená, že hodnota vlastnosti instance je použita namísto hodnoty statické vlastnosti. Například následující kód
ukazuje, že jestliže třída Extender definuje proměnnou instance pojmenovanou test, příkaz trace() používá
hodnotu proměnné instance namísto hodnoty statické proměnné:
109
package
{
{
{
}
}
}
class Base
{
}
{
public var test:String = "instance";
public function Extender()
{
trace(test); // output: instance
}
}
Pokročilá témata
Historie podpory OOP jazyka ActionScript
Protože jazyk ActionScript 3.0 navazuje na předchozí verze jazyka ActionScript, může být užitečné pochopit, jak se
model objektu jazyka ActionScript vyvinul. Jazyk ActionScript začal jako jednoduchý skriptovací mechanismus pro
dřívější verze aplikace Flash Professional. Později začali programátoři pomocí jazyka ActionScript vytvářet
komplexnější aplikace. V reakci na potřeby těchto programátorů má každá následující verze nové funkce jazyka, které
umožňují vytváření složitých aplikací.
Jazyk ActionScript 1.0
Jazyk ActionScript 1.0 je verze jazyka použitá v přehrávači Flash Player 6 a v dřívějších verzích. I v této ranné fázi
vývoje byl model objektu jazyka ActionScript založen na konceptu objektu jako základního typu dat. Objekt jazyka
ActionScript je složený typ dat se skupinou vlastností. Hovoříme-li o modelu objektu, pojem vlastnosti zahrnuje vše,
co je připojeno k objektu. Jedná se například o proměnné, funkce nebo metody.
Ačkoliv první generace jazyka ActionScript nepodporuje definici tříd pomocí klíčového slova class, můžete definovat
třídu pomocí speciálního druhu objektu nazvaného objekt prototypu. Namísto použití klíčového slova class pro
vytvoření definice třídy, kterou zkonkretizujete do určitých objektů, jak to děláte v jazycích založených na třídě (Java
a C++), jazyky založené na prototypu (ActionScript 1.0) používají stávající objekt jako model (nebo prototyp) pro jiné
objekty. Zatímco objekty v jazyce založeném na třídě mohou indikovat třídu, která slouží jako její šablona, objekty v
jazyce založeném na prototypu namísto toho ukazují na jiný objekt, svůj prototyp, který slouží jako šablona.
110
Pro vytvoření třídy v jazyce ActionScript 1.0 vytvoříte pro danou třídu funkci konstruktoru. V jazyce ActionScript jsou
funkce skutečné objekty, nikoliv pouze abstraktní definice. Funkce konstruktoru, kterou vytváříte, slouží jako
prototypický objekt pro instance dané třídy. Následující kód vytvoří třídu pojmenovanou Shape a definuje jednu
vlastnost pojmenovanou visible, která je implicitně nastavena na hodnotu true (pravda):
// base class
function Shape() {}
// Create a property named visible.
Shape.prototype.visible = true;
Tato funkce konstruktoru definuje třídu Shape, kterou můžete konkretizovat pomocí operátoru new, a to následovně:
myShape = new Shape();
Stejně jako slouží objekt funkce konstruktoru Shape() jako prototyp pro instance třídy tvaru, může také sloužit jako
prototyp pro podtřídy tvaru - tj. pro další třídy, které rozšiřují třídu Shape.
Vytvoření třídy, která je podtřídou třídy Shape, je proces zahrnující dva kroky. Nejprve vytvořte třídu tím, že pro
danou třídu definujete funkci konstruktoru:
// child class
function Circle(id, radius)
{
this.id = id;
this.radius = radius;
}
Poté použijte operátor new za účelem deklarování, která třída Shape je prototypem třídy Circle. Každá třída, kterou
vytvoříte, implicitně používá třídu Object jako prototyp, což znamená, že Circle.prototype aktuálně obsahuje
generický objekt (instance třídy Object). Pro určení, že prototyp kruhu je tvar a nikoliv objekt, použijte následující kód
pro změnu hodnoty Circle.prototype tak, aby obsahovala objekt tvaru namísto generického objektu:
// Make Circle a subclass of Shape.
Circle.prototype = new Shape();
Třídy Shape a Circle jsou nyní navzájem propojeny ve vztahu dědičnosti, který je běžně znám jako řetězec prototypu.
Tento diagram ilustruje vztah v řetězci prototypu:
Object.prototype
Shape.prototype
Circle.prototype
Základní třída na konci každého řetězce prototypu je třída Object. Třída Object obsahuje statickou vlastnost s názvem
Object.prototype, která ukazuje na základní objekt prototypu pro všechny objekty vytvořené v jazyce ActionScript
1.0. Další objekt v řetězci prototypu našeho příkladu je objekt Shape. Důvod je ten, že vlastnost Shape.prototype
nebyla nikdy explicitně nastavena, takže stále obsahuje generický objekt (instanci třídy Object). Závěrečný odkaz v
tomto řetězci je třída Circle, které je propojena se svým prototypem, tedy třídou Shape (vlastnost Circle.prototype
obsahuje objekt Shape).
Jestliže vytvoříte instanci třídy Circle jako v následujícím příkladu, zdědí daná instance řetězec prototypu třídy Circle:
// Create an instance of the Circle class.
myCircle = new Circle();
111
Vzpomeňte si, že příklad zahrnoval vlastnost s názvem visible jako člena třídy Shape. V tomto příkladu vlastnost
visible neexistuje jako součást objektu myCircle, ale pouze jako člen objektu Shape. Přesto má ale následující řádek
kódu výsledek true (pravda):
trace(myCircle.visible); // output: true
Běhový modul může zjistit, že objekt myCircle zdědí vlastnost visible, a to procházením řetězce prototypu směrem
vzhůru. Při provádění tohoto kódu se běhový modul nejprve pokusí vyhledat ve vlastnostech objektu myCircle
vlastnost s názvem visible, ale nenalezne ji. Následně se podívá do objektu Circle.prototype, ale ani pak vlastnost
pojmenovanou visible nenalezne. Bude řetězcem procházet dále a nakonec nalezne vlastnost visible definovanou
na objektu Shape.prototype a vyprodukuje hodnotu dané vlastnosti.
V zájmu zachování jednoduchosti je vynechána řada detailů a spletitostí řetězce prototypu. Místo toho je cílem
poskytnout dostatek informací, díky nimž snáze pochopíte objektový model jazyka ActionScript 3.0.
ActionScript 2.0
Jazyk ActionScript 2.0 zavedl nová klíčová slova, například class, extends, public a private, které vám umožnily
definovat třídy způsobem známým všem, kteří pracují s jazyky založenými na třídě, jako jsou Java a C++. Je důležité
pochopit, že výchozí mechanismus dědičnosti se mezi jazyky ActionScript 1.0 a ActionScript 2.0 nezměnil. Jazyk
ActionScript 2.0 pouze přidal novou syntaxi pro definování tříd. Řetězec prototypu funguje v obou verzích jazyka
stejně.
Nová syntaxe zavedená jazykem ActionScript 2.0, zobrazená v následujícím výpise, vám umožňuje definovat třídy
způsobem, který je pro mnoho programátorů intuitivnější.
// base class
class Shape
{
var visible:Boolean = true;
}
Všimněte si, že jazyk ActionScript 2.0 také zavedl typ anotací, které budou použity pro kontrolu času kompilace. To
vám umožní deklarovat, že by vlastnost visible v předchozím příkladě měla obsahovat pouze booleovskou hodnotu.
Nové klíčové slovo extends také zjednodušuje proces vytváření podtřídy. V následujícím příkladě je proces se dvěma
kroky v jazyce ActionScript 1.0 dokončen jedním krokem, a to pomocí klíčového slova extends:
// child class
class Circle extends Shape
{
var id:Number;
var radius:Number;
function Circle(id, radius)
{
this.id = id;
this.radius = radius;
}
}
Konstruktor je nyní deklarován jako část definice třídy a vlastnosti třídy id a radius musí být také explicitně
deklarovány.
Jazyk ActionScript 2.0 také přidal podporu pro definici rozhraní, která vám umožňuje dále předefinovat své programy
orientované na objekt s formálně definovanými protokoly pro komunikaci mezi objekty.
112
Objekt třídy v jazyce ActionScript 3.0
Běžné paradigma programování orientované na objekt, které je nejčastěji spojené s jazyky Java a C++, používá třídy
pro definici tříd objektů. Programovací jazyky, které přijímají toto paradigma, také často používají třídy pro
konstrukci instancí typu dat, které třída definuje. Jazyk ActionScript používá třídy pro oba tyto způsoby, ale jeho
základ jazyka založeného na prototypu přidává další zajímavé vlastnosti. Jazyk ActionScript vytváří pro každou
definici třídy zvláštní objekt třídy, která umožňuje sdílení chování i stavu. Pro mnoho programátorů jazyka
ActionScript nicméně tento rozdíl nemusí mít žádné praktické implikace pro kód. Jazyk ActionScript 3.0 je navržen
tak, že vytváříte sofistikované aplikace jazyka ActionScript orientované na objekt bez použití, nebo dokonce
pochopení, těchto zvláštních objektů tříd.
Následující diagram ukazuje strukturu objektu třídy, který představuje jednoduchou třídu pojmenovanou A
definovanou pomocí příkazu class A {}:
Class.prototype
T
Object.prototype
CA
delegát
typ
C
delegát
prototyp
konstruktor
A
vlastnost
P
A
T
A
Každý obdélník v diagramu představuje objekt. Každý objekt v daném diagramu má charakter dolního indexu A, který
představuje to, že náleží do třídy A. Objekt třídy (CA) obsahuje odkazy na několik jiných důležitých objektů. Objekt
vlastnosti instance (TA) uchovává vlastnosti instance, které jsou definovány v rámci definice třídy. Objekt vlastnosti
třídy (TCA) představuje interní typ třídy a uchovává statické vlastnosti definované danou třídou (znak dolního indexu
C znamená „class” - třída). Objekt prototypu (PA) vždy znamená objekt třídy, ke kterému byl původně připojen
pomocí vlastnosti constructor.
Objekt vlastnosti
Objekt vlastnosti, který je v jazyce ActionScript 3.0 nový, byl implementován s ohledem na výkon. V předcházejících
verzích jazyka ActionScript mohlo být vyhledání názvu, kdy přehrávač Flash Player prochází řetězec prototypu, časově
náročným procesem. V jazyce ActionScript 3.0 je vyhledání názvu daleko účinnější a méně časově náročné, protože
zděděné vlastnosti jsou kopírovány z nadřazených tříd do objektů vlastností podtříd.
Objekt vlastnosti není přímo dostupný kódem programátora, ale jeho přítomnost zaznamenáte díky lepšímu výkonu
a využití paměti. Objekty vlastností poskytují AVM2 detailní informace o rozvržení a obsahu třídy. Díky této znalosti
může AVM2 výrazně zkrátit dobu provedení, protože může často vygenerovat přímé pokyny zařízení pro přístup k
vlastnostem nebo může vyvolat metody přímo bez časově náročného vyhledávání názvu.
Díky objektu vlastností může být otisk paměti objektu výrazně menší než podobný objekt v předchozích verzích jazyka
ActionScript. Jestliže je například třída zapečetěna (tj. třída není deklarovaná jako dynamická), instance třídy
nepotřebuje tabulku rušení pro dynamicky přidané vlastnosti a může přestavovat pouze ukazovátko na objekty
vlastností a některé bloky pro pevné vlastnosti definované ve třídě. Následkem toho by objekt, který vyžaduje 100 bytů
paměti v jazyce ActionScript 2.0, mohl vyžadovat pouze 20 bytů paměti v jazyce ActionScript 3.0.
113
Poznámka: Objekt vlastnosti je interním detailem implementace a neexistuje žádná záruka, že se nezmění nebo dokonce
v příštích verzích jazyka ActionScript nezmizí.
Objekt prototypu
Každý objekt třídy jazyka ActionScript má vlastnost pojmenovanou prototype, která je odkazem na objekt prototypu
třídy. Objekt prototypu je odkazem kořenů jazyka ActionScript jako jazyka založeného na prototypu. Pro více
informací viz Historie podpory jazyka ActionScript objektově orientovaného programování.
Vlastnost prototype je určena pouze ke čtení, což znamená, že nemůže být upravena a odkazovat tak na různé
objekty. To se liší od vlastnosti třídy prototype v předchozích verzích jazyka ActionScript, kdy může být prototyp
znovu přiřazen tak, aby odkazoval na odlišnou třídu. Ačkoliv je vlastnost prototype určena pouze ke čtení, objekt
prototypu, na který odkazuje, není. Jiným slovy, k objektu prototypu lze přidat nové vlastnosti. Vlastnosti přidané k
objektu prototypu jsou sdíleny mezi všemi instancemi dané třídy.
Řetězec prototypu, který byl jediným mechanismem dědičnosti v předchozích verzích jazyka ActionScript, slouží v
jazyce ActionScript 3.0 pouze jako sekundární úloha. Primární mechanismus dědičnosti, dědičnost pevné vlastnosti,
je zpracována interně objektem vlastnosti. Pevná vlastnost je proměnná nebo metoda definovaná jako část definice
třídy. Dědičnost pevné vlastnosti se také nazývá dědičnost třídy, protože se jedná o mechanismus dědičnosti, který je
spojen s klíčovými slovy jako class, extends a override.
Řetězec prototypu poskytuje alternativní mechanismus dědičnosti, který je dynamičtější než dědičnost pevné
vlastnosti. Vlastnosti k objektu prototypu třídy můžete přidat nejen jako součást definice třídy, ale také v čase
zpracování prostřednictvím třídy vlastnosti prototype objektu. Nicméně si všimněte, že jestliže nastavíte kompilátor
na přísný režim, nemusíte mít přístup k vlastnostem přidaným k objektu prototypu, pokud nedeklarujete třídu s
klíčovým slovem dynamic.
Dobrým příkladem třídy s několika vlastnostmi připojené k objektu prototypu je třída Objekt. Metody třídy objektu
toString() a valueOf() jsou vlastně funkce přiřazené k vlastnostem objektu prototypu třídy Object. Následující
příklad ukazuje, jak by mohla deklarace těchto metod teoreticky vypadat (skutečná implementace se mírně liší z
důvodů detailů implementace).
public dynamic class Object
{
prototype.toString = function()
{
// statements
};
prototype.valueOf = function()
{
// statements
};
}
Jak již bylo zmíněno dříve, můžete připojit vlastnost k objektu prototypu třídy mimo definici třídy. Například metodu
toString() lze také definovat mimo definici třídy Object, a to následovně:
Object.prototype.toString = function()
{
// statements
};
114
Narozdíl od dědičnosti pevné vlastnosti dědičnost prototypu nevyžaduje klíčové slovo override, jestliže si přejete
znovu definovat metodu v podtřídě. Například. Jestliže si přejte znovu definovat metodu valueOf() v podtřídě třídy
Object, máte tři možnosti. Zaprvé definujete metodu valueOf() na objektu prototypu dílčí třídy uvnitř definice třídy.
Následující kód vytvoří podtřídu objektu pojmenovanou Foo a znovu definuje metodu valueOf() na objektu
prototypu Foo jako část definice třídy. Protože každá třída dědí ze třídy Object, není třeba použít klíčové slovo
extends.
dynamic class Foo
{
prototype.valueOf = function()
{
return "Instance of Foo";
};
}
Za druhé můžete definovat metodu valueOf() na objektu prototypu Foo mimo definici třídy, dle příkladu v
následujícím kódu:
Foo.prototype.valueOf = function()
{
};
Za třetí můžete definovat pevnou vlastnost pojmenovanou valueOf() jako část třídy Foo. Tato technika se liší od
jiných tím, že kombinuje dědičnost pevné vlastnosti s dědičností prototypu. Jakákoliv podtřída Foo, která chce znovu
definovat valueOf(), musí použít klíčové slovo override. Následující kód ukazuje valueOf() definovanou jako
pevnou vlastnost v Foo:
class Foo
{
function valueOf():String
{
}
}
Obor názvů AS3
Existence dvou oddělených mechanismů dědičnosti, dědičnosti pevné vlastnosti a dědičnosti prototypu, vytváří
zajímavou otázku kompatibility s ohledem na vlastnosti a metody tříd jádra. Slučitelnost se specifikací jazyka výkresů
ECMAScript, na kterých je jazyk ActionScript založen vyžaduje použití dědičnosti prototypu, což znamená, že
vlastnosti a metody třídy jádra jsou definovány na objektu prototypu dané třídy. Na druhou stranu slučitelnost s
jazykem ActionScript 3.0 vyžaduje použití dědičnosti pevné vlastnosti, což znamená, že vlastnosti a metody třídy jádra
jsou definovány v definici třídy pomocí klíčových slov const, var a function. Navíc použití pevných vlastností
namísto verzí prototypů může vést k významnému nárůstu výkonu během zpracovávání.
Jazyk ActionScript 3.0 tento problém řeší použitím jak dědičnosti prototypu, tak dědičnosti pevné vlastnosti pro třídy
jádra. Každá třída jádra obsahuje dvě množiny vlastností a metod. Jedna množina je definována na objektu prototypu
pro slučitelnost se specifikací ECMAScript a druhá je definována pomocí pevných vlastností a jmenného prostoru
AS3,0 pro slučitelnost s jazykem ActionScript 3.0.
Jmenný prostor AS3 poskytuje výhodný mechanismus pro volbu mezi těmito dvěma množinami vlastností a metod.
Jestliže nepoužíváte jmenný prostor AS3, instance třídy jádra dědí vlastnosti a metody definované na objektu
prototypu třídy jádra. Jestliže se rozhodnete použít jmenný prostor AS3, instance třídy jádra dědí verze AS3, protože
jsou pevné vlastnosti vždy upřednostněny před vlastnostmi prototypu. Jinými slovy, kdykoliv je dostupná pevná
vlastnost, je vždy použita namísto stejně pojmenované vlastnosti prototypu.
115
Můžete selektivně použít verzi jmenného prostoru AS3 vlastnosti nebo metody, a to její kvalifikací s jmenným
prostorem AS3. Například následující kód používá verzi AS3 metody Array.pop():
var nums:Array = new Array(1, 2, 3);
nums.AS3::pop();
trace(nums); // output: 1,2
Můžete také použít příkaz use namespace a otevřít tak jmenný prostor AS3 pro všechny definice v rámci bloku kódu.
Například následující kód používá příkaz use namespace pro otevření jmenného prostoru AS3 pro metodu pop() i
pro metodu push():
use namespace AS3;
var nums:Array = new Array(1, 2, 3);
nums.pop();
nums.push(5);
trace(nums) // output: 1,2,5
Jazyk ActionScript 3.0 také poskytuje volby kompilátoru pro každou sadu vlastností, takže jmenný prostor AS3 můžete
použít na celý váš program. Volba kompilátoru -as3 představuje jmenný prostor AS3 a volba -es představuje volbu
dědičnosti prototypu (es znamená ECMAScript). Pro otevření jmenného prostoru AS3 pro celý váš program nastavte
volbu kompilátoru -as3 na hodnotu true (pravda) a volbu -es na hodnotu false (nepravda). Pro použití verzí
prototypu nastavte volby kompilátoru na opačné hodnoty. Výchozí nastavení kompilátoru pro aplikace Flex Builder
a Flash Professional jsou -as3 = true (pravda) a -es = false (nepravda).
Jestliže si přejete rozšířit jakoukoliv z tříd jádra a potlačit nějakou metodu, měli byste chápat, jak může jmenný prostor
AS3 ovlivnit způsob deklarace potlačené metody. Jestliže používáte jmenný prostor AS3, jakékoliv metoda potlačení
metody třídy jádra musí také používat jmenný prostor AS3, společně s atributem override. Jestliže jmenný prostor
AS3 nepoužíváte a přejete si znovu definovat metodu třídy jádra v podtřídě, neměli byste používat jmenný prostor AS3
ani klíčové slovo override.
Příklad: GeometricShapes
Vzorová aplikace GeometricShapes ukazuje, jak lze pomocí jazyka ActionScript 3.0 použít několik konceptů a funkcí
orientovaných na objekt, a to včetně:
• Definování tříd
• Rozšiřování tříd
• Polymorfismus a klíčové slovo override
• Definování, rozšiřování a implementace rozhraní
Zahrnuje také „metodu rodiny”, která vytváří instanci třídy a ukazuje, jak deklarovat hodnotu vrácení jako instanci
rozhraní a použít daný vrácený objekt obecným způsobem.
Aplikační soubory pro tuto ukázku najdete na adrese www.adobe.com/go/learn_programmingAS3samples_flash_cz.
Soubory aplikace GeometricShapes naleznete ve složce Samples/GeometricShapes. Aplikace sestává z následujících
souborů:
116
Třída File
Popis
GeometricShapes.mxml
Hlavní soubor aplikace v programu Flash (FLA)
nebo Flex (MXML).
nebo
GeometricShapes.fla
com/example/programmingas3/geometricshapes/IGeometricShape.as
Základní metody definující rozhraní budou
implementovány všemi třídami aplikace
GeometricShapes.
com/example/programmingas3/geometricshapes/IPolygon.as
Metody definující rozhraní budou
implementovány třídami aplikace
GeometricShapes, které mají více stran.
com/example/programmingas3/geometricshapes/RegularPolygon.as
Typ geometrického tvaru, jehož strany mají
stejnou délku a jsou rozloženy symetricky kolem
středu tvaru.
com/example/programmingas3/geometricshapes/Circle.as
Typ geometrického tvaru, který definuje kruh.
com/example/programmingas3/geometricshapes/EquilateralTriangle.as
Podtřída RegularPolygon, která definuje
trojúhelník, jehož strany mají stejné délky.
com/example/programmingas3/geometricshapes/Square.as
Podtřída RegularPolygon definující obdélník,
jehož všechny strany jsou stejně dlouhé.
com/example/programmingas3/geometricshapes/GeometricShapeFactory.as
Třída obsahující metodu rodiny pro vytvoření
tvarů s daným typem tvaru a velikostí.
Definice tříd GeometricShapes
Aplikace GeometricShapes umožňuje uživateli specifikovat typ geometrického tvaru a jeho velikost. Tvar poté reaguje
s popisem tvaru, jeho oblasti a vzdálenosti okolo jeho obvodu.
Uživatelské rozhraní aplikace je triviální, včetně několika kontrol pro výběr typu tvaru, nastavení velikosti a zobrazení
popisu. Nejzajímavější část této aplikace je pod povrchem, ve struktuře tříd a samotných rozhraní.
Tato aplikace se zabývá geometrickými tvary, ale nezobrazuje je graficky.
Třídy a rozhraní, které definují geometrické tvary v tomto příkladě, jsou ukázány v následujícím diagramu pomocí
poznámky v jednotném modelovacím jazyce (UML):
117
<< rozhraní >>
IGeometricShape
+getArea (): Number
+describe (): Strin
Circle
+diameter:Number
+Circle () : Circle
+getArea () : Number
+describe () : String
+getCircumference () : Number
<< rozhraní >>
IPolygon
+getPerimeter (): Number
+getSumOfAngles (): Number
RegularPolygon
+numSides : int
+sideLength : Number
+RegularPolygon (): RegularPolygon
+getSumOfAngles (): Number
+getPerimeter (): Number
+getArea (): Number
+describe (): String
Square
EquilateralTriangle
+EquilateralTriangle (): EquilateralTriangle
+getArea (): Number
+Square (): Square
+getArea (): Number
Třídy příkladu GeometricShapes
Definice běžného chování s rozhraními
Tato aplikace GeometricShapes se zabývá třemi typy tvarů: kruhy, čtverci a rovnostrannými trojúhelníky. Struktura
třídy GeometricShapes začíná s velice jednoduchým rozhraním, IGeometricShape, které uvádí metody běžné pro
všechny tři typy tvarů:
package com.example.programmingas3.geometricshapes
{
public interface IGeometricShape
{
function getArea():Number;
function describe():String;
}
}
Rozhraní definuje dvě metody: metodu getArea(), která vypočítává a vrací oblast tvaru a metodu describe(), která
sestavuje textový popis vlastností tvaru.
Také je vhodné znát vzdálenost kolem obvodu každého tvaru. Obvod kruhu je vypočten jedinečným způsobem, takže
se chování liší od chování trojúhelníku nebo čtverce. Přesto mezi trojúhelníky, čtverci a jinými mnohoúhelníky
existuje dostatečná podobnost a je tedy dobré definovat novou třídu rozhraní pouze pro ně: IPolygon. Rozhraní
IPolygon je, jak je ukázáno níže, také spíše jednoduché:
{
public interface IPolygon extends IGeometricShape
{
function getPerimeter():Number;
function getSumOfAngles():Number;
}
}
118
Toto rozhraní definuje dvě metody společné pro všechny mnohoúhelníky: metodu getPerimeter(), která měří
kombinovanou vzdálenost všech stran a metodu getSumOfAngles(), která sčítá všechny vnitřní úhly.
Rozhraní IPolygon rozšiřuje rozhraní IGeometricShape, což znamená, že jakákoliv třída, která implementuje rozhraní
IPolygon, musí deklarovat všechny čtyři metody - dvě z rozhraní IGeometricShape a dvě z rozhraní IPolygon.
Definice tříd tvaru
Jakmile pochopíte metody společné pro každý typ tvaru, můžete definovat samotné třídy tvarů. Co se týče počtu
metod, které potřebujete implementovat, je nejjednodušší třídou třída Circle:
{
public class Circle implements IGeometricShape
{
public var diameter:Number;
public function Circle(diam:Number = 100):void
{
this.diameter = diam;
}
public function getArea():Number
{
// The formula is Pi * radius * radius.
var radius:Number = diameter / 2;
return Math.PI * radius * radius;
}
public function getCircumference():Number
{
// The formula is Pi * diameter.
return Math.PI * diameter;
}
public function describe():String
{
var desc:String = "This shape is a Circle.\n";
desc += "Its diameter is " + diameter + " pixels.\n";
desc += "Its area is " + getArea() + ".\n";
desc += "Its circumference is " + getCircumference() + ".\n";
return desc;
}
}
}
Třída Circle implementuje rozhraní IGeometricShape, takže musí poskytnout kód pro metodu getArea() i metodu
describe(). Dále definuje metodu getCircumference(), která je jedinečná pro třídu Circle. Třída Circle také
deklaruje vlastnost diameter, kterou lze najít v jiných třídách mnohoúhelníků.
Druhé dva typy tvarů, čtverce a jednostranné trojúhelníky, mají společné i jiné věci: oba mají stejně dlouhé strany a
existují společné vzorce, které můžete použít pro výpočet obvodu a součtu vnitřních úhlů obou tvarů. Tyto společné
vzorce defacto platí pro jakékoliv jiné pravidelné mnohoúhelníky, jež budou definovány i v budoucnosti.
119
Třída RegularPolygon je nadřazenou třídou pro třídu Square i třídu EquilateralTriangle. Nadřazená třída vám
umožňuje definovat běžné metody na stejném místě, takže je nemusíte definovat zvlášť v každé podtřídě. Zde je kód
pro třídu RegularPolygon:
{
public class RegularPolygon implements IPolygon
{
public var numSides:int;
public var sideLength:Number;
public function RegularPolygon(len:Number = 100, sides:int = 3):void
{
this.sideLength = len;
this.numSides = sides;
}
public function getArea():Number
{
// This method should be overridden in subclasses.
return 0;
}
public function getPerimeter():Number
{
return sideLength * numSides;
}
public function getSumOfAngles():Number
{
if (numSides >= 3)
{
return ((numSides - 2) * 180);
}
else
{
return 0;
}
}
public function describe():String
{
var desc:String = "Each side is " + sideLength + " pixels long.\n";
desc += "Its area is " + getArea() + " pixels square.\n";
desc += "Its perimeter is " + getPerimeter() + " pixels long.\n";
desc += "The sum of all interior angles in this shape is " + getSumOfAngles() + "
degrees.\n";
return desc;
}
}
}
Nejprve třída RegularPolygon deklaruje dvě vlastnosti, které jsou společné pro všechny pravidelné mnohoúhelníky:
délka každé strany (vlastnost sideLength) a počet stran (vlastnost numSides).
Třída RegularPolygon implementuje rozhraní IPolygon a deklaruje všechny čtyři metody rozhraní IPolygon. Tato
třída implementuje dvě z nich - metodu getPerimeter() a metodu getSumOfAngles() - pomocí společných vzorců.
120
Protože se vzorec pro metodu getArea() liší tvar od tvaru, nemůže verze metody základní třídy zahrnovat společnou
logiku, která může být zděděna metodami podtřídy. Místo toho jednoduše vrátí výchozí hodnotu 0 udávající, že daná
oblast nebyla vypočtena. Pro správný výpočet oblasti každého tvaru musí podtřídy třídy RegularPolygon potlačit
samotnou metodu getArea().
Následující kód pro třídu EquilateralTriangle ukazuje, jak je metoda getArea() potlačena:
{
public class EquilateralTriangle extends RegularPolygon
{
public function EquilateralTriangle(len:Number = 100):void
{
super(len, 3);
}
public override function getArea():Number
{
// The formula is ((sideLength squared) * (square root of 3)) / 4.
return ( (this.sideLength * this.sideLength) * Math.sqrt(3) ) / 4;
}
public override function describe():String
{
/* starts with the name of the shape, then delegates the rest
of the description work to the RegularPolygon superclass */
var desc:String = "This shape is an equilateral Triangle.\n";
desc += super.describe();
return desc;
}
}
}
Klíčové slovo override udává, že metoda EquilateralTriangle.getArea() záměrně potlačí metodu getArea()
z nadřazené třídy RegularPolygon. Při vyvolání metoda EquilateralTriangle.getArea() vypočte oblast pomocí
vzorce v předcházejícím kódu a kód v metodě RegularPolygon.getArea() nebude nikdy proveden.
Naopak třída EquilateralTriangle nedefinuje svou vlastní verzi metody getPerimeter(). Při vyvolání metody
EquilateralTriangle.getPerimeter() prochází volání řetězcem dědičnosti a provede kód v metodě
getPerimeter() nadřazené třídy RegularPolygon.
Konstruktor EquilateralTriangle() používá příkaz super() pro explicitní vyvolání konstruktoru
RegularPolygon() ze své nadřazené třídy. Pokud by konstruktory měly stejnou množinu parametrů, mohli byste
úplně vypustit konstruktor EquilateralTriangle() a konstruktor RegularPolygon() by byl proveden místo něj.
Nicméně konstruktor RegularPolygon() potřebuje parametr navíc, numSides. Proto konstruktor
EquilateralTriangle() vyvolá metodu super(len, 3), která projde podél vstupního parametru len a hodnoty 3,
která určuje, že daný trojúhelník bude mít 3 strany.
Metoda describe() rovněž používá příkaz super(), avšak odlišným způsobem. Používá jej k vyvolání verze metody
describe() nadřazené třídy RegularPolygon. Metoda EquilateralTriangle.describe() nejprve nastaví
proměnnou řetězce desc pro příkaz ohledně typu tvaru. Poté získá výsledky metody RegularPolygon.describe()
vyvoláním super.describe()a připíše výsledek k řetězci desc.
Třídu Square zde není popsána podrobně, je však podobná třídě EquilateralTriangle a poskytuje konstruktor a své
vlastní implementace metod getArea() a describe().
121
Polymorfismus a metoda rodiny
Množina třídy, která využívá rozhraní a dědičnost, může být použita mnoha zajímavými způsoby. Například všechny
zatím popsané třídy tvaru buď implementují rozhraní IGeometricShape nebo rozšiřují nadřazenou třídu, která
provádí implementaci. Takže pokud definujete proměnou jako instanci třídy IGeometricShape, nemusíte vědět, zda
se vlastně jedná o instanci třídy Circle nebo Square, aby došlo k vyvolání její metody describe().
Následující kód ukazuje způsob funkce:
var myShape:IGeometricShape = new Circle(100);
trace(myShape.describe());
Při vyvolání myShape.describe() dojde k provedení metody Circle.describe(), protože ačkoliv je proměnná
definována jako instance rozhraní IGeometricShape, třída Circle je její základní třídou.
Tento příklad ukazuje princip polymorfismu v akci: přesně to samé volání metody bude mít za následek provedení
různého kódu, a to v závislosti na třídě objektu, jehož metoda je vyvolávána.
Aplikace GeometricShapes použije tento typ polymorfismu založeného na rozhraní pomocí zjednodušené verze
designového vzoru známé jako metoda rodiny. Pojem produkční metoda označuje funkci, která vrací objekt, jehož
základní typ dat nebo obsah se může lišit v závislosti na kontextu.
Zde uvedená třída GeometricShapeFactory definuje metodu rodiny pojmenovanou createShape():
{
public class GeometricShapeFactory
{
public static var currentShape:IGeometricShape;
public static function createShape(shapeName:String,
len:Number):IGeometricShape
{
switch (shapeName)
{
case "Triangle":
return new EquilateralTriangle(len);
case "Square":
return new Square(len);
case "Circle":
return new Circle(len);
}
return null;
}
public static function describeShape(shapeType:String, shapeSize:Number):String
{
GeometricShapeFactory.currentShape =
GeometricShapeFactory.createShape(shapeType, shapeSize);
return GeometricShapeFactory.currentShape.describe();
}
}
}
122
Metoda rodiny createShape() umožňuje konstruktorům podtřídy tvaru definovat podrobnosti instancí, které
vytvářejí, zatímco vracejí nové objekty jako instance IGeometricShape, takže je aplikace může zpracovat obecnějším
způsobem.
Metoda describeShape() v předcházejícím příkladě ukazuje, jak může aplikace použít metodu rodiny pro získání
obecné reference ke specifičtějšímu objektu. Aplikace může získat popis pro nově vytvořený objekt Circle takto:
GeometricShapeFactory.describeShape("Circle", 100);
Metoda describeShape() poté vyvolá metodu rodiny createShape() se stejnými parametry a uchová nový objekt
kruhu ve statické proměnné pojmenované currentShape, která je typem objektu IGeometricShape. Poté je vyvolána
metoda describe() na objektu currentShape a dané volání je automaticky vyřešeno pro provedení metody
Circle.describe(), která bude mít za následek podrobný popis kruhu.
Vylepšení vzorové aplikace
Skutečná váha rozhraní a dědičnosti bude zřejmá, jakmile vylepšíte nebo změníte svou aplikaci.
Řekněme, že k této vzorové aplikaci chcete přidat nový tvar, pětiúhelník. Vytvořili byste novou třídu Pentagon, která
rozšiřuje třídu RegularPolygon a definuje své vlastní verze metod getArea() a describe(). Poté byste přidali novou
volbu pětiúhelníku do vstupního pole v uživatelském rozhraní aplikace. Ale to je vše. Třída Pentagon by automaticky
získala funkce metody getPerimeter() a metody getSumOfAngles() z třídy RegularPolygon prostřednictvím
dědičnosti. Protože dědí ze třídy, která implementuje rozhraní IGeometricShape, může být s instancí Pentagon
zacházeno také jako s instancí IGeometricShape. To znamená, že pro přidání nového typu tvaru nepotřebujete změnit
metodu podpisu žádné z metod ve třídě GeometricShapeFactory (a následně také nemusíte změnit žádný z kódů, která
třída GeometricShapeFactory používá).
Můžete si přát přidat třídu Pentagon k příkladu geometrických tvarů jako cvičení a zjistit tak, jak mohou rozhraní a
dědičnost ulehčit pracovní zatížení přidání nových funkcí do aplikace.

Zobrazit nápovědu v souboru

Transkript

Podobné dokumenty

Sborník příspěvků

Stáhnout PDF s nápovědou( 10MB)

ladění player6

Zobrazit nápovědu v souboru

Používání programu Adobe® Flash® CS4 Professional

Yahoo! Maps

Používání aplikace Flash Professional

Používání aplikace Adobe® Flash® Professional CS5

Vlastimil Vávrů

příručka uživatele