Programmez en Actionscript 3

Sauf mention contraire, le contenu de cet ouvrage est publi sous la licence :
Creative Commons BY-NC-SA 2.0

La copie de cet ouvrage est autorise sous rserve du respect des conditions de la licence.
Texte complet de la licence disponible sur : http : //creativecommons.org/licenses/by-nc-sa/2.0/fr/
Mentions lgales
Conception couverture : amalgam impression
Illustrations chapitres : Fan Jiyong et Alexandra Persil
OpenClassrooms 2014 - ISBN : 979-10-90085-64-0
Avant-propos
i vous lisez ces lignes, cest que vous avez trs certainement envie dapprendre
programmer en Actionscript 3. Il sagit du langage de programmation de prdilection pour concevoir des applications Adobe Flash, applications notamment
trs rpandues sur Internet, sous forme de jeux interactifs, de lecteurs de vidos, de
bannires publicitaires. . .
Contrairement aux ides prconues, lActionscript ne se cantonne pas uniquement

la ralisation de vulgaires animations. Il est possible de concevoir des applications
en ligne visuellement trs avances ou de vrais logiciels de bureau laide de Flash.
Larrive de Adobe Air et Flex a galement normment contribu au dploiement de la
technologie Flash vers de nouvelles plateformes, telles que les terminaux mobiles iOS,
Android ou BlackBerry. Initialement, Flash a t conu pour raliser des animations
vectorielles, au travers du logiciel Flash Professional dit par la socit Adobe. Depuis
la version 3, lActionscript est devenu un langage de programmation part entire,
et il est maintenant possible de concevoir des applications Flash sans avoir recours
ce logiciel. Cet ouvrage sintresse justement lapprentissage de ce langage, en utilisant essentiellement des outils gratuits et accessibles tous. Certains dentre vous se
demandent peut-tre si lActionscript est un bon choix pour commencer la programmation ? Grce sa documentation fournie et ses concepts haut niveau, ce langage
de programmation est tout fait accessible aux dbutants. De plus, les possibilits
quoffre ce langage sont vastes, et le rendu des applications intresseront coup sr les
dveloppeurs plus expriments. Nhsitez donc pas vous lancer ds maintenant la
dcouverte de ce merveilleux langage quest lActionscript 3 !
Quallez-vous apprendre en lisant ce livre ?

Le plan de ce livre a t pens en partant du principe que le lecteur est un parfait
novice en programmation : ce cours se veut progressif et accessible tous. Voici les
diffrentes parties qui vous attendent dans cet ouvrage.
1. Les bases de lActionscript : cette premire partie est une introduction la
programmation et au langage Actionscript 3. Nous verrons ce quest rellement
lActionscript 3 et quels sont les outils indispensables pour suivre ce cours. Une
fois ces derniers en place, nous commencerons tudier les fondamentaux de la
i
CHAPITRE 0. AVANT-PROPOS
programmation : les variables, les conditions, les boucles, les fonctions...
2. La programmation oriente objet : au cours de cette partie, nous aborderons
un concept incontournable en Actionscript 3, la programmation oriente objet.
Il sagit dune manire de concevoir et de structurer le code au sein dun projet.
En organisant les programmes sous forme dobjets, le dveloppement de logiciels
devient plus efficace et intuitif. Nous aborderons les notions de classes, dhritage, de polymorphisme, dinterfaces... Un chapitre sur des notions avances la
programmation oriente objet en fin de partie vous permettra dapprofondir vos
connaissances.
3. Laffichage : tout au long de cette partie, nous dcouvrirons comment raliser
du contenu visuel, qui a fait toute la rputation des applications Flash. Nous
verrons notamment comment utiliser du texte et des images, mais surtout, nous
apprendrons dessiner des graphismes vectoriels directement partir du langage
de programmation. Un TP vous attend en fin de partie, et vous permettra de
vous exercer.
4. Interaction et animation : animer le contenu et le rendre interactif nest pas
chose aise. Nanmoins avec de prcieux conseils et quelques astuces, vous parviendrez crer les applications dynamiques et attrayantes. Pour vous le prouver,
nous raliserons travers un TP un vritable jeu de billard amricain. Vous prendrez alors conscience que vous avez dj atteint un excellent niveau !
5. Annexes : avant de vous laissez explorer de nouveaux horizons par vous-mmes,
nous reviendrons dans cette partie sur quelques rgles et astuces de bonnes pratiques adopter.
Comment lire ce livre ?

Suivez lordre des chapitres
Lisez ce livre comme on lit un roman. Il a t conu pour cela.
Contrairement beaucoup de livres techniques o il est courant de lire en diagonale et
de sauter certains chapitres, il est ici trs fortement recommand de suivre lordre du
cours, moins que vous ne soyez dj un peu expriments.
Pratiquez en mme temps

Pratiquez rgulirement lActionscript 3. Nattendez pas davoir fini la lecture de ce
livre pour allumer votre ordinateur et faire vos propres essais ; nhsitez pas modifier les codes donns en exemples, afin de bien cerner le comportement de chaque
instruction. Plus vous vous exercerez, et plus lapprentissage sera rapide et efficace.
ii
REMERCIEMENTS
Utilisez les codes web !

Afin de tirer parti dOpenClassrooms, dont ce livre est issu, celui-ci vous propose ce
quon appelle des codes web . Ce sont des codes six chiffres saisir sur une page
dOpenClassrooms pour tre automatiquement redirig vers un site web sans avoir
en recopier ladresse.
Pour utiliser les codes web, rendez-vous sur la page suivante :
http://www.openclassrooms.com/codeweb
Un formulaire vous invite rentrer votre code web. Faites un premier essai avec le code
ci-dessous :

Tester le code web
B
Code web : 123456

Ces codes web ont deux intrts :
ils vous redirigent vers les sites web prsents tout au long du cours, vous permettant
ainsi dobtenir les logiciels dans leur toute dernire version ;
ils vous permettent dafficher les codes sources inclus dans ce livre, ce qui vous vitera
davoir recopier certains programmes un peu longs.
Ce systme de redirection nous permet de tenir jour le livre que vous avez entre les
mains sans que vous ayez besoin dacheter systmatiquement chaque nouvelle dition.
Si un site web change dadresse, nous modifierons la redirection mais le code web
utiliser restera le mme. Si un site web disparat, nous vous redirigerons vers une page
dOpenClassrooms expliquant ce qui sest pass et vous proposant une alternative.
En clair, cest un moyen de nous assurer de la prennit de cet ouvrage sans que vous
ayez faire quoi que ce soit !
Remerciements
Nous tenons remercier toutes les personnes qui nous ont aides et soutenues dans la
ralisation de ce livre.
Guillaume Chau
Je souhaite remercier :
Ma famille et mes proches pour leur soutien et leurs encouragements inestimables,
Guillaume Lapayre pour mavoir soutenu dans le projet, aid rdiger le cours et
motiv aller de lavant,
Jonathan Baudoin pour son suivi et sa relecture minutieuse, ainsi que son engagement
auprs de nous dans le projet,
Mathieu Nebra, Pierre Dubuc et toute lquipe de Simple IT pour avoir cr la
plate-forme OpenClassrooms nous ayant permis dcrire cet ouvrage,
Mais surtout, tous les lecteurs pour leurs questions et leurs encouragements !
iii
CHAPITRE 0. AVANT-PROPOS
Guillaume Lapayre
Je souhaite remercier :
Mes parents, ma famille et mes proches pour leur soutien et leur encouragement,
quel que soit le projet dans lequel je mengage,
Guillaume Chau pour mavoir fait confiance et mavoir permis de travailler ses
cts et contribuer la rdaction de cet ouvrage,
Jonathan Baudoin pour avoir cru en ce projet, pour le temps pass la relecture ce
cours, et pour avoir support nos nombreux coups de flemme,
Mathieu Nebra et Pierre Dubuc, et toute lquipe de Simple IT, sans lesquels cet
ouvrage naurait jamais vu le jour,
Enfin, tous les lecteurs pour leurs encouragements et lintrt quils portent ce
cours.
iv
Table des matires
Avant-propos
Quallez-vous apprendre en lisant ce livre ? . . . . . . . . . . . . . . . . . . . .
Comment lire ce livre ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
ii
Suivez lordre des chapitres . . . . . . . . . . . . . . . . . . . . . . . . .
ii
Pratiquez en mme temps . . . . . . . . . . . . . . . . . . . . . . . . . .
ii
Utilisez les codes web ! . . . . . . . . . . . . . . . . . . . . . . . . . . . .
iii
Remerciements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
iii
Guillaume Chau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
iii
Guillaume Lapayre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
iv
Les bases de lActionscript
1 Vous avez dit Actionscript ?
Adobe Flash
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Prsentation de Flash . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Un peu dhistoire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Les drivs de Flash . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Quelques exemples dutilisation . . . . . . . . . . . . . . . . . . . . . . . . . .
Le dynamisme apport au web par lActionscript . . . . . . . . . . . . .
Cration de sites web orients vers le visuel . . . . . . . . . . . . . . . .
Introduction dAdobe Air . . . . . . . . . . . . . . . . . . . . . . . . . .
LActionscript 3
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
v
TABLE DES MATIRES

Orient objet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
De haut niveau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10
vnementiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10
2 Votre premier programme avec Flex SDK

Prambule . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
12
Le compilateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
12
Le lecteur Flash . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
13
Installation des outils . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
14
Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
14
Flex SDK . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
14
Version de dbogage du lecteur Flash . . . . . . . . . . . . . . . . . . . .
19
Crer les sources . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
21
Compiler le programme de test . . . . . . . . . . . . . . . . . . . . . . .
21
Dis bonjour au monsieur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
23
Structure de notre programme . . . . . . . . . . . . . . . . . . . . . . .
23
Commentez votre code ! . . . . . . . . . . . . . . . . . . . . . . . . . . .
30
Afficher un message dans la console . . . . . . . . . . . . . . . . . . . . .
30
Place au test ! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
32
FlashDevelop la rescousse ! . . . . . . . . . . . . . . . . . . . . . . . . . . .
36
Tlchargement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
36
Installation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
36
Un peu de paramtrage . . . . . . . . . . . . . . . . . . . . . . . . . . .
40
Crons un projet Actionscript . . . . . . . . . . . . . . . . . . . . . . . .
43
Bien utiliser Flashdevelop . . . . . . . . . . . . . . . . . . . . . . . . . .
43
Compiler et tester notre projet . . . . . . . . . . . . . . . . . . . . . . .
47
3 Les variables
vi
11
51
Dclarer et utiliser des variables . . . . . . . . . . . . . . . . . . . . . . . . . .
52
Dclaration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
52
Utiliser les variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
53
Les nombres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
54
Les diffrents types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
54
Oprations sur les nombres . . . . . . . . . . . . . . . . . . . . . . . . .
56
La classe Math . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
58
TABLE DES MATIRES

Les chanes de caractres
. . . . . . . . . . . . . . . . . . . . . . . . . . . . .
60
chappement des caractres spciaux . . . . . . . . . . . . . . . . . . . .
60
Utiliser les variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
61
Concatnation de chanes . . . . . . . . . . . . . . . . . . . . . . . . . .
62
Quelques variables et fonctions utiles . . . . . . . . . . . . . . . . . . . .
62
4 Les conditions
67
criture dune condition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
68
Quest-ce quune condition ? . . . . . . . . . . . . . . . . . . . . . . . . .
68
Les oprateurs relationnels . . . . . . . . . . . . . . . . . . . . . . . . . .
68
Les oprateurs logiques
. . . . . . . . . . . . . . . . . . . . . . . . . . .
70
La priorit des oprateurs . . . . . . . . . . . . . . . . . . . . . . . . . .
71
Linstruction if. . .else . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
72
La structure de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
72
Le type boolen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
74
La structure avec else if . . . . . . . . . . . . . . . . . . . . . . . . . .
75
Linstruction switch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
76
Lutilisation conventionnelle . . . . . . . . . . . . . . . . . . . . . . . . .
76
Une utilisation spcifique lActionscript . . . . . . . . . . . . . . . . .
77
5 Les boucles
79
La boucle while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
80
Le principe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
80
criture en Actionscript . . . . . . . . . . . . . . . . . . . . . . . . . . .
80
La boucle do. . .while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
82
La boucle for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
84
Prsentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
84
6 Les fonctions
87
Concept de fonction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Le principe de fonctionnement
88
. . . . . . . . . . . . . . . . . . . . . . .
88
Prsentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
89
Cration et appel de fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . .
90
Instructions de fonction . . . . . . . . . . . . . . . . . . . . . . . . . . .
90
Expressions de fonction . . . . . . . . . . . . . . . . . . . . . . . . . . .
92
vii
TABLE DES MATIRES

Quelques exemples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
92
Message de bienvenue . . . . . . . . . . . . . . . . . . . . . . . . . . . .
93
Calcul de PGCD . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
93
Calcul dun maximum . . . . . . . . . . . . . . . . . . . . . . . . . . . .
93
7 Les tableaux
97
Le type Array . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
98
Cration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
98
Les lments du tableau . . . . . . . . . . . . . . . . . . . . . . . . . . .
98
Proprits du type Array . . . . . . . . . . . . . . . . . . . . . . . . . .
99
Le type Vector . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100

Dclaration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
Gestion des lments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
Les tableaux multidimensionnels . . . . . . . . . . . . . . . . . . . . . . . . . 102
Le concept . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
Un peu de pratique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
Parcourir un tableau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
La boucle for classique . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
La boucle for...in . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
La boucle for each . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
II
La Programmation Oriente Objet
8 La POO dans tous ses tats
109
111
Les notions-cls . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112

Il tait une fois. . . un objet . . . . . . . . . . . . . . . . . . . . . . . . . 112
LObjet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
La Classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
Un autre exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
Lencapsulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
Lhritage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
Manipuler des objets : les chanes de caractres . . . . . . . . . . . . . . . . . 118
Lhorrible secret du type String . . . . . . . . . . . . . . . . . . . . . . 118
Crer un objet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
viii
TABLE DES MATIRES

Accder aux proprits dun objet . . . . . . . . . . . . . . . . . . . . . 121
Des pointeurs sous le capot . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
Plantons le dcor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
Explications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
9 Les classes (1re partie)
Crer une classe
125
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
La Classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
Construire la classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
Des paramtres facultatifs pour nos mthodes . . . . . . . . . . . . . . . . . . 130
La surcharge de mthodes . . . . . . . . . . . . . . . . . . . . . . . . . . 130
Les paramtres facultatifs . . . . . . . . . . . . . . . . . . . . . . . . . . 131
Encapsulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
Les diffrents droits daccs . . . . . . . . . . . . . . . . . . . . . . . . . 132
Les accesseurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133
Exercice : Crons notre premire classe . . . . . . . . . . . . . . . . . . . . . . 139
Prsentation de la classe . . . . . . . . . . . . . . . . . . . . . . . . . . . 139
criture du code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140
La classe complte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142
10 Les classes (2nde partie)
145
Les lments statiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146

Les variables statiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
Les mthodes statiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
Une nouvelle sorte de variable : la constante ! . . . . . . . . . . . . . . . . 148
Prsentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148
Intrt des constantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
Un objet dans un objet (dans un objet. . .) . . . . . . . . . . . . . . . . . . . . 150
Le problme du ptrole
. . . . . . . . . . . . . . . . . . . . . . . . . . . 150
Une nouvelle classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153

Exercice : Jeu de rle
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157
Prsentation de lexercice . . . . . . . . . . . . . . . . . . . . . . . . . . 157

Solution initiale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158
Une nouvelle classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165
La bonne solution
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169
ix
TABLE DES MATIRES

11 Lhritage
175
La notion dhritage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 176

Construction dun hritage . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177
La porte protected . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178
Construction des sous-classes . . . . . . . . . . . . . . . . . . . . . . . . 178
La substitution dune sous-classe une superclasse . . . . . . . . . . . . 182
Le polymorphisme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183
Les attributs de classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184
Les diffrents droits daccs . . . . . . . . . . . . . . . . . . . . . . . . . 185
Exemple dutilisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185
12 Notions avances de la POO
189
Les classes dynamiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190

Dfinition de la classe de base . . . . . . . . . . . . . . . . . . . . . . . . 190
Dfinition de proprits hors de la classe . . . . . . . . . . . . . . . . . . 191
Les interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192
Problme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192
Utilisation des interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . 193
Plus loin avec les interfaces . . . . . . . . . . . . . . . . . . . . . . . . . 198
Les classes abstraites . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200
Le concept . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200
Application lActionScript 3 . . . . . . . . . . . . . . . . . . . . . . . . 201
Les types inconnus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203
Dterminer si un objet est une occurrence dune certaine classe . . . . . 203
Des paramtres de type inconnu
. . . . . . . . . . . . . . . . . . . . . . 204
Accder dynamiquement aux proprits . . . . . . . . . . . . . . . . . . . . . 206

Les objets anonymes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209
Crer un objet anonyme . . . . . . . . . . . . . . . . . . . . . . . . . . . 209
Les fonctions anonymes . . . . . . . . . . . . . . . . . . . . . . . . . . . 214
III
Laffichage
215
13 Les objets daffichage
217
Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218
x
TABLE DES MATIRES

Les couleurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218
Laffichage sur un cran . . . . . . . . . . . . . . . . . . . . . . . . . . . 221
Larbre des objets daffichage . . . . . . . . . . . . . . . . . . . . . . . . . . . 223
Larbre daffichage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223
Les classes daffichage . . . . . . . . . . . . . . . . . . . . . . . . . . . . 225
Manipuler les conteneurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 228
Buvez du Sprite ! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229
Ajouter des enfants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229
Afficher un objet sur la scne principale . . . . . . . . . . . . . . . . . . 230
Lindex daffichage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233
Ajouter un enfant un index prcis
. . . . . . . . . . . . . . . . . . . . 234
Oprations sur les enfants . . . . . . . . . . . . . . . . . . . . . . . . . . 235

Retirer des enfants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 237
Proprits utiles des objets daffichage . . . . . . . . . . . . . . . . . . . . . . 238
Position . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 238
Un mot sur lorigine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239
Taille . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 242
Rotation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 243
Transparence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244
Supprimer un objet daffichage de la mmoire . . . . . . . . . . . . . . . . . . 245
14 Afficher du texte
249
Une histoire de TextField . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 250

La classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 250
Utilisation de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 251
Slection du texte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 256
Centrer le champ de texte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 258
Un mot sur la scne principale . . . . . . . . . . . . . . . . . . . . . . . 258
Adapter la taille du champ de texte au texte . . . . . . . . . . . . . . . 262
Modifier la position du champ de texte . . . . . . . . . . . . . . . . . . . 264
La mise en forme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 268
Formatons notre champ de texte . . . . . . . . . . . . . . . . . . . . . . 268
Gestion du multi-ligne . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274
En HTML dans le texte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 278
xi
TABLE DES MATIRES

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 278
Balises principales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 280
Balises de mise en forme . . . . . . . . . . . . . . . . . . . . . . . . . . . 285
Les polices de caractres embarques . . . . . . . . . . . . . . . . . . . . . . . 287
Embarquer des polices . . . . . . . . . . . . . . . . . . . . . . . . . . . . 287
Rotation sur soi-mme . . . . . . . . . . . . . . . . . . . . . . . . . . . . 297
15 Dessiner avec lActionscript
303
Lobjet Graphics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 304

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 304
Des contours et des remplissages . . . . . . . . . . . . . . . . . . . . . . 306
Dessinez, cest gagn ! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 308
Les lignes et les courbes . . . . . . . . . . . . . . . . . . . . . . . . . . . 308
Les formes prdfinies . . . . . . . . . . . . . . . . . . . . . . . . . . . . 310
Techniques avances . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 311
Exercice : Dessine-moi un mouton . . . . . . . . . . . . . . . . . . . . . . . . 314
Conception du dessin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 314
Code final . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 321
16 Utilisation des matrices
327
Les matrices ou la classe Matrix . . . . . . . . . . . . . . . . . . . . . . . . . 328

Introduction aux matrices . . . . . . . . . . . . . . . . . . . . . . . . . . 328
Lobjet Matrix . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 330
Cration de dgrads . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 330
Prsentation des dgrads . . . . . . . . . . . . . . . . . . . . . . . . . . 331
Ajouter une matrice de description . . . . . . . . . . . . . . . . . . . . . 332
Exemple : cration dun bouton . . . . . . . . . . . . . . . . . . . . . . . 334
Les transformations matricielles . . . . . . . . . . . . . . . . . . . . . . . . . . 335
Un objet transformer . . . . . . . . . . . . . . . . . . . . . . . . . . . . 335
Cration dune matrice de transformation . . . . . . . . . . . . . . . . . 336
Pour finir avec les matrices . . . . . . . . . . . . . . . . . . . . . . . . . 338
17 Manipuler des images
341
Embarquer des images . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 342

Prparation de limage . . . . . . . . . . . . . . . . . . . . . . . . . . . . 342
xii
TABLE DES MATIRES

Librairie dimages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 342
Afficher des images . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 344
La classe Bitmap . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 344
Redimensionnement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 345
Oprations sur les images . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 349
La classe BitmapData . . . . . . . . . . . . . . . . . . . . . . . . . . . . 349
Crer notre premire image . . . . . . . . . . . . . . . . . . . . . . . . . 351
Dessiner sur des images . . . . . . . . . . . . . . . . . . . . . . . . . . . 351
18 Filtres et modes de fusion
361
Les filtres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362
Cration dun exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362
Ajout de filtres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 363
Application des filtres . . . . . . . . . . . . . . . . . . . . . . . . . . . . 364
Glossaire des filtres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 364
Les filtres de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 364
Correction de couleurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . 368
Convolution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 372
Mappage de dplacement . . . . . . . . . . . . . . . . . . . . . . . . . . 375
Les modes de fusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 376
Dfinition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 376
Mise en place . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 378
Glossaire de modes de fusion . . . . . . . . . . . . . . . . . . . . . . . . . . . 378
Le mode de fusion par dfaut . . . . . . . . . . . . . . . . . . . . . . . . 378
Les fusions de calques . . . . . . . . . . . . . . . . . . . . . . . . . . . . 378
Les fusions de transparence . . . . . . . . . . . . . . . . . . . . . . . . . 384
19 Les masques
387
Un masque. . . qui ne masque pas . . . . . . . . . . . . . . . . . . . . . . . . . 388

Le principe des masques . . . . . . . . . . . . . . . . . . . . . . . . . . . 388
Les masques en Flash . . . . . . . . . . . . . . . . . . . . . . . . . . . . 388
Niveaux de transparence multiples . . . . . . . . . . . . . . . . . . . . . . . . 390
Prsentation du concept . . . . . . . . . . . . . . . . . . . . . . . . . . . 390
Place au code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 391
xiii
TABLE DES MATIRES

Exercice : une lampe torche . . . . . . . . . . . . . . . . . . . . . . . . . . . . 393
Prparation des images . . . . . . . . . . . . . . . . . . . . . . . . . . . . 393
Mise en place du masque . . . . . . . . . . . . . . . . . . . . . . . . . . . 396
Projet final . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 398
20 TP : Mauvais temps
403
Le cahier des charges . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 404

Lobjectif du chapitre . . . . . . . . . . . . . . . . . . . . . . . . . . . . 404
Le travail raliser . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 405
Les images . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 406
La correction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 407
La structure du programme . . . . . . . . . . . . . . . . . . . . . . . . . 407
La classe Flocon . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 408
La classe Neige . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 409
La classe principale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 412
Le code source complet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 414
La classe Flocon . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 414
La classe Neige . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 415
La classe principale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 417
IV
Interaction et animation
21 Les vnements
419
421
Quest ce quun vnement ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . 422

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 422
Un jour au bureau. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 422
Les couteurs en POO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 424
Linterface IEventDispatcher . . . . . . . . . . . . . . . . . . . . . . . 424
La classe EventDispatcher . . . . . . . . . . . . . . . . . . . . . . . . . 425
Mise en place dun couteur . . . . . . . . . . . . . . . . . . . . . . . . . . . . 426
Introduction aux fonctions de rappel . . . . . . . . . . . . . . . . . . . . 426
Crer une fonction dcouteur . . . . . . . . . . . . . . . . . . . . . . . . 428
Grer les couteurs dun objet . . . . . . . . . . . . . . . . . . . . . . . . 429
Le flux dvnements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 430
xiv
TABLE DES MATIRES

Prsentation du concept de flux dvnements . . . . . . . . . . . . . . . 430
Bien comprendre le fonctionnement . . . . . . . . . . . . . . . . . . . . . 433
Lobjet Event . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 435
Prsentation de la classe Event . . . . . . . . . . . . . . . . . . . . . . . 435
Les proprits lis au flux dvnements . . . . . . . . . . . . . . . . . . 436
22 Interagir avec lutilisateur
La souris
439
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 440
Lobjet MouseEvent . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 440

La technique du glisser-dposer . . . . . . . . . . . . . . . . . . . . . 446
Exercice : Crer et animer un viseur . . . . . . . . . . . . . . . . . . . . 447
Curseurs personnaliss . . . . . . . . . . . . . . . . . . . . . . . . . . . . 449
Le clavier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 455
Lobjet KeyboardEvent . . . . . . . . . . . . . . . . . . . . . . . . . . . 455
Exercice : grer laffichage de lanimation . . . . . . . . . . . . . . . . . 457
Champs de saisie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 459
Retour sur lobjet TextField . . . . . . . . . . . . . . . . . . . . . . . . 459
vnements et TextField . . . . . . . . . . . . . . . . . . . . . . . . . . 463
Exercice : un mini formulaire . . . . . . . . . . . . . . . . . . . . . . . . 467
23 Animer des objets
473
Lanimation par images-cls . . . . . . . . . . . . . . . . . . . . . . . . . . . . 474

Lvnement Event.ENTER_FRAME . . . . . . . . . . . . . . . . . . . . . . 474
Crer une animation basique . . . . . . . . . . . . . . . . . . . . . . . . 474
Lutilisation de Timer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 477
La classe Timer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 477
Exercice : une horloge . . . . . . . . . . . . . . . . . . . . . . . . . . . . 478
Les interpolations avec TweenMax . . . . . . . . . . . . . . . . . . . . . . . . 482
La librairie TweenMax . . . . . . . . . . . . . . . . . . . . . . . . . . . . 482
Les bases de lanimation avec TweenMax . . . . . . . . . . . . . . . . . . 484
Utilisation avance de TweenMax . . . . . . . . . . . . . . . . . . . . . . 488
24 Les collisions
495
Prambule . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 496
Dfinition dune collision . . . . . . . . . . . . . . . . . . . . . . . . . . . 496
xv
TABLE DES MATIRES

Dtecter des collisions . . . . . . . . . . . . . . . . . . . . . . . . . . . . 496
La thorie des collisions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 498
Collisions rectangulaires . . . . . . . . . . . . . . . . . . . . . . . . . . . 498
Collisions circulaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 502
Collisions ponctuelles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 505
Les collisions de pixels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 508
Utiliser lopacit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 508
Application en code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 510
25 TP : Jeu de billard
Objectifs
513
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 514
Les rgles de notre billard . . . . . . . . . . . . . . . . . . . . . . . . . . 514

Le droulement dune partie . . . . . . . . . . . . . . . . . . . . . . . . . 515
Consigne supplmentaire . . . . . . . . . . . . . . . . . . . . . . . . . . . 517
Prparation et conseils . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 517
Prparation du projet . . . . . . . . . . . . . . . . . . . . . . . . . . . . 517
Les diffrents lments du jeu . . . . . . . . . . . . . . . . . . . . . . . . 520
Un peu de Maths . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 527
Organiser son projet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 535
Organisation de lapplication . . . . . . . . . . . . . . . . . . . . . . . . . . . 535
La structure de lapplication . . . . . . . . . . . . . . . . . . . . . . . . . 535
Description des diffrents classes . . . . . . . . . . . . . . . . . . . . . . 537
Cration des classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 537
Visuel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 537
Bille . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 539
Table . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 547
Trous . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 550
Queue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 554
Billard . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 560
Main . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 573
Conclusion et amliorations possibles . . . . . . . . . . . . . . . . . . . . . . . 577
Sources du Billard . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 577
Ides damlioration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 577
26 La gestion des erreurs
xvi
579
TABLE DES MATIRES

Les principes de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 580
Introduction la gestion des erreurs . . . . . . . . . . . . . . . . . . . . 580
Les diffrents types derreurs dexcution . . . . . . . . . . . . . . . . . . 580
Les erreurs synchrones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 581
Lintruction throw . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 581
Linstruction try...catch . . . . . . . . . . . . . . . . . . . . . . . . . . 583
Les erreurs asynchrones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 585
Distribuer un objet ErrorEvent . . . . . . . . . . . . . . . . . . . . . . . 585
Grer des vnements derreurs . . . . . . . . . . . . . . . . . . . . . . . 585
Bien comprendre les deux approches . . . . . . . . . . . . . . . . . . . . . . . 586
Une classe utilisant les deux approches . . . . . . . . . . . . . . . . . . . 586
Intrts des erreurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 589
Annexes
591
27 Bonnes pratiques
593
La mmoire dans Flash . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 594

Flash et la mmoire vive . . . . . . . . . . . . . . . . . . . . . . . . . . . 594
Le ramasse-miettes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 594
Prparer un objet pour la suppression . . . . . . . . . . . . . . . . . . . 594
Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 595
Les commentaires de documentation . . . . . . . . . . . . . . . . . . . . . . . 597
Ecrire un commentaire de documentation . . . . . . . . . . . . . . . . . 597
Gnrer la documentation de vos classes . . . . . . . . . . . . . . . . . . 598
xvii
TABLE DES MATIRES
xviii
Premire partie
Les bases de lActionscript
Chapitre
Vous avez dit Actionscript ?

Difficult :
Pour commencer ce cours en douceur, voici une petite introduction pour vous prsenter la
technologie Flash, ainsi que son langage de programmation principal, lActionscript 3 !
Pour ceux qui ne connatraient pas cette technologie, nous verrons ce quil est possible de
faire en Flash ainsi que les diffrentes utilisations de celui-ci. Nous essaierons galement
de prsenter les technologies Flex et Air qui peuvent servir enrichir Flash. Quelques
exemples de projets Flash vous seront donns afin que vous puissiez vous faire une ide des
possibilits de lActionscript.
Ce chapitre dintroduction ne prsente aucune difficult, mme si vous tes un parfait
dbutant en programmation. Je vous rappelle que ce cours est rdig avec une difficult
progressive aussi, contentez-vous de lire celui-ci votre rythme et tout ira bien !
CHAPITRE 1. VOUS AVEZ DIT ACTIONSCRIPT ?
Adobe Flash
Prsentation de Flash
Flash est une technologie actuellement dveloppe et soutenue par Adobe Systems
(prononcez adobi ).
Elle est principalement utilise pour afficher des animations dynamiques et interactives
dans des pages web travers le navigateur Internet. Elle permet, par exemple, dajouter
une vido ou un jeu sur son site web, animer une galerie dimages, proposer une interface
dynamique pour un service ou un logiciel en ligne.
Un document Flash est un fichier sous le format swf (Shockwave Flash), et vous en
avez srement ouvert plusieurs chaque visite sur le web : en effet, ces animations
Flash, couramment utilises sur Internet, sont un assemblage dimages, de textes, de
dessins et de sons pouvant sanimer et mme interagir avec vous.
Parmi ses concurrents, on peut citer Silverlight, de Microsoft ou encore Java, de Sun/Oracle. LHTML5, coupl avec le CSS3 est une nouvelle alternative standardise ces
animations, ne ncessitant pas de plug-in dans le navigateur. Les spcifications de
lHTML5 ne sont malheureusement pas encore finalises lheure actuelle. Je vous
encourage lire le tutoriel de Mathieu Nebra sur lHTML5 et le CSS3 sur OpenClassrooms, si vous vous sentez lme dun webdesigner !
Un peu dhistoire
Flash nest pas aussi rcent que lon pourrait le croire, car son anctre direct a vu
le jour en 1995 et est sorti un an plus tard : il sagit de FutureSplash Animator
(voir figure 1.1), un concurrent de Macromedia Shockwave cette poque (un autre
format multimdia orient vers le web). FutureSplash a t dvelopp par FutureWave
Software, une compagnie lorigine de SmartSketch, un logiciel de dessin vectoriel dont
il manquait la composante animation contrairement Shockwave.
Figure 1.1 FutureSplash Animator

Son succs amena Macromedia racheter FutureSplash Animator en dcembre 1996,
pour le renommer en Macromedia Flash (voir figure 1.2), contraction de Future et
Splash. En 2005, Adobe Systems acquiert Macromedia ; le dveloppement de Flash se
poursuit et aboutit une volution majeure de la technologie avec la sortie en 2007 de
CS3 (Creative Suite 3 ) : cest la naissance de lActionscript 3 et de Flash 9.
Depuis, Adobe travaille lamlioration du lecteur Flash avec notamment la sortie
en 2008 de la dixime version de Flash apportant quelques nouveauts et un dbut de
support de lacclration matrielle pour obtenir de meilleures performances. En 2011,
4
ADOBE FLASH
Figure 1.2 Macromedia Flash

une onzime version majeure apporte une nouveaut trs attendue : le support intgral de lacclration matrielle par la carte graphique, ouvrant la voie de nouveaux
contenus en 3D complexe. Le fameux moteur de jeux vido dEpic Games, lUnreal
Engine 3, a dailleurs t port sur la plate-forme Flash !
Adobe cherche maintenant faciliter lutilisation de sa technologie sur les autres appareils multimdia, et on peut dsormais dvelopper en Flash sur un tlphone portable
fonctionnant sous Android de Google, iOs dApple ou BlackBerry 10 de RIM, sur des
tablettes tactiles et mme sur des tlvisions !
Les drivs de Flash

La plupart des professionnels se servent du logiciel Flash Professionnal dAdobe,
mais il existe dautres faons dutiliser cette technologie. Voici les deux principales :
la premire utilise un autre langage tandis que la deuxime est en quelque sorte une
extension de lActionscript 3.
Flex
Flex est un logiciel jumeau de Flash Professionnal, il est orient dveloppement et
design dapplications (voir figure 1.3). Il permet principalement de combler les lacunes,
si on peut dire, de Flash en termes de cration dinterfaces utilisateur. Cest pourquoi,
celui-ci propose une grande collection de composants prconus faciles manipuler tels
que des boutons, des champs de texte, etc. Les dveloppeurs peuvent ainsi concevoir
trs rapidement une interface utilisateur pour des programmes qui ne ncessitent pas
toute la puissance de dessin de Flash.
Figure 1.3 Adobe Flex

Flex utilise principalement un autre langage invent par Macromdia : le MXML
(Macromedia Extensible Markup Language), une variante du langage trs connu quest
le XML. Le MXML est utilis pour dcrire la structure visuelle dune application de
la mme faon que pour crire une page web avec lHTML (lui aussi bas sur le
5

XML) ; on place alors des balises reprsentant les composants du programme tout
en les mettant en forme. Ensuite, lActionscript sajoute au XML dans une balise <mx:Script> et permet de manipuler et danimer les balises MXML ainsi que
dinteragir avec lutilisateur par exemple.
Pour obtenir plus dinformations, vous pouvez jeter un coup dil au tutoriel Flex de
Migs sur OpenClassrooms.
Air
Adobe Air est une variante de Flash permettant nimporte quelle animation cre
avec Flash ou Flex de sinstaller et de fonctionner comme une vritable application
(figure 1.4). Grce aux nombreuses nouvelles fonctionnalits et outils qui sont votre
disposition lorsque vous programmez une application Air, vous pouvez grer le systme de fichiers de lordinateur ou les disques amovibles, crer des bases de donnes,
monter un serveur, etc. Ainsi, peut-on programmer un traitement de texte ou encore
un logiciel de messagerie instantane, voire un navigateur Internet avec Flash.
Figure 1.4 Adobe Air

Une autre particularit de cette plate-forme ressemblant Flash est que, en plus du
MXML et de lActionscript 3, on peut utiliser uniquement du simple HTML, CSS
et Javascript pour crer de telles applications. Air utilise alors le moteur Webkit
(utilis par Chrome et Safari entre autres) pour afficher ces lments de pages web dans
les applications. Ceci reprsente un avantage non ngligeable pour les dveloppeurs
web voulant programmer des applications de bureau sans toutefois avoir apprendre
et matriser un autre langage de programmation !
Enfin, cest Air qui permet aux dveloppeurs Flash de crer des applications destination de mobiles comme liPhone, sur les tablettes tactiles ou encore sur les tlviseurs,
et cela depuis 2010 avec la sortie dAir 2.5 (voir figure 1.5).
Quelques exemples dutilisation

Pour bien cerner les possibilits de Flash et diffrencier les multiples variantes de cette
technologie, voici, rien que pour vous, quelques exemples illustrs.
Le dynamisme apport au web par lActionscript

Il est probable que la premire fois que vous ayez entendu parler de Flash soit en jouant
divers jeux sur le web. En effet, il existe de nombreux sites web proposant des jeux
6
QUELQUES EXEMPLES DUTILISATION
Figure 1.5 Prsentation dAdobe AIR 2.5, un driv de Flash.

Flash. Bien entendu, ceux-ci sont raliss en Flash laide du langage Actionscript.
Pour vous donner un exemple concret, je vous ai slectionn un jeu nomm Kingdom
Rush, dont un aperu est donn la figure 1.6.
Figure 1.6 Un jeu ralis en Flash : Kingdom Rush.
Cration de sites web orients vers le visuel

La technologie Flash est aussi grandement utilise dans la conception des sites web
eux-mmes. En gnral, les animations Flash sont plutt rserves aux sites web
statiques ou sites-vitrines. Ceux-ci sont trs apprcis pour leurs interactions et leurs
animations qui dynamisent normment la navigation : il est important, notamment
7

pour les sites commerciaux destination du grand public, dattirer le regard. Toutefois,
il est tout fait possible de crer des sites web dynamiques et interagir avec un serveur
grce au langage PHP par exemple. Pour que vous puissiez mieux vous faire une ide
de la chose, je vous propose daller visiter le site de la nouvelle srie de Canal+ (voir
figure 1.7) :

Carlos
.
B
Code web : 751006
Figure 1.7 Le site de la srie Carlos est ralis en Flash.
Introduction dAdobe Air

Comme nous le verrons dans le prochain chapitre, lutilisation de la technologie Flash
ncessite un lecteur spcifique nomm Flash Player. Celui-ci est trs rpandu lintrieur des navigateurs Internet, et lutilisation de Flash sest ainsi longtemps limite au
web. Heureusement, ceci nest plus le cas avec larrive dAdobe Air. En effet, cette
technologie vient ajouter de nouvelles fonctionnalits Flash et permettre lutilisation
de Flash hors-ligne en tant que programme. Pour vous donner un exemple, lapplication Flash du site de poker Winamax (voir figure 1.8), disponible initialement sur
navigateur Internet, a pu tre convertie en vritable logiciel grce Adobe Air.
Ainsi lutilisation dAdobe Air permet de porter les applications directement sur un
systme dexploitation. Cette technologie est notamment utilise aujourdhui par de
nombreux systmes dexploitation mobiles tels que liOS, Android ou BlackBerry 10.
8
LACTIONSCRIPT 3
Figure 1.8 Le logiciel Winamax utilise la technologie Air.
LActionscript 3
LActionscript est le langage de programmation servant faire fonctionner les animations Flash. Cest le plus utilis parmi les langages de Flash. Il est bas sur lECMAscript, linstar du Javascript utilis sur Internet, directement dans les pages
web. Sans lui, aucune animation ou interaction dans un fichier Flash ne serait possible
et celui-ci serait alors rduit une simple image fixe.
LActionscript est un langage orient objet, de haut niveau et vnementiel.
Orient objet
En effet, sa structure est base sur le concept dobjet, cest--dire que tous les lments
de lanimation (y compris ceux qui ne relvent pas de laffichage, comme par exemple les
nombres) sont des objets, avec des attributs et des mthodes qui leur sont attachs.
Chaque objet est dcrit par une classe : un ensemble dattributs et de mthodes
qui reprsentent son comportement.
Prenons comme exemple une voiture de sport : cest un objet qui a pour classe Voiture,
cest--dire quelle a par exemple un attribut vitesse qui nous permet de connatre sa
vitesse de dplacement, ou encore une mthode tourner gauche, qui la fait tourner.
Tous ces attributs et ces mthodes sont dcrits et expliqus dans la classe Voiture.
Sil nous prenait lenvie de programmer un jeu de course de voitures basique, il faudrait
dabord crire une classe Voiture, puis, sur le fichier principal, crer un nouvel objet
de la classe Voiture pour crer une voiture (et ensuite la dplacer par exemple).
Une partie toute entire sera consacre la programmation oriente objet, ne vous
en faites pas si vous narrivez pas tout bien saisir maintenant.
9
De haut niveau
LActionscript est un langage dit de haut niveau, cest--dire que son fonctionnement est trs loign du fonctionnement de lordinateur au niveau matriel, au contraire
des langages dit de bas niveau, proches de la machine (comme le langage C).
Gnralement, cela signifie quil est plus facile de raliser certaines choses ou quil faut
moins dinstructions, mais cela se traduit souvent par des performances plus faibles.
Le Java, le Python ou le Ruby sont dautres exemples de langages de haut niveau.
vnementiel
Enfin, cest un langage vnementiel, cest--dire que linteractivit de vos programmes
sera base sur des vnements que nous allons couter. Par exemple, pour utiliser
un bouton, nous allons couter (donc attendre) sur lui lvnement cliqu qui sera
dclench lorsque lutilisateur appuiera sur ce bouton. Bien sr, pendant ce temps,
nous pouvons faire autre chose : cest tout lintrt de ce systme.
En rsum
LActionscript est un langage interprt, il a donc besoin dun interprteur
(le lecteur Flash) pour tre excut.
La technologie Flash regroupe les programmes Flash classiques, les applications
Flex que lon peut trouver sur des pages web, ainsi que les applications AIR
destination du bureau ou dautres appareils comme les mobiles.
Le principal langage utilis dans ces programmes est lActionscript 3, mais on peut
aussi utiliser le MXML (pour Flex et AIR), voire lHTML et le Javascript (pour
les applications AIR uniquement).
LActionscript 3 est un langage de haut-niveau : son fonctionnement est loign de
la machine et il est en gnral plus facile dimplmenter des fonctionnalits complexes.
Cest aussi un langage orient objet : son fonctionnement est bas sur des concepts
dobjets et de classes.
Enfin, cest un langage vnementiel : on coute des objets, et si des vnements
surviennent, on peut excuter du code.
10
Chapitre
Votre premier programme avec Flex

SDK
Difficult :
Maintenant que vous en savez un peu plus sur Flash, il est grand temps de passer la
pratique et lessentiel de ce cours : lActionscript 3 ! Vous aurez besoin doutils pour
suivre ce cours et appliquer ce que vous apprendrez (cest trs important), mais ne vous
inquitez pas, tous sont gratuits.
Le compilateur, qui servira transformer votre code en animation, est effectivement gratuit
pour tout le monde et mme open-source ! Il sagit de Flex SDK, qui faisait partie du projet
Adobe Open Source et qui est rcemment pass sous laile de la Fondation Apache. Nous
utiliserons galement un logiciel facultatif pour nous aider coder et compiler nos projets,
disponible hlas uniquement sous Windows.
11
CHAPITRE 2. VOTRE PREMIER PROGRAMME AVEC FLEX SDK

Cette partie est un peu difficile, surtout si vous navez jamais programm :
accrochez-vous, relisez les parties que vous navez pas comprises ! La suite
en sera plus facile apprhender. La partie sur la compilation en ligne de
commande est facultative si vous travaillez sur Windows et que vous tes
allergiques la console. . .
Prambule
Le compilateur
Un compilateur est un programme trs utile dans la plupart des langages de programmation. Vous vous doutez bien que lordinateur ne sait pas interprter directement le
code que nous lui crivons : en effet, les langages de programmation ont t conus
pour tre facilement utilisables par les tres humains comme vous et moi. Or, les ordinateurs ne comprennent que les instructions en binaire de bas niveau (voir chapitre
prcdent). Il faut donc traduire nos programmes grce au compilateur ! (voir figure
2.1)
Figure 2.1 Le principe de la compilation

Certains langages de programmation sont interprts par un logiciel faisant
lintermdiaire entre le code et lordinateur : on peut en gnral se passer de
la compilation. Cest le cas de la plupart des langages utiliss sur Internet,
comme le Javascript ou le PHP. Mais cest aussi le cas de lActionscript !
Mais alors, pourquoi doit-on compiler nos programmes crits en Actionscript ?

En Actionscript 3, la compilation vous donne des informations sur vos erreurs
de syntaxe pour que vous les corrigiez plus facilement, mais elle permet surtout de
rassembler tout votre code et le contenu ncessaire au bon droulement de votre programme (comme les librairies) dans un seul fichier. Ainsi, il est plus facile dintgrer
une animation Flash dans un site web et il devient possible dimporter directement
dans lanimation des images, des sons, des polices de caractres ou dautres mdias
12
PRAMBULE
qui seront chargs en mme temps que votre programme. En outre, le compilateur
compresse votre animation afin quelle prenne moins de temps se charger.
Ainsi, en Flash, le compilateur ne traduit pas votre code en binaire (voir figure 2.2).
vrai dire, ce nest quun demi-compilateur : il ne soccupe seulement de lier plusieurs
fichiers en un seul (opration appele dition de liens), alors que les compilateurs
classiques traduisent galement le code.
Figure 2.2 Le compilateur Flash

Le fichier qui est produit est en gnral au format swf (ShockWave Flash) ; cest lui
qui sera charg par un navigateur Internet par exemple.
Le lecteur Flash
Donc il nous faut un logiciel pour que lordinateur comprenne notre code ?
Oui ! Cest l que le lecteur Flash (ou Flash Player en anglais) entre en scne (voir
figure 2.3). Ce logiciel contient un ensemble doutils permettant dexcuter votre programme : Flash Player est un interprteur, et lActionscript est un langage interprt.
Figure 2.3 Le lecteur Flash

Tout ce processus se droule lintrieur dune machine virtuelle. Concrtement, Flash
Player cache le systme sur lequel votre programme tourne et gre lui-mme la mmoire et les autres changes ncessaires au bon droulement de votre programme.
Ainsi, ce dernier peut fonctionner correctement sur plusieurs systmes dexploitation
(Windows, Mac, Linux, Android, etc.) totalement diffrents. Entre autres, il dispose
13

dun compilateur la vole, ou JIT (Just In Time) qui traduit en temps rel certains
passages de votre code en binaire afin damliorer les performances.
Installation des outils

Ainsi, pour programmer en Actionscript, il nous faut plusieurs outils, dont un
compilateur et un lecteur Flash. Nous allons ds prsent nous occuper de tout
cela !
Java
Java est une technologie similaire Flash, dveloppe initialement par Sun Microsystems (rachet par Oracle), qui regroupe un ensemble doutils permettant de crer des
applications (voir figure 2.4). Or, le compilateur de Flash est crit en Java : il faut
donc que Java soit install sur votre ordinateur. Si vous tes certains que cest dj le
cas, vous pouvez passer ltape suivante. Sinon, tlchargez et installez Java :

Tlchargez Java
.
B
Code web : 741426
Figure 2.4 Le logo Java
Flex SDK
Le Flex SDK (Software Development Kit) est un ensemble doutils de dveloppement
qui permettent, entre autres, de compiler des programmes crits en Actionscript 1, 2
ou 3, et des applications Flex ou Air.
Depuis 2011, Adobe a plac Flex sous licence Apache, par le biais de la Fondation
Apache. Le Flex SDK est ainsi distribu maintenant sous lappellation Apache Flex,
et est donc un projet open source (figure 2.5).
Nous verrons, dans la dernire partie de ce chapitre, comment utiliser un
logiciel nous permettant de dvelopper en Actionscript sans utiliser la console
de lignes de commande : il sagit de Flashdevelop (Windows uniquement).
Si vous ne voulez pas essayer de compiler avec la console et que vous tes
sous Windows, vous pourrez alors vous passer de la console pour compiler
vos applications.
14
INSTALLATION DES OUTILS
Figure 2.5 Le logo Apache Flex
Tout dabord, il vous faut disposer dAdobe Air pour installer le SDK, et suivez
ensuite les instructions dinstallation.

Adobe Air
.
B
Code web : 815403

Ensuite, il faut que vous rcupriez le SDK sur le site dApache :

Apache Flex SDK
B
.
Code web : 944481

Cliquez sur le bouton Download, lancez le tlchargement (voir figure 2.6) et allez
prendre un caf.
Figure 2.6 Page de tlchargement dApache Flex

Une fois le tlchargement termin, installez et lancez lapplication Apache Flex SDK
Installer. Un cran de slection de la version des diffrents composants du SDK saffiche une fois lapplication ouverte (voir figure 2.7).
15
Figure 2.7 Application dinstallation
Laissez les valeurs telles quelles sont : les dernires versions sont en effet slectionnes
par dfaut.
Sur lcran suivant, choisissez lemplacement dinstallation du SDK, de prfrence un
rpertoire facilement accessible (votre dossier personnel par exemple) et nommez-le
Flex SDK 4.
Ensuite, vous devez accepter les licences dutilisation des diffrents composants du SDK
en cochant les cases de la liste des composants (voir figure 2.8).
Figure 2.8 Liste des composants du SDK

Le tlchargement et linstallation des composants dbute alors. Une fois linstallation
termine, vous pouvez fermer lapplication.
16

Pour les utilisateurs de linux, il faut installer Adobe AIR 2.6.0 pour pouvoir
utiliser lapplication dinstallation de Flex SDK 4. Skype peut galement
entrer en conflit avec Adobe AIR, il faut alors le dsinstaller.
Vous voil arms dun compilateur Flash ! Mais comment sen sert-on ? Avec les lignes
de commande pardi ! Pour les utilisateurs de Windows, il est grand temps de renouer
une relation avec le terminal ! Pour Mac et Linux en revanche, cela ne devrait pas trop
vous poser de problmes. . .
Voici la marche suivre pour lancer un terminal :
Windows : dans le menu dmarrer, allez dans
Tous les
programmes, Accessoires,

Invite de commandes, ou appuyez sur Windows +R et entrez cmd puis validez
(voir figure 2.9).
Linux : comment a, vous ne savez pas ouvrir un terminal ? :- Le gnome-terminal
(Gnome) ou la Konsole (KDE) conviendront parfaitement (voir figure 2.10).
Mac : dans le Finder, slectionnez Applications, puis Utilitaires et enfin Terminal
(voir figure 2.11).
Sur Windows, il existe une alternative au terminal classique, bien plus complte et confortable, car elle se rapproche de ceux des systmes dexploitation
Linux ou Mac. Il sagit de Powershell ; pour le lancer, appuyez sur Windows+R, entrez powershell et validez. Dsormais, vous pouvez par exemple
appuyer sur TAB pour complter automatiquement une commande ou un
chemin, comme sur Linux !
Maintenant, il va falloir se placer dans le dossier bin du SDK : utilisez la commande
cd (Change Directory) pour vous dplacer dans larborescence de fichiers.
Figure 2.9 Windows
17
Figure 2.10 Linux
Figure 2.11 Mac
18
Version de dbogage du lecteur Flash

Un deuxime outil va nous tre indispensable : il sagit dune version lgrement diffrente du lecteur Flash habituel que lon trouve dans les navigateurs Internet par
exemple. En effet, ceFlash Player de dbogage peut sexcuter tout seul comme
une quelconque application et dispose surtout de fonctions de dbogage trs utiles.
Par exemple, si un problme survient pendant que lon teste notre programme, une
fentre nous affichera les dtails de lerreur, la ligne incrimine et les diffrents appels
de fonctions ayant conduit cette erreur.
Vous pouvez ds prsent rcuprer le lecteur sur le site web dAdobe :

Flash Player de dbogage
B
Code web : 927850

Un large choix de versions soffre vous : il faut prendre le lecteur appel Projector
content debugger , correspondant votre systme dexploitation :
si vous tes sur Windows, il faut cliquer sur le lien Download the Windows Flash
Player xx.x Projector content debugger,
si vous tes sur Max, il sagit du lien Download the Macintosh Flash Player xx.x
Projector content debugger
enfin, si vous tes sur Linux, le bon lien est Download the Linux Flash Player xx.x
Projector content debugger.
Sur Windows
Lancez le fichier excutable tlcharg une fois afin que les fichiers .swf soient automatiquement associs au Lecteur Flash (voir figure 2.12)
Sur Linux
Commencez par extraire larchive tlcharge. Pour que son utilisation soit plus facile,
et surtout parce que lon en aura besoin un peu plus loin, vous pouvez dplacer lexcutable flashplayerdebugger vers le dossier /usr/bin et le renommer en flashplayer
grce la commande suivante (noubliez pas de vous placer dans le dossier de larchive
extraite) :
sudo mv f l as h playerdebugger / usr / bin / flashplayer
Une fois le dplacement effectu, relancez votre console et replacez-vous dans le dossier
Flex SDK 4/bin.
Sur Mac
Installez le lecteur Flash en double-cliquant sur linstallateur Install Adobe Flash
Player Debugger 11.dmg (voir figure 2.13)
19
Figure 2.12 Lecteur Flash de dbogage Windows
Figure 2.13 Installation de Flash Player Debugger
20
Crer les sources

Vu que nous navons pas encore attaqu lcriture de programmes en Actionscript
3, je vous ai concoct un petit code de test, qui va nous permettre de vrifier que votre
installation fonctionne bien.
Pour les utilisateurs de Windows, il est ncessaire de pouvoir enregistrer vos
fichier dans nimporte quelle extension : sinon, il y a de grandes chances
pour que Windows vous trahisse en sauvegardant votre fichier Test.as en
Test.as.txt par exemple, sans que vous ne en rendiez compte ! Pour viter
cela, il faut dsactiver une fonctionnalit de Windows qui masque la plupart
des extensions : dans une fentre de lexplorateur de fichiers, allez dans le
menu Options des dossiers, puis dans longlet Affichage et dcochez
Masquer les extensions des fichiers dont le type est connu.
Commencez par crer un rpertoire Sources dans le dossier bin o lon mettra les
sources de nos futurs programmes. Dans le rpertoire Sources, crez un nouveau fichier nomm Test.as et copiez-y le code en utilisant un diteur de texte quelconque,
tel que le Bloc-notes si vous tes sous Windows. Utilisez le code web ci-dessous pour
afficher le code et le copier/coller.

Code pour test.as
B
Code web : 171910
Compiler le programme de test

Pour compiler Test.as, revenez dans le terminal pour lancer le programme mxmlc
contenu dans le dossier bin.
Windows
.\ mxmlc . exe " Sources / Test . as "
Linux et Max
./ mxmlc Sources / Test . as
Il est possible que vous ayez besoin des droits administrateurs sur Linux pour
pouvoir compiler. Pour contourner le problme, essayez dajouter bash ou
sudo avant la commande ./mxmlc.
21

Ensuite, appuyez sur Entre pour lancer la compilation (voir figures 2.14, 2.15 et
2.16 pour les diffrents cas).
Figure 2.14 Windows
Figure 2.15 Linux

Aprs quelques instants, et si tout sest bien pass, un fichier Test.swf a t cr dans
le dossier Sources ; il vous suffit de louvrir avec le lecteur de dbogage que nous avons
tlcharg prcdemment !
22
DIS BONJOUR AU MONSIEUR
Figure 2.16 Mac

Sur Windows ou Mac
Double-cliquez sur le fichier Test.swf. Si jamais le lecteur Flash ne souvre pas,
choisissez-le avec la commande Ouvrir avec... ou dans la liste Slectionner un
programme install (voir figures 2.17 et 2.18).
Sur Linux
Entrez dans votre terminal (voir figure 2.19) :
flashplayer Sources / Test . swf
Si votre curseur laisse une trane blanche et brumeuse, cela signifie que la compilation
a russi et que vous tes prts pour passer la suite !
Dis bonjour au monsieur

Nous allons maintenant crire de A Z notre premier programme Flash ! Commencez
par crer un nouveau fichier Actionscript dans le rpertoire Source, et nommez-le
Hello.as.
Structure de notre programme

Un programme crit intgralement en Actionscript, ce qui sera le cas durant ce cours,
prsente toujours la mme structure : le code est obligatoirement mis dans des fonctions, elles-mmes places dans une classe, englobe par un paquet (on utilise alors
23
Figure 2.17 Windows
Figure 2.18 Mac

24
Figure 2.19 Linux

le mot anglais package). Pour linstant, il y a de grandes chances que les trois termes
que je viens dutiliser soient obscurs pour vous ; la seule chose importante retenir est
lorganisation de ces trois niveaux qui composent le code source de tout fichier Actionscript. Pas de panique : nous explorerons plus en dtails chacune de ces notions
plus tard dans le cours.
Vous trouverez un petit schma rcapitulatif la figure 2.20.
Figure 2.20 Structure dun programme
Le package
Commenons par le plus simple : le package. Il est compos dun nom facultatif et
dun bloc daccolades. Nous utilisons le mot-cl package comme ceci :
1
package nom {
2
3
25

Un mot-cl (ou rserv) est une expression qui est utilise par le langage et
qui lui est donc rserve. Vous ne pourrez donc pas utiliser ce type de mots
autrement que tels quils ont t dfinis en Actionscript.
Le nom du package dcrit la position de la classe dans larborescence des fichiers de
votre projet. Effectivement, vous ne pouvez choisir vous-mmes le nom du package :
vous devez mettre le chemin relatif du fichier par rapport au fichier principal (celui que
lon compile avec la commande mxmlc vue plus haut), en sparant les dossiers par des
points ( la place des slashes ou antislashes).
Par exemple, si votre fichier principal Hello.as se trouve dans le dossier source et
que vous crez un nouveau dossier ET dans lequel vous rajoutez un dossier telephoner,
en y mettant un fichier Actionscript Maison.as qui est utilis par votre programme
principal, vous devrez crire son package ainsi :
1
package ET . telephoner {
2
3
Larborescence des fichiers est alors Sources/ET/telephoner/Maison.as.

Comment cela, on peut utiliser un autre fichier Actionscript depuis notre
programme principal ?
Bien sr ! Cest mme trs utile : il vaut mieux faire plusieurs fichiers bien tris (un
dossier pour les utilitaires, un dossier pour le chargement de son. . .), que mettre lensemble des donnes dans un seul et unique fichier. Imaginez que votre programme fasse
plusieurs centaines de milliers de lignes de code : il vous sera impossible de vous y
retrouver ! Nous allons voir cette notion appele importation de fichiers dans trs
peu de temps.
Quen est-il de notre fichier Hello.as ?
Trs bonne question : pour le programme principal contenu dans le fichier que vous
allez compiler avec la commande mxmlc, il ny a pas de nom de package ! Et oui, il est
dj dans le dossier principal de votre projet, inutile donc de mettre un chemin.
Dans ce cas, le package scrit ainsi :
1
package {
2
3
Vous pouvez crire ce code dans votre fichier vide si vous ne lavez pas dj fait !
26

Importer des fichiers Actionscript
Comme nous lavons vu, importer des fichiers peut savrer trs utile, voire vital dans
la plupart des cas. Limportation est une instruction (ou une ligne de code si vous
prfrez) qui permet de rendre tout le code du fichier import utilisable dans notre
code. Il y a deux types de fichiers que vous pouvez importer : les fichiers contenus dans
les packages de Flash (commenant par flash.) et vos propres fichiers. Dans les
deux cas, on utilise le mot-cl import suivi du package du fichier importer, son nom
et un point-virgule :
1
import ET . telephone . Maison ;
La plupart des instructions et lignes de code devraient tre termines par un

point-virgule en fin de ligne. Je dis devraient car il est tolr domettre
le point-virgule, mais cest trs fortement dconseill : il est le symbole qui
indique clairement la fin de votre ligne de code. Il est possible, dans de rares
cas, que vous obteniez des erreurs cause de cela. Votre ordinateur ne sautodtruira pas si vous ne mettez pas les points-virgules, mais ce serait une
trs, trs, trs mauvaise habitude : si jamais vous voulez apprendre et utiliser
un autre langage, vous oublierez constamment les points-virgules et maudirez
le jour o vous avez dcid de ne pas suivre mon conseil. . . :- Vous remarquerez quil ne faut pas mettre de point-virgule quand il sagit de blocs de
code dlimits par des accolades ({ et }), comme pour le package que lon
vient de voir.
Les importations scrivent juste aprs avoir ouvert la premire accolade du package :
1
package {
import ET . telephone . Maison ;
3
4
5
Pour notre programme, il va falloir importer un fichier standard de Flash : Sprite. Il

est ncessaire pour toute application : nous dtaillerons son utilit bien plus tard dans
le cours car il nous manque trop de notions actuellement. Je peux tout de mme vous
dire que cela nous permet dafficher le programme et donc de le lancer : effectivement,
tout programme Flash a besoin dun affichage pour sexcuter.
Je vous donne le code du fichier import que vous devez avoir dans votre Hello.as :
1
package {
import flash . display . Sprite ;
3
4
5
27

Vous laurez srement compris, le package du fichier est flash.display
(gestion de laffichage).
La classe
Ensuite, vient la. . . Comment a vous ne savez pas ? Retournez vite regarder le schma !
Effectivement, dans le package, on trouve une classe. Cette notion est un concept trs
important de la programmation oriente objet que jai mentionne dans lintroduction. Il est trop tt pour dvelopper cette notion, mais rassurez-vous : une partie
entire de ce cours sera consacre lorient objet.
Lessentiel est de retenir que la classe est obligatoire et que sa syntaxe est la suivante :
les mots-cls public class suivis du nom de la classe et dun bloc daccolades, comme
pour le package.
1
public class NomDeMaClasse {
2
3
Attention ! Le nom dune classe ne doit contenir que des lettres, et doit tre
identique au nom du fichier dans lequel elle se trouve (sans lextension). De
plus, il doit imprativement commencer par une majuscule : cela explique
pourquoi tous nos fichiers Actionscript ont une majuscule depuis le dbut
du cours !
tant donn que le nom du fichier est le mme que celui de la classe de ce fichier, nous
parlerons dsormais de classe dans les deux cas.
Il existe une notation appele Camel (chameau) ou CamelCase (notation
chameau), trs utilise dans le monde de linformatique. Je lai utilise pour
crire NomDeMaClasse : chaque mot dbute par une majuscule, comme des
bosses de chameau ! Son utilit est purement esthtique car cette notation
amliore la lisibilit du code lorsque lon ne peut pas utiliser despaces ou
dautres caractres spciaux. Cest le cas ici avec le nom des classes. Je pense
que cest une bonne habitude prendre, alors autant commencer tout de
suite : avouez que si javais crit Nomdemaclasse, ce serait beaucoup moins
lisible !
La classe se dispose juste aprs les importations de fichiers, comme ceci pour notre
fichier Hello.as :
1
package {
2
3
4
5
28
public class Hello extends Sprite {

6
7
8
Les plus observateurs dentre vous auront remarqu que jai ajout deux mots derrire
le nom de notre classe. Le mot-cl extends (tendre en anglais) permet dutiliser la
classe Sprite dune manire un peu spciale, comme nous le verrons dans la partie
consacre lorient objet.
Les fonctions
Maintenant que notre classe est prte, il faut crire une ou plusieurs fonctions pour
pouvoir mettre du code dedans ! Une de ces fonctions est obligatoire et elle porte un
nom : il sagit du constructeur de la classe. Devinez quoi ? Cest encore li lorient
objet ! Pour faire simple, ce constructeur est automatiquement excut dans certains
cas, lorsque lon utilise une classe. Ici, le code lintrieur sera parcouru au lancement
de notre programme. Pour crire un constructeur, on utilisera les mots-cls public
function suivis du nom de la classe, de parenthses et dun nouveau bloc daccolades.
Pour notre classe Hello contenue dans notre fichier Hello.as, le constructeur ressemblera ceci :
1
public function Hello () {
2
3
Et voil ! Notre fichier est fin prt pour que nous commencions (enfin) coder !
Voici le code complet de notre fichier Hello.as pour que vous puissiez vrifier :
1
2
// Premier niveau : le paquet

package {
// Les classes import es

4
5
6
// Deuxi me niveau : la classe du fichier

7
8
9
// Troisi me niveau : la ou les fonctions
10
11
// Constructeur de la classe
12
13
14
// Nous allons coder ici !
15
16
17
18
19
20
29
Commentez votre code !

Avez-vous remarqu que jai insr du texte en franais dans le code prcdent qui na
a priori rien faire l ? On appelle cela des commentaires. Vous pouvez y crire absolument nimporte quoi et pour cause, ils seront tout simplement ignors lorsque vous
lancerez votre programme. Vous vous demandez alors quoi servent-ils ? La rponse
est plutt simple : commenter un code permet de sy retrouver mme si nous avons
nous-mmes crit le code en question. Imaginez que vous reveniez dessus quelques mois
plus tard : sil ny a aucun commentaire, vous serez aussi perdu que si vous naviez
pas t le programmeur ! Cela peut mme arriver dans un intervalle de quelques jours
seulement. Et ce serait encore pire si vous souhaitiez que votre code soit lu ou utilis
par dautres personnes. . . Mais attention, il ne sagit pas non plus dinonder votre code
de commentaires : vous ne russiriez qu le rendre encore plus illisible et incomprhensible ! Il faut trouver un juste milieu : commentez quand cela est ncessaire pour
dcrire brivement ce que fait un morceau de votre programme afin de vous en rappeler
facilement plus tard.
Il existe deux types de commentaires : les commentaires en ligne et les commentaires multi-lignes.
Les commentaires en ligne
Ce sont des commentaires qui ne comportent quune seule ligne. On les dbute par
deux slashs, comme ceci :
1
// Voici un commentaire en ligne
Tout le texte suivant les deux slashs sera considr comme du commentaire.
Vous pouvez mettre un commentaire en fin de ligne, sans gner personne :
1
import display . Sprite ; // Pour l ' affichage
Les commentaires multi-lignes

Cette fois-ci, il est possible dtaler notre commentaire sur plusieurs lignes. Pour
cela, il faut dbuter notre commentaire par un slash et une astrisque et terminer
explicitement le commentaire par une astrisque et un slash :
1
2
3
4
/* Ceci
est un commentaire
sur quatre
lignes . */
Afficher un message dans la console

Avant toute chose, il est important de souligner que la technologie Flash na jamais
t conue pour tre utilise en lignes de commande : en effet, son objectif est de propo30

ser des applications et des animations entirement graphiques. Cela implique que lon
ne puisse quafficher du texte la console (avec quelques efforts) et quil est impossible
dentrer des donnes au clavier via la console, comme en langage C par exemple.
Cest une fonction qui nous permettra dafficher des messages dans la console : elle
rpond au doux nom de trace() et est quasiment exclusivement utilise pour le dbogage des programmes Flash.
Cette fonction est accessible partout dans tout code Actioncript, il suffit de lappeler.
Lappeler ? Comme mon chien pour partir en balade ?
Oui, on utilise le terme appeler lorsque lon utilise une fonction : nous nallons pas
crire du code entre les accolades de la fonction trace(), nous allons nous contenter
de lutiliser. En effet, son code est dj prt et fait partie du lecteur Flash lui-mme !
Pour lutiliser, nous allons prendre presque la mme syntaxe que celle du constructeur
Hello (qui est lui aussi une fonction), sans le bloc daccolades et sans oublier le pointvirgule (car il sagit dune instruction) :
1
trace ( " texte afficher " ) ;
Entre les deux parenthses, vous devez spcifier la fonction trace() ce quelle doit
afficher. Ce peut tre du texte (dlimit par des guillemets) ou un nombre. Par exemple,
pour afficher 42 dans la console, nous cririons :
1
trace ( 42 ) ;
vous de jouer ! Faites en sorte sans le tester que votre programme Hello soit capable dafficher le grand classique Hello world ! . Souvenez-vous o il faut mettre les
instructions dans le programme Hello que nous avons crit jusqu prsent !
1
2
// Premier niveau : le paquet

package {
3
4
5
// Les classes import es

6
7
8
// Deuxi me niveau : la classe du fichier

9
10
// Troisi me niveau : la ou les fonctions
11
12
13
// Constructeur de la classe
14
trace ( " Hello world ! " ) ;
15
16
17
18
31

19
20
Place au test !
Compiler notre programme
Commenons tout dabord par compiler Hello.as. Il y a une petite diffrence par
rapport tout lheure : cette fois-ci, il va falloir activer le mode dbogage lors de la
compilation, pour que lon puisse afficher le message Hello world ! dans la console.
Pour ce faire, ajoutons un paramtre lors de la compilation : -debug=true.
Sur Windows :
.\ mxmlc . exe - debug = true " Sources / Hello . as "
Sur Linux :
./ mxmlc - debug = true " Sources / Hello . as "
Et enfin, sur Mac :

./ mxmlc - debug = true Sources / Hello . as
Encore une fois, il est possible que vous ayez besoin des droits administrateurs sur Linux pour pouvoir compiler. Pour contourner le problme, essayez
dajouter bash ou sudo avant la commande ./mxmlc.
Si tout cest bien pass, votre console devrait afficher quelque chose comme ce que vous
voyez la figure 2.21.
Lancer le dbogueur Flash
Pour pouvoir afficher les messages de la fonction trace(), il nous faut utiliser un autre
outil notre disposition : le dbogueur Flash. En effet, Flash Player, mme en
version de dbogage, ne peut pas afficher des messages en continu dans une console. Il
se contente de les envoyer : le dbogueur va alors se charger de rcuprer les messages
et de nous les prsenter dans la console. Il sagit du programme fdb qui devrait tre
dans le rpertoire Flex SDK 4/bin (voir figure 2.22).
Lancez le programme dans votre console :
Sur Windows :
.\ fdb . exe
Sur linux :
32
Figure 2.21 Rsultat de la compilation
Figure 2.22 Contenu du rpertoire Flex SDK 4/bin
33
./ fdb
Sur Mac :
./ fdb
Un nouvel invit de commande, gr par fdb, devrait apparatre, comme la figure

2.23.
Figure 2.23 Le nouvel invit de commande gr par fdb
Lancer notre programme

Tout dabord il faut lancer une session de dbogage pendant laquelle le dbogueur
essayera de rcuprer les messages de dbogage du lecteur Flash :
run
Le dbogueur est ainsi en attente du lecteur Flash : lancez votre programme en

double-cliquant dessus, ou avec la commande que lon a vu plus haut dans le cas de
Linux. Le lecteur Flash nest cependant pas encore dmarr, il ne devrait donc pas se
passer grand-chose lcran.
Une fois que la session est correctement dmarre, entrez cette commande dans fdb
pour rellement lancer le programme :
34
continue
Miracle ! Notre trace("Hello world !"); a fonctionn et le message est apparu dans
la console ! (voir figure 2.24)
Figure 2.24 Rsultat de la fonction trace()

Une fentre blanche sest ouverte : il sagit de notre animation ! Pour linstant, elle ne
fait presque rien, nous remdierons cela dans la suite du cours.
Vous pouvez maintenant fermer votre programme. Si plus tard vous voulez quitter fdb,
entrez cette commande :
quit
Vous pouvez galement lister lintgralit des commandes du dbogueur avec cette
commande :
help
Lorsque vous programmez en lignes de commande, je vous conseille douvrir

deux consoles : une pour la compilation laide de mxmlc, et une autre pour
le dbogueur fdb. Cela vous vitera de quitter et relancer ce dernier chaque
compilation ; il vous suffira dutiliser la commande run chaque fois que vous
voulez tester votre programme.
35

Il en faut faire des efforts pour dboguer en lignes de commande, mais une fois
que vous avez pris le coup de main, cest plus facile. Pour se faciliter la vie, mieux vaut
squiper avec les meilleurs outils ! En effet, il existe des diteurs de code trs facile
dutilisation qui intgrent galement des outils prts lemploi pour compiler et tester
nos programmes !
FlashDevelop la rescousse !
Pour Windows, il existe un trs puissant diteur pour programmer en Flash, de
plus, il est gratuit et libre : jai nomm Flashdevelop ! Flashdevelop est ce que
lon appelle un IDE (Integrated Development Environment, environnement de
dveloppement intgr en anglais) : cest un logiciel contenant tout le ncessaire pour
programmer dans un ou plusieurs langages (ici lActionscript, mais pas seulement).
Vous allez voir : compiler sera dsormais aussi simple que dappuyer sur un bouton !
Tlchargement
Flashdevelop est donc disponible au tlchargement gratuitement, malheureusement,
la version officielle est rserve aux utilisateurs de Windows (voir figure 2.25). Commencez par tlcharger Flashdevelop.

Flashdevelop
B
Code web : 868865

Il est possible, pour les utilisateurs dun autre systme dexploitation, dutiliser une
machine virtuelle, tant que les dveloppeurs nauront pas eu le temps dadapter Flashdevelop dautres supports. Il existe galement une version alternative, sous forme
dun plugin pour le logiciel Eclipse. Rassurez-vous, le reste du cours ne porte pas sur
Flashdevelop, vous pourrez tout faire sans !

Plugin
B
Code web : 649014

Eclipse
B
.
Code web : 752289
Installation
Une fois linstallateur de Flashdevelop tlcharg, lancez-le et appuyez sur Next (voir
figure 2.26).
Cet cran nous permet de choisir dinstaller ou non des composants supplmentaires,
comme le Flex SDK. Pour viter tout problme, nous allons laisser les options par
dfaut, mais vous pouvez dcocher Install Flex SDK si vous lavez dj tlcharg et
que vous tes sr de vous. Je vous conseille toutefois de laisser le programme installer
le compilateur lui-mme pour viter tout problme. Cliquez sur Next (voir figure 2.27).
36
FLASHDEVELOP LA RESCOUSSE !
Figure 2.25 Tlchargement de FlashDevelop
Figure 2.26 Installation de FlashDevelop : tape 1
37

Choisissez le dossier dinstallation de Flashdevelop, puis cliquez une nouvelle fois sur
Next (voir figure 2.28).

Allez prendre un caf pendant linstallation ! (voir figure 2.29)
Cliquez sur Finish pour terminer linstallation (voir figure 2.30).
Si Flashdevelop ne se lance pas tout seul, lancez-le. Vous arrivez sur lcran daccueil
(voir figure 2.31).
38
39
Figure 2.31 Page de dmarrage de FlashDevelop

Vous pouvez fermer la page daccueil en cliquant sur la croix correspondante (voir figure
2.32).
Figure 2.32 Fermeture de la page daccueil
Un peu de paramtrage
Si vous avez dcoch Install Flex SDK lors de linstallation du logiciel, il faut lui
dire o se trouve le Flex SDK que nous avions tlcharg au dbut avant de pouvoir
lutiliser : autrement, il ne pourra pas compiler notre projet, ce qui serait bien dommage.
Ces manipulations vous seront galement utiles si vous mettez jour le Flex SDK
plus tard.
Commenons par nous rendre dans les paramtres du logiciel, laide du menu Tools
(voir figure 2.33).
40
Figure 2.33 Accs aux paramtres de FlashDevelop

La fentre des paramtres de Flashdevelop souvre ; slectionnez AS3Context dans la
liste de gauche, puis Installed Flex SDKs dans le panneau de droite. Ensuite, cliquez
sur le petit bouton avec trois points, comme la figure 2.34.
Figure 2.34 Paramtres de FlashDevelop

Le gestionnaire des SDK souvre et est normalement vide. Nous allons ajouter notre
SDK dans la liste : cliquez sur le bouton Ajouter en bas gauche (voir figure 2.35).
Un nouveau SDK est apparu dans la liste ! Il faut maintenant spcifier le chemin (Path)
41
Figure 2.35 diteur de collections InstalledSDK
du SDK en le slectionnant et en cliquant sur le petit bouton de droite trois points

(voir figure 2.36).
Figure 2.36 Mise en place du SDK
Choisissez le dossier o vous avez plac le SDK au dbut du chapitre, par exemple
D:\Flex SDK 4. Pour finir, validez en cliquant sur le bouton OK et fermez la fentre
des paramtres laide du bouton Close situ en bas droite.
42
Crons un projet Actionscript

Pour pouvoir programmer sereinement au mme endroit durant le cours, il nous faut
crer un projet Actionscript 3. Pour cela, allez dans le menu Project de la barre de
menus en haut, et cliquez sur New Project (voir figure 2.37).
Figure 2.37 Cration dun nouveau projet

Une nouvelle fentre apparat, proposant plusieurs types de projets. Slectionnez AS3
Project et donnez un nom votre projet dans le champ Name. Vous pouvez demander
Flashdevelop de vous crer automatiquement un dossier pour votre projet, en cochant
la case Create directory for project (voir figure 2.38).
Validez et notre projet est prt ! Flashdevelop a cr pour nous les dossiers et fichiers de
base quil faut pour commencer travailler sur notre programme Flash. Slectionnez
le panneau Project en bas droite : il nous affiche larborescence de notre projet (voir
figure 2.39).
Le dossier bin doit contenir tous les mdias qui seront chargs lexcution de notre
programme (pour linstant, nous allons le laisser tel quil est). Cest aussi le dossier
o notre fichier SWF sera cr la compilation. Le dossier lib sert regrouper tous
les mdias et librairies que vous pourriez importer dans votre programme, comme je
lai expliqu au tout dbut du chapitre. Laissons-le vide galement. Enfin, le dossier
src contient tous les fichiers de code qui composent notre programme. tendez-le,
et vous verrez que Flashdevelop a cr pour nous un fichier Actionscript principal
(reconnaissable la petite flche verte), quil a nomm Main.as. Double-cliquez dessus
pour louvrir dans lditeur.
Bien utiliser Flashdevelop

Avoir de bons outils ne suffit pas : il est primordial de bien savoir les utiliser ! Ainsi,
avant de tester notre projet, il est prfrable de faire un petit tour du propritaire.
43
Figure 2.38 Paramtrage du nouveau projet
Figure 2.39 Arborescence du projet
44
Linterface
Linterface de Flashdevelop, bien qucrite en anglais, est plutt claire et surtout trs
pratique (voir figure 2.40). Dtaillons-la ensemble.
Figure 2.40 Linterface de FlashDevelop

1. La barre de menu
Toutes les fonctionnalits de Flashdevelop sont accessibles dans ces menus.
File (Fichier) : vous trouverez ici toutes les commandes en rapport avec les fichiers,
comme la cration de nouveaux documents, la sauvegarde, limpression. . .
Edit (dition) : ce deuxime menu concerne le texte que vous tapez dans lditeur. Vous pouvez ainsi facilement annuler des modifications, copier-coller du texte,
commenter du code slectionn. . .
View (Affichage) : ici, vous pouvez modifier la prsentation de Flashdevelop, et rouvrir les panneaux que vous auriez malencontreusement ferm.
Search (Recherche) : si vous voulez effectuer des recherches de texte dans votre
document ou dans le contenu des fichiers de votre projet, passez par ce menu !
Debug (Dbogage) : ce menu est un peu plus technique et concerne les sessions
de dbogage que vous effectuerez dans Flashdevelop (comme avec fdb). Nous en
reparlerons plus tard.
Project (Project) : tout ce qui touche la gestion de vos projets, comme la cration,
louverture, mais aussi pour tester votre projet actuel.
Insert (Insertion) : ici vous pouvez insrer du texte spcial dans votre document,
comme lheure actuelle (timestamp) ou une couleur entre autres.
Refactor (Refactorisation) : derrire ce terme barbare se cachent les oprations automatiques de maintenance et de mise en forme de votre code afin de le retravailler
pour quil soit plus clair (Code formatter). Dans Flashdevelop se trouvent gale45

ment des outils de gnration de code pour travailler plus vite (Code generator).
Tools (Outils) : ici vous trouverez des outils pour le dveloppement en Flash, et
plusieurs fentres de paramtrage du logiciel.
Macros : il sagit de scripts lancer dans le logiciel pour automatiser certaines tches ;
toutefois, nous naborderons pas les macros de Flashdevelop dans ce cours.
Syntax (Syntaxe) : dans ce menu, vous pouvez spcifier Flashdevelop dans quel
langage vous tes en train de coder, afin quil puisse colorier le code de manire
adquate. En gnral, on nutilise pas ce menu, car Flashdevelop dtecte le type de
chaque fichier laide de son extension.
Help (Aide) : ce menu regroupe toutes les aides disponibles pour Flashdevelop, et
permet galement de vrifier les mises jour du logiciel.
2. La barre de raccourcis
Les commandes les plus utilises sont rassembles ici pour pouvoir les utiliser directement sans avoir passer par les menus.
3. Les raccourcis de dbogage
Cette zone de la barre des raccourcis est rserve aux boutons utiles pour compiler notre
projet (Build Project), le tester (Test Project) et changer le mode de dbogage
(choisir Debug revient ajouter le paramtre -debug=true au compilateur du Flex
SDK comme nous lavons vu plus haut).
4. Lditeur de texte
Cest ici que vous crirez vos programmes. gauche sont affichs les numros des lignes,
et en haut se trouvent les diffrents documents ouverts sous forme donglets.
5. Les panneaux de dveloppement
Ce sont des outils qui vous faciliteront la vie lorsque vous programmerez.
6. La console de sortie
Dans ce panneau seront affichs tous les messages de Flashdevelop (comme ltat de
la compilation par exemple) et les messages du lecteur Flash (par exemple, avec la
fonction trace()).
Lauto-compltion
Cette fonctionnalit est trs utile et vous lutiliserez en permanence pendant que vous
programmerez : en effet, elle peut terminer ce que vous tes en train de taper votre
place (toujours dans une optique de gain de temps) et peut galement vous aider
choisir quoi taper grce aux informations quelle propose.
Commenons par complter notre classe Main : placez-vous dans la fonction _init
aprs le commentaire // entry point (point dentre) et commencez taper trace.
Surprise ! Un menu souvre au bout du quatrime caractre, vous proposant dajouter
la fonction trace(), avec en bonus sa description ! (voir figure 2.41)

Pour valider votre choix, appuyez sur Entre et le mot trace est automatiquement
termin ! Bien entendu, cela na pas une grande utilit dans notre cas car le nom de la
46
Figure 2.41 Auto-compltion de la fonction trace()

fonction est trs court. Mais imaginez si vous aviez retenir toutes les fonctions et si
en plus leur nom fasait vingt caractres !
Il est galement possible dactiver lauto-compltion tout moment, mme
si lon na rien encore tap : il suffit dappuyer simultanment sur les touches
Ctrl et Espace.
Compiler et tester notre projet

Terminez votre ligne de code pour que votre programme affiche Hello world ! dans
la console. Comment a, vous ne vous souvenez plus comment faire ? ! Bon daccord, je
vous donne la ligne ajouter, mais cest bien parce que cest vous :
1
Voici quoi doit ressembler le fichier aprs modifications :

1
2
3
package {
import flash . events . Event ;
4
5
6
7
8
9
/* *
* ...
* @author Guillaume
*/
public class Main extends Sprite {
10
11
12
13
14
15
16
public function Main () : void {

if ( stage )
init () ;
else
addEventListener ( Event . ADDED_TO_STAGE , init ) ;
}
17
47

private function init ( e : Event = null ) : void {
removeEventListener ( Event . ADDED_TO_STAGE , init ) ;
// entry point
18
19
20
21
22
23
24
25
26
27
Mais pourquoi le code est diffrent par rapport tout lheure ?
Trs bonne question ! Flashdevelop, en crant notre projet, a automatiquement rempli cette classe avec le code de base de telle sorte quil ny ait aucun problme pour
nous. Les fonctions quil a rajout sont utiles dans certains cas pour viter des erreurs
daffichage. Retenez quil faut commencer programmer juste aprs le commentaire
// entry point seulement dans notre classe Main. Dans les autres classes que vous
crerez, ce code supplmentaire ne sera pas ncessaire.
Une fois que votre classe Main est prte, lancez la compilation en cliquant sur le
bouton en forme de flche bleue (Test Project)

dans la barre des raccourcis ou en
appuyant simultanment sur les touches Ctrl et Entre . Vous remarquerez quil y
a un bouton Build Project immdiatement gauche qui ne sert qu compiler notre
projet sans le lancer.
Si tout ce passe bien, une fentre du lecteur Flash souvre avec votre programme et la
console affiche notre message Hello world ! , comme la figure 2.42.
Figure 2.42 Lancement du programme

48
Cest aussi simple que cela !
En rsum
Lopration de vrification des erreurs, dassemblage des diffrents fichiers et de compression dun projet sappelle la compilation.
Le Flex SDK est un ensemble doutils de dveloppement, et notamment un compilateur permettant daboutir au fichier swf.
FlashDevelop est un IDE, cest--dire un outil qui permet dcrire, de compiler et
de tester du code Actionscript plus facilement.
En Actionscript, le code scrit lintrieur de fonctions, elles-mmes contenues
dans une classe, le tout plac dans un package.
Il est possible dinsrer des commentaires au milieu du code grce aux caractres
// , /* et */ .
Il existe une fonction trace() qui permet dcrire du texte dans la console, et est
principalement utilise pour les tapes de dbogage.
49
50
Chapitre
Les variables
Difficult :
Les variables sont un des lments les plus importants dans tous les langages de programmation : elles permettent de mmoriser des informations de toutes sortes. Sans elles, les
programmes seraient tous trs basiques et moins puissants, le monde informatique serait
alors dun ennui mortel.
Un petit exemple concret : vous voulez que votre programme vous dise bonjour, aprs lui
avoir donn votre nom. Une variable (appele monNom par exemple) se chargera alors de
mmoriser le mot que vous lui entrerez pour plus tard permettre au programme de vous
appeler par votre nom : il lui suffira de regarder ce quil se trouve dans la variable monNom.
51
CHAPITRE 3. LES VARIABLES
Dclarer et utiliser des variables

Dclaration
Le mot-cl var
La premire chose faire avant dutiliser des variables, cest de les crer :
1
var maVariable ;
Pour cela, nous avons notre disposition un mot-cl (ou mot rserv) obligatoire : var.
Cette instruction permet de dclarer une variable ; elle sutilise de la faon suivante :
var suivit dun espace et du nom de la variable.
Petit rappel : un mot-cl (ou rserv) est une expression qui est utilise par
le langage et qui lui est donc rserve, cest--dire que vous ne pouvez pas
appeler une variable var ou utiliser ce mot rserv pour autre chose que son
utilit premire.
Dsormais, vous savez crer une variable, mais le code prcdent nest pas trs utile.
En effet, chaque variable possde un type, indispensable, qui dcrit son comportement
et son utilit (par exemple : nombre, entier, chane de caractres, etc.). Sans ce type,
le langage ne saurait pas qui il a affaire en lisant une variable et surtout comment
lutiliser.
Noubliez pas de mettre le point-virgule en fin de ligne !
Comme pour les noms de classes, il est prfrable dutiliser la notation

Camel pour le nom de nos variables : leNomDeMaVariable au lieu de
lenomdemavariable. Vous pouvez galement utiliser lunderscore (_) pour
simuler les espaces qui eux sont interdits.
Le typage
Il faut donc assigner un type chaque nouvelle variable pour que le programme puisse
la reconnatre. Pour cela, on utilise les deux points ainsi :
1
var maVariable : sonType ;
Ce type suivra la variable tout au long de lexcution du programme.

Avant, en Actionscript 2, il tait possible de dclarer des variables sans les typer, le
lecteur Flash se chargeait de deviner le type de ces variables. Bien entendu, cette
technique est proscrire pour des raisons de performances et de rigueur (imaginez
52
DCLARER ET UTILISER DES VARIABLES

plusieurs centaines de variables qui vous avez affaire, mais dont vous ne connaissez
pas le type). Dsormais, les variables doivent tre types la cration : on appelle cela
le typage strict. Cest une des principales raisons de lamlioration des performances
des animations depuis le passage lActionscript 3.
Les diffrents types que vous pourrez utiliser seront dtaills un peu plus loin.
Initialiser la nouvelle variable
Aprs avoir cr une variable, il vous prendra peut-tre lenvie dy mettre quelque
chose pour la rutiliser plus tard :
1
var maVariable : sonType = ceQueJeMetsDedans ;
Vous remarquerez quon peut remplir une variable directement sa cration (ce qui est
drlement pratique), en mettant un signe gal aprs le type ; on appelle cette opration linitialisation. Ainsi, ds quelle sera cre, la variable maVariablesera du type
sonTypeet contiendra ceQueJeMetsDedans.
Vous ntes videmment pas obligs dinitialiser les variables, vous pourrez leur donner
une valeur (ou un contenu si vous prfrez) plus tard laide de laffectation.
Les valeurs par dfaut
Lorsque vous crez une variable et que vous ne linitialisez pas, elle nest pas tout fait
vide ; en effet, elle contient automatiquement une valeur par dfaut qui sera souvent
null, sauf quelques cas particuliers selon le type de la variable. Ainsi, si vous crivez
ceci :
1
var maVariable : sonType ;
maVariable contiendra sa valeur par dfaut, donne par son type.

Le mot-cl null est rserv lActionscript, vous ne pouvez donc pas appeler une variable null. Cette valeur remplace lancien mot-cl quivalent
undefined valable en Actionscript 2. Nanmoins, une variable que vous ninitialisez pas contient undefined si elle na pas de type, et vous pourrez rencontrer ce mot-cl avec les tableaux dans un des chapitres suivants.
Utiliser les variables

Affectation
Tout au long de lexcution du programme, vous aurez srement besoin de modifier le
contenu dune variable en fonction des besoins du moment. La mthode est presque
identique linitialisation, car on utilise nouveau le signe gal :
53

1
maVariable = nouveauContenu ;
Ainsi, la valeur nouveauContenu sera stocke dans la variable maVariable.

Il est absolument interdit daffecter une valeur une variable si cette dernire
nexiste pas. Cela naurait aucun sens et le compilateur vous le fera savoir en
refusant de compiler votre programme. Noubliez donc pas de dclarer vos
variables avant de les utiliser.
Lecture
Il est tout aussi intressant de pouvoir lire une variable pour utiliser son contenu : par
exemple, le programme aura besoin de regarder ce que contient la variable monNom pour
pouvoir afficher Bonjour Georges ! si jai mis Georges dans la variable avant.
Par exemple, pour copier le contenu de la variable a dans la variable b, il faut donc
crire :
1
b = a ; // Je prends ce qu ' il y a dans la variable a , et je le

mets dans b
Vous pouvez voir ainsi que la faon de procder est trs simple : il suffit de renseigner
le nom de la variable.
Petite piqre de rappel : // Je prends ce quil y a dans la
variable a, et je le mets dans b est un commentaire ; il permet dcrire des informations sur le programme destination dventuels
lecteurs ou pour vous-mmes afin de vous rappeler quoi sert ce que vous
avez tap l par exemple. Les commentaires ninfluent en aucune faon sur
le fonctionnement du programme, ils sont tout simplement ignors.
Avec les dclarations des variables, cela donnerait :
1
2
3
4
var a : typeDeA = contenuA ;

var b : typeDeB = contenuB ;
b = a ; // Je prends ce qu ' il y a dans la variable a , et je le
mets dans b
// La variable b contient maintenant " contenuA "
Les nombres
Les diffrents types
Comme vous pouvez vous en douter, les nombres sont trs utiliss dans le monde de
linformatique, tant donn que le numrique est bas sur des suites de 0 et de 1. Il
existe diffrents types de nombres en ActionScript 3, chacun ayant sa spcificit.
54
LES NOMBRES
Le type int
Le type int sert manipuler des entiers relatifs. Voici un exemple de dclaration et
dinitialisation de ce type de variables :
1
var monEntier : int = - 100 ;
Ce type permet de manipuler des nombres cods sur 32 bits (cest--dire 32 0 ou

1 ), donc compris entre -2 147 483 648 et 2 147 483 647. Si vous sortez de cet
encadrement, vous obtiendrez une erreur. La valeur par dfaut de ce type est 0.
Pour accder rapidement ces deux valeurs, utilisez respectivement
int.MIN_VALUE et int.MAX_VALUE. Ce sont des variables un peu spciales
car elles sont utilisables partout dans votre code et on ne peut que les lire.
On les appelle des constantes, notion que nous aborderons dans le chapitre
sur lorient objet.
Le type uint
Le type uint sert manipuler des entiers naturels ou non-signs (cest--dire positifs),
voici un exemple de dclaration et dinitialisation :
1
var monEntier : uint = 42 ;
Le type uint permet dutiliser des entiers naturels cods sur 32 bits galement, donc
compris entre 0 et 4 294 967 295. Comme le type int, la valeur par dfaut est 0, et
vous obtiendrez aussi une erreur si vous sortez de cet encadrement. Dans certaines
situations, lutilisation de ce type ralentit lgrement lexcution de votre programme.
Ainsi, je vous conseille dutiliser le type int si les nombres que vous voulez manipuler
sont infrieurs 2 147 483 647.
Pour accder rapidement ces deux valeurs, utilisez respectivement
uint.MIN_VALUE et uint.MAX_VALUE. Elles sont galement utilisables en
lecture seule partout dans votre code.
Le type Number
Le type Number sert manipuler tous les nombres (entiers comme flottants), dans un
intervalle extrmement grand. On peut presque considrer quon peut y mettre tous
les nombres. Voici comment les utiliser :
1
var monNombre : Number = 3 . 1415 ;
55

Comme dans la plupart des langages de programmation, et de faon gnrale
en informatique, on utilise la notation anglaise des nombres flottants (ou
virgule). Cest--dire qu la place de la virgule, on met un point : 3,14 crit
en franais donne 3.14 en Actionscript.
La valeur par dfaut de ce type est NaN.
Le mot-cl NaN signifie Not a Number (pas un nombre) : votre nombre prend
cette valeur si vous ne linitialisez pas une certaine valeur ou si vous tentez
dy stocker autre chose quun nombre.
Ainsi, le code suivant ne ferait pas derreur, mais la variable nbr aurait pour valeur
NaN :
1
2
var nbr : Number = Number ( " Je veux un nombre ! " ) ; // On force la

variable contenir du texte ...
trace ( nbr ) ; // Affiche : NaN
Pour accder rapidement la valeur minimum ou la valeur maximum autorise, utilisez respectivement Number.MIN_VALUE et Number.MAX_VALUE.
Une nouvelle fois, elles sont utilisables en lecture seule partout dans votre
code.
Vous tes curieux de savoir quels sont le minimum et le maximum autoriss ? Voici le
code pour les afficher :
1
2
3
4
trace ( Number . MIN_VALUE + " " + Number . MAX_VALUE ) ;

// Affiche : 4 . 9406564584124654e - 324 1 . 79769313486231e + 308
// Le " e " signifie " fois dix puissance " ; par exemple , 1e + 10
quivaut 1x10 ^ 10 = 10 000 000 000
// 1 . 79769313486231e + 308 est donc un nombre 309 chiffres
Si par mgarde vous essayez daffecter un nombre flottant (cest--dire

virgule, comme 3.14) une variable de type int ou uint, il sera automatiquement arrondi lentier infrieur avant dtre stock dans la variable. Par
exemple, 3.14 deviendra 3, et 45.9 deviendra 45.
Oprations sur les nombres

Les oprateurs de base
Pour effectuer une opration entre deux nombres, on procde comme sur les cahiers
de Maths lcole ! Lopration est effectue lors de lexcution du programme et le
rsultat peut tre stock dans une variable monNombre par exemple. Voici un tableau
qui regroupe les oprations de base :
56
LES NOMBRES
Nom de lopration
Addition
Soustraction
Multiplication
Division
Modulo
Symbole
+
*
/
%
Exemple
monNombre
monNombre
monNombre
monNombre
monNombre
=
=
=
=
=
1
8
2
8
8
+
*
/
%
4;
3;
3;
4;
5;
//
//
//
//
//
monNombre
monNombre
monNombre
monNombre
monNombre
=
=
=
=
=
5
5
6
2
3
Pour ceux qui ne le connatraient pas, le modulo est un oprateur moins

courant qui permet de renvoyer le reste de la division euclidienne entre deux
nombres.
Ces oprations peuvent tre effectues sur des variables des trois types de nombres que
nous avons vu prcdemment, mme en les mlangeant. Voici quelques exemples de
calculs :
1
2
3
4
5
var unEntier : uint = 3 + 42 ;

var unAutreEntier : int = - 25 ;
var monResultat : Number = unEntier * unAutreEntier ;
monResultat = monResultat / 100 ;
trace ( monResultat ) ; // Affiche : - 11 . 25
Contrairement beaucoup dautres langages, diviser par zro ne fera

pas planter votre programme. . . Le rsultat de lopration sera en fait
Number.POSITIVE_INFINITY, autrement dit, le nombre infini ! Faites trs
attention vrifier quune telle chose narrive pas, sinon vous pourriez avoir
des surprises lors de lexcution de votre programme. . .
Notez galement quil faut tre prudent sur le type de variables utilis pour les calculs.
Je rappelle quun nombre virgule sera automatiquement arrondi lentier infrieur
si vous tentez de laffecter une variable de type int ou uint. Reprez donc ce qui se
droule au fil de ces instructions :
1
2
3
4
var unEntier : uint =

var unNombre : Number
var monResultat : int
trace ( monResultat ) ;
2;
= 3 . 14 ;
= unEntier + unNombre ;
// Affiche : 5
Simplifier les calculs

Comme dans beaucoup de langages, il est possible en Actionscript de simplifier des
calculs de ce genre :
1
monResultat = monResultat / 100 ;
Ainsi lcriture de cette instruction peut tre simplifie et rduite sous la forme :
1
monResultat /= 100 ;
57

Ce code est donc plus rapide crire, et provoque le mme rsultat que prcdemment.
Bien videmment, cette manipulation nest pas rserve la division, mais peut tre
effectue avec nimporte quel autre oprateur arithmtique : +=, -=, *=, /= et %=.
Nous avons prsent fait le tour des oprateurs disponibles en Actionscript.
Mais quen est-il des autres oprations mathmatiques plus complexes,
comme la racine carre ?
En effet, il nexiste pas doprateurs arithmtiques en Actionscript 3 pour effectuer
de telles oprations. Heureusement, une classe un peu spciale appele Math est fournie
par Flash.
La classe Math
Cette classe na pas besoin dtre importe, elle est accessible en permanence. Elle
contient une flope doutils mathmatiques trs utiles comme les puissances, les fonctions trigonomtriques, les nombres alatoires. . .
Les puissances
Ces fonctions de la classe Math vous permettent de manipuler les puissances sur des
nombres :
1
2
3
4
5
var monNombre : Number = 42 ;

// Elever la puissance
trace ( Math . pow ( monNombre , 5 ) ) ;
// Racine carr e
trace ( Math . sqrt ( monNombre ) ) ;
Les arrondis
Il existe trois types darrondis : larrondi classique, larrondi lentier infrieur le plus
proche et larrondi lentier suprieur le plus proche :
1
2
3
4
5
6
7
58
var monNombre : Number = 3 . 1415 ;

// Arrondi
trace ( Math . round ( monNombre ) ) ; // 3
// Entier inf rieur
trace ( Math . floor ( monNombre ) ) ; // 3
// Entier sup rieur
trace ( Math . ceil ( monNombre ) ) ; // 4
LES NOMBRES
Trigonomtrie
Cosinus, sinus, tangente, arc-cosinus, arc-sinus et arc-tangente sont des fonctions trigonomtriques que nous propose la classe Math :
La valeur de \pi est accessible laide de Math.PI.
1
2
var angle1 : Number = Math . PI / 2 ;

var angle2 : Number = Math . PI / 6 ;
3
4
5
6
// Cosinus
trace ( Math . cos ( angle1 ) ) ;
// 6 . 123233995736766e - 17
7
8
9
10
// Sinus
trace ( Math . sin ( angle1 ) ) ;
// 1
11
12
13
14
// Tangente
trace ( Math . tan ( angle1 ) ) ;
// 163312 39353195370
15
16
17
18
// ArcCosinus
trace ( Math . acos ( angle2 / angle1 ) ) ;
// 1 . 2309594173407747
19
20
21
22
// ArcSinus
trace ( Math . asin ( angle2 / angle1 ) ) ;
// 0 . 3398369094541219
23
24
25
26
// ArcTangente
trace ( Math . atan ( angle1 ) ) ;
// 1 . 0038848218538872
Les angles sont toujours exprims en radians.
Il existe une variante de la fonction arc-tangente en Actionscript 3 :

Math.atan2(). Elle sert principalement calculer sans erreur langle entre
deux positions. Nous en aurons besoin plus loin dans le cours.
59

Nombre alatoire
Il serait trs intressant de fabriquer des nombres alatoires, pour des jeux par exemple.
Cela est possible avec la fonction Math.random() :
1
trace ( Math . random () ) ; // Affiche un nombre flottant al atoire

compris entre 0 et 1
Pour gnrer un nombre alatoire entre deux valeurs a et b (voir figure 3.1), il faut
utiliser la formule suivante :
1
trace ( a + Math . random () * ( b - a ) ) ;
Figure 3.1 Cration dun nombre alatoire
Les chanes de caractres

Les chanes de caractres sont galement trs utilises. Il sagit dune suite de caractres qui forme du texte. Par exemple, Hello world ! est une chane de caractres ;
son premier caractre est le H , et son dernier caractre est le ! .
Une chane de caractres est toujours entoure de guillemets, comme nous lavons
vu dans le chapitre prcdent :
1
Mais vous pouvez aussi mettre des apostrophes la place des guillemets :
1
trace ( ' Hello world ! ') ;
Attention toutefois ne pas mlanger les deux, cela ne marcherait pas. Ainsi,
le code trace("Hello world !); est incorrect.
chappement des caractres spciaux

Mais si je veux mettre des guillemets ou des apostrophes dans ma chane de
caractres ?
60
LES CHANES DE CARACTRES

Je vous voyais venir ! Effectivement, mettre des guillemets dans une chane de caractres guillemets ou des apostrophes dans une chane de caractres apostrophes serait problmatique : en effet, le compilateur pensera que vous avez termin
votre chane au deuxime guillemet ou apostrophe rencontr, et se demandera pourquoi
diable dautres caractres se baladent derrire !
Dans cet exemple, vous pouvez voir que la coloration syntaxique nous montre le problme :
1
trace ( " Hello . swf a dit : " Hello world ! " " ) ;
En effet, le Hello world ! nest dans ce cas plus considr comme faisant partie de
la chane de caractres. . .
Pour remdier cela, il faut chapper le ou les caractres qui posent problme. Cela
consiste mettre un autre caractre spcial, lantislash (\), qui permettra de dire que
le caractre suivant doit tre pris pour un caractre tout fait banal dans notre chane.
Ainsi, le code correct serait :
1
trace ( " Hello . swf a dit : \" Hello world !\" " ) ;
Vous pouvez galement remplacer les guillemets par des apostrophes dans les cas o
a vous arrange de faire ainsi :
1
trace ( ' Hello . swf a dit : " Hello world !" ') ;
Plus besoin dchapper, car ce nest plus le caractre guillemet qui prcise o dbute
et o se termine la chane, mais lapostrophe. Par contre, si vous voulez mettre une
apostrophe en plus, le problme va revenir :
1
trace ( ' Hello . swf m 'a dit : " Hello world ! " ') ;
Encore une fois, le compilateur ne va vraiment rien comprendre ce que vous lui
crivez. Solution : chapper le caractre apostrophe qui pose problme !
1
trace ( ' Hello . swf m \ ' a dit : " Hello world !" ') ;
Vous pouvez systmatiquement chapper les guillemets et apostrophes dans

les chanes de caractres si cela vous met laise.
trace ( ' Hello . swf m \ ' a dit : \" Hello world !\" ') ;
Utiliser les variables

Maintenant, si nous voulons mmoriser des chanes de caractres, il va falloir les
ranger dans des variables de type String. Par exemple, pour mmoriser notre phrase
Hello world ! dans la variable coucou, il faut procder ainsi :
61

1
2
var coucou : String = " Hello world ! " ;

trace ( coucou ) ; // Affiche : Hello world !
La valeur par dfaut dune variable de type String est null.
Concatnation de chanes
Concatner deux chanes de caractres consiste les assembler pour ne former quune seule chane. Par exemple, concatner la chane Hello avec la chane
world ! donnerait une nouvelle chane plus grande : Hello world ! . Pour cela, il
faut utiliser loprateur + (qui sert aussi additionner deux nombres), de cette faon :
1
" Hello " + " world ! "
Ainsi, si lon voulait afficher notre texte en deux parties, nous cririons ceci :
1
trace ( " Hello " + " world ! " ) ;
Il est alors possible de concatner des chanes avec des variables de tout type (y compris
avec des nombres) et de diffrentes manires :
1
2
3
4
5
6
var coucouDebut : String = " Hello " ;

var coucouFin : String = " ! " ;
var monNom : String = " J r me " ;
var monAge : int = 42 ;
trace ( coucouDebut + monNom + coucouFin + " Tu as " + monAge + "
ans , n 'est - ce pas ? " ) ;
// Affiche : Hello J r me ! Tu as 42 ans , n 'est - ce pas ?
7
8
9
trace ( Number . MIN_VALUE + " " + Number . MAX_VALUE ) ;

// Affiche : 4 . 9406564584124654e - 324 1 . 79769313486231e + 308
Quelques variables et fonctions utiles

Ces variables ou fonctions sont obligatoirement attaches une variable de type String
laide dun point. Vous ne pouvez pas les utiliser sur une chane de caractres simple
comme "Hello world !".
Longueur dune chane
Pour connatre la longueur dune chane de caractres, cest--dire, le nombre de
caractres quelle contient, il faut utiliser la variable length disponible sur notre chane
de cette manire :
62

1
2
3

trace ( " Cette cha ne contient " + coucou . length + " caract res . "
);
// Affiche : Cette cha ne contient 13 caract res .
Le point est important : il signifie que cest la longueur de cette chane particulire que
lon veut.
Changer la casse dune chane

La casse est ltat dune lettre, cest--dire si elle est en minuscule ou en majuscule.
Il est possible de modifier la casse de lensemble dune chane de caractres
en utilisant les fonctions toLowerCase() (en casse minuscule) et toUpperCase() (en
casse majuscule) :
1
2
3
4
5

// En minuscules
trace ( coucou . toLowerCase () ) ; // hello world !
// En majuscules
trace ( coucou . toUpperCase () ) ; // HELLO WORLD !
Rechercher dans une chane

Il peut tre utile de rechercher un ou plusieurs caractres dans une chane. Pour cela,
on utilise la fonction indexOf() (position de) :
1
maVariable . indexOf ( " Cha ne recherch e " ) ;
La fonction renvoie la position du premier caractre de la chane recherch dans la

variable, ou -1 si elle ne la pas trouv.
Vous pouvez aussi spcifier une variable de type String entre les parenthses,
au lieu dune chane de caractres simple.
Cherchons la position de la premire lettre a dans notre variable :
1
2

trace ( coucou . indexOf ( " a " ) ) ; // -1 , on n 'a rien trouv
Effectivement, il ny a pas de a dans notre chane. . . Retentons notre chance avec

le mot world :
1
trace ( coucou . indexOf ( " world " ) ) ; // 6 ! Victoire !
Bravo, nous avons trouv le mot world la septime lettre !

63

Il se situe la septime position, car le numro des caractres commence
zro : le premier caractre a le numro 0, le deuxime a le numro 1 et
ainsi de suite. Du coup, pour avoir le numro du dernier caractre dans la
chane, il faut prendre sa longueur moins un : coucou.length - 1.
Remplacer dans une chane

Cette fonction replace() est similaire la fonction de recherche, mais il faut en plus
indiquer le texte qui va remplacer lancien.
1
maVariable . replace ( " Cha ne recherch e " , " Cha ne ins rer la
place " ) ;
Modifions dynamiquement notre chane pour remplacer world par Jrme :

1
trace ( coucou . replace ( " world " , " J r me " ) ) ; // Hello J r me !
La variable de dpart nest pas modifie : la fonction se contente de renvoyer la nouvelle

chane que lon peut afficher ou mettre dans une variable :
1
2
3
4

var salut : String = coucou . replace ( " world " , " J r me " ) ;
trace ( salut ) ; // Hello J r me !
trace ( coucou ) ; // Hello world !
Le texte nest remplac quune seule fois : ds que le texte recherch est
rencontr, il est remplac et la fonction sarrte.
1
2
var coucou : String = " Hello world world world ! " ;

trace ( coucou . replace ( " world " , " J r me " ) ) ; // Hello J r me world
world !
Pour pouvoir remplacer tous les world en Jrme , il faut faire autant de
replace()que ncessaire :
1
2
3
4
5
6
7
64
var coucou : String = " Hello world world world ! " ;

coucou = coucou . replace ( " world " , " J r me " ) ;
trace ( coucou ) ; // Hello J r me world world !
trace ( coucou ) ; // Hello J r me J r me world !
trace ( coucou ) ; // Hello J r me J r me J r me !

Il existe une autre mthode bien plus efficace et puissante qui consiste utiliser les expressions rgulires (ou RegExp) : ce sont des codes suivant
des rgles prcises, capables de rechercher et de remplacer du texte plusieurs fois dans une mme chane, ceci parmi une foule dautres choses fort
utiles. Malheureusement, cette notion est plutt complexe apprhender, je
ne laborderais pas dans le cours.
En rsum
Une variable permet de mmoriser une valeur.
Le mot-cl var sert dclarer une variable qui peut tre affecte dune valeur par
un signe = .
On utilise les trois types int, uint et Number pour des valeurs numriques.
Pour effectuer des calculs, il existe principalement les oprateurs de base : +, -,
*, / et %.
Grce la classe Math, il est possible de raliser des oprations mathmatiques
complexes.
Le type String est rserv lutilisation des chanes de caractres.
Diffrentes fonctions permettent de manipuler les chanes de caractres et il est
possible de les concatner grce loprateur +.
65
66
Chapitre
Les conditions
Difficult :
Nous avons vu dans le prcdent chapitre comment manipuler les nombres laide doprateurs
et de variables. Nous allons voir prsent comment tester le contenu de ces variables ;
ainsi vous pourrez excuter des instructions ou non pour les diffrentes valeurs que pourront
prendre vos variables. Comme vous pourrez le voir, les conditions sont trs utiles dans le
monde de linformatique, et sont la base de linteractivit des machines, sans quoi elles
feraient toujours la mme chose !
67
CHAPITRE 4. LES CONDITIONS
criture dune condition

Quest-ce quune condition ?
Les conditions permettent de tester le contenu dune ou plusieurs variables. Ainsi,
vous pourrez excuter des instructions diffrentes suivant le rsultat du test. Grce ces
structures conditionnelles, le programme sera alors en mesure de prendre des dcisions.
Nos programmes seront donc moins monotones et pourront ragir diffremment suivant
les circonstances : imaginez si tous les programmes faisaient exactement la mme chose
quel que soit le contexte, cela serait bien ennuyeux ! Voici le genre dinstructions que
nous serons capables de raliser laide des conditions :
1
2
SI ma condition est vraie

ALORS effectuer mes instructions
Dans une condition, nous pourrons ainsi tester diffrentes choses. Par exemple, nous
pourrions tester un nombre entier pour savoir sil est positif ou non. Nous cherchons
donc une relation entre deux valeurs pour pouvoir les comparer. Pour cela, nous utiliserons donc divers oprateurs prsents dans la suite de ce cours. Si la condition est
vraie, alors les instructions qui la suivent sont excutes. Dans le cas contraire, elles
sont tout simplement ignores.
Ne vous inquitez pas si vous avez du mal saisir le concept, vous comprendrez mieux
au fil du chapitre.
En Actionscript, comme dans beaucoup dautres langages, les conditions renvoient automatiquement une valeur de type Boolean comme nous le verrons
plus loin dans le chapitre : true pour vraie et false pour fausse.
Les oprateurs relationnels

Les oprateurs relationnels permettent de comparer une variable une valeur ou
deux variables entre elles. Dans le tableau ci-dessous sont rpertoris les diffrents
symboles correspondants. Ces symboles seront utiliss en permanence, cest pourquoi
il serait judicieux de les retenir.
De manire gnrale, les oprateurs sont utiliss ainsi : une variable ou une valeur,
loprateur et une autre variable ou valeur. Voici quelques exemples de conditions :
1
2
3
4
// Cette condition est vraie si monEntier contient un nombre

sup rieur 2
monEntier > 2
// Cette deuxi me condition est vraie si maVariable et
monAutreVariable contiennent la m me valeur
monVariable == monAutreVariable
Vous pouvez galement comparer des chanes de caractres :

68
CRITURE DUNE CONDITION

Oprateur
1
2
3
4
5
6
<
Signification pour des valeurs numriques

est infrieur
>
est suprieur
<=
est infrieur ou gal
>=
est suprieur ou gal
==
!=
===
!==
est
est
est
est
gal
diffrent de
strictement gal
strictement diffrent de
Signification pour des caractres

est avant dans lordre alphabtique
est aprs dans lordre alphabtique
est avant dans lordre alphabtique ou identique
est aprs dans lordre alphabtique ou identique
est identique
est diffrent de
est strictement identique
est strictement diffrent de
var t1 : String = " Salut " ;

var t2 : String = " Salut " ;
var t3 : String = " Bonjour " ;
trace ( t1 == t2 ) ; // Affiche : true
trace ( t1 == t3 ) ; // Affiche : false
trace ( t1 > t3 ) ; // Affiche : true , car Salut est apr s Bonjour
dans l ' ordre alphab tique
Vous remarquerez que le test dgalit seffectue laide de deux signes = .

Les dbutants omettent souvent le deuxime symbole = , ce qui est source
derreurs dans votre code. En effet, le symbole = seul est un signe daffectation pour les variables comme nous lavons vu dans le prcdent chapitre.
Comparer deux variables : une question de types

Un oprateur relationnel permet de comparer uniquement deux expressions du mme
type. Il nest pas possible de comparer deux variables dont lune, par exemple, serait de
type int et lautre de type String. Si cela se produisait, le compilateur vous afficherait
un message derreur de ce type : Error : Comparison between. . . . Toutefois, il existe
une exception : les nombres qui peuvent tre compars entre eux mme si leur type
varie entre int, uint et Number. Par exemple, le code suivant fonctionnera sans erreur :
1
2
3
var nombre : Number = 0 . 4 ;

var entier : int = 1 ;
trace ( nombre < entier ) ; // Affiche : true
Mais alors, comment puis-je facilement comparer un nombre et une chane

de caractres ?
69

Et bien, il suffit de transformer lune de nos deux variables pour que les deux aient
exactement le mme type ! Par exemple, transformons le nombre en chane de caractres :
1
2
3

var texte : String = " 3 . 14 " ;
trace ( nombre . toString () == texte ) ; // Affiche : true
En effet, taper .toString() derrire notre variable de type Number transforme sa valeur
en chane de caractres afin que la comparaison fonctionne correctement !
La variable nombre nest pas rellement transforme, elle reste de type Number
par la suite.
Prcisions sur les oprateurs stricts

Les oprateurs stricts (=== et !==) servent comparer deux objets quelconques (par
exemple, deux variables) en regardant non seulement leur valeur, mais aussi leur type.
Ces oprateurs sont peu utiliss : en gnral, on connat lavance le type des variables
que lon manipule. Par exemple, je dclare et initialise trois variables de type Object,
cest--dire quelles nont pas de type bien dfini et que lon peut y mettre ce que
lon souhaite ; attention toutefois ne pas abuser de ce type un peu spcial, il ralentit
lexcution de votre programme. Ensuite, je teste la valeur de ces variables avec ==,
pour finalement tester leur valeur et leur type en mme temps avec ===. De toute
vidence, le caractre 3 nest pas du mme type que lentier 3.
1
2
3
4
5
6
var nom : Object = " 42 " ;

var prenom : Object = " 42 " ;
var age : Object = 42
trace ( nom === prenom ) ; // Affiche : true
trace ( nom == age ) ; // Affiche : true
trace ( nom === age ) ; // Affiche : false
Dans ce cas trs prcis, votre programme Flash convertira automatiquement le

format des variables lorsquil est ncessaire, sauf si vous utilisez les oprateurs
=== ou !==. Ainsi, la comparaison entre la chane de caractres et lentier se
droule sans accroc.
Les oprateurs logiques

Contrairement aux oprateurs prcdents qui permettaient de comparer des valeurs, les
oprateurs logiques servent combiner plusieurs conditions. Ceux-ci peuvent avoir
leur utilit lorsque nous voulons tester par exemple, si un nombre est compris dans un
intervalle. Les oprateurs relationnels ne permettent pas ce genre de comparaison.
70
CRITURE DUNE CONDITION

Nous pouvons donc contourner le problme en combinant plusieurs conditions. Prenons
un exemple : nous voulons savoir si une variable monNombre est comprise entre 0 et 10.
Pour cela nous pourrions dcomposer ce test en deux conditions :
monNombre est suprieur 0.
monNombre est infrieur 10.
Les oprateurs logiques nous permettent alors dassocier ces deux conditions en une
seule : monNombre > 0 ET monNombre < 10.
Le tableau ci-dessous prsente donc ces diffrents oprateurs, ainsi que les symboles
qui leur sont associs :
Oprateur
!
&&
||
Signification
NON logique
ET logique
OU logique
Ainsi, nous allons comparer notre nombre par rapport un intervalle laide de loprateur && :
1
2
// Test pour savoir si monNombre est compris entre 0 et 10

monNombre > 0 && monNombre < 10
La priorit des oprateurs

Pour dcider dans quel ordre les diffrentes oprations seront effectues, les oprateurs
respectent les rgles de priorit suivantes :
Les oprateurs arithmtiques (+, -, *, /, %) sont prioritaires par rapport aux
oprateurs relationnels (==, !=, <, >, etc. . .).
Les oprateurs relationnels sont prioritaires par rapport aux oprateurs logiques
(!, && et ||).
Les oprations entoures de parenthses sont toujours prioritaires.
Ainsi la condition 3 + 4 > 5 est vraie du fait que laddition est effectue avant la
comparaison.
Quelques exemples doprations imbriques :
1
2
3
4
5
trace ( 1
trace ( 1
trace ( 1
trace ( 1
trace ( 1
== 2 ) ; // Affiche : false
+ 1 == 2 ) ; // Affiche : true
== 2 || 2 == 2 ) ; // Affiche : true
!= 2 && 1 + 1 == 2 ) ; // Affiche : true
!= 2 && 1 + 2 == 2 ) ; // Affiche : false
Pour mieux comprendre lutilisation de ces conditions, nous allons tudier diffrentes
structures qui les utilisent. Commenons tout de suite avec linstruction if...else.
71
Linstruction if. . .else

La structure de base
La syntaxe
Linstruction if...else est la structure de base des conditions. Grce elle, nous
pouvons excuter des instructions diffrentes suivant si la condition est vraie ou fausse.
Sans plus attendre, voyons la structure if...else crite en Actionscript :
1
2
3
4
5
6
7
8
if ( /* Condition */ )
{
// Instructions si la condition est vraie
}
else
{
// Instructions si la condition est fausse
}
Vous remarquerez donc, dans cette structure, les deux blocs dinstructions dfinis par les
paires daccolades. Si la condition est vrifie, alors le premier bloc dinstructions sera
excut, sinon (traduction du mot else ) ce sera le second. Bien entendu, lcriture
du bloc else nest pas obligatoire. En revanche, il nest pas possible dcrire un bloc
else seul. Vous pourriez donc vous contenter du code suivant :
1
2
3
4
if ( /* Condition */ )
{
// Instructions si la condition est vraie
}
Parce que rien ne vaut un bon exemple, nous allons tout de suite tester une premire
condition dans notre IDE. Pour cela, nous prendrons une variable nomme maVie
reprsentant, par exemple, la vie restante dans un jeu quelconque. Nous pourrions
alors tester si vous tes encore en vie ou si vous tes mort. Voici donc le code insrer
juste aprs le commentaire // entry point de votre classe Main :
1
var maVie : uint = 1 ;
2
3
4
5
6
7
8
9
10
if ( maVie == 0 )
{
trace ( " Vous tes mort . " ) ;
}
else
{
trace ( " Vous tes toujours en vie . " ) ;
}
11
12
// Affiche : Vous tes toujours en vie .
Ici la variable maVie est gale 1, et donc la condition maVie == 0 est fausse. Ainsi, lors
de lexcution, seule linstruction lintrieur des accolades du else sera excute. Vous
72
LINSTRUCTION IF. . .ELSE

verrez donc apparaitre le message : Vous tes toujours en vie. Nhsitez pas tester
ce code avec diffrentes valeurs pour maVie afin de bien comprendre le fonctionnement.
Pour crire une condition if seule ou if...else, il faut respecter un certain
nombre de rgles et de conventions que nous allons dtailler.
Les rgles et conventions dcriture

Nous allons maintenant dfinir quelles sont les diffrentes rgles dcriture ainsi que
des conventions fortement recommandes. Tout dabord, vous aurez srement remarqu labsence de point-virgule ; aprs les accolades. En effet, les conditions ne
se terminent jamais par un point-virgule. Dautre part, les parenthses qui entourent
votre condition sont obligatoires. En revanche, les accolades peuvent tre facultatives
mais uniquement dans un cas ; il sagit du cas o il ny a quune seule instruction
lintrieur du bloc dinstructions. Il est alors possible dcrire votre condition suivant
lune des trois formes ci-dessous :
1
2
3
4
if ( maVie == 0 )
else
ou bien :
1
2
3
4
5
6
if ( maVie == 0 )
else
{
}
ou encore :
1
2
3
4
5
6
if ( maVie == 0 )
{
}
else
Pour finir ce paragraphe, nous parlerons dune chose trs importante en termes de
prsentation. Vous aurez certainement remarqu la mise en forme utilise depuis le
dbut pour crire les conditions :
Laccolade ouvrante sur une ligne.
Vos instructions dcales vers la droite laide dune tabulation.
Laccolade fermante sur une ligne.
73

Cette mise en forme est appele lindentation et nest pas obligatoire cependant, il
est trs fortement dconseill de tout crire sur une seule ligne ou de ne pas dcaler
les instructions lintrieur des accolades. En effet, respecter ces rgles vous permettra
de rendre vos codes beaucoup plus clairs et lisibles par vous mais aussi par dautres
personnes qui ne connatront pas la faon dont vous avez ralis votre programme.
Les ternaires
Dans certains cas, il est possible de condenser des conditions : on appelle cela les
expressions ternaires. Cette technique nest pas applicable tout le temps et il ne
faut pas en abuser. Pour introduire cette notion, nous allons partir du code suivant :
1
2
3
4
5
6
var monMessage : String ;

if ( maVie == 0 )
monMessage = " Vous tes mort . " ;
else
monMessage = " Vous tes toujours en vie . " ;
trace ( monMessage ) ;
Vous remarquerez quici la condition sert uniquement affecter une variable dune
valeur qui dpend dune condition. Les expressions ternaires ne peuvent tre utilises
que dans ce cas-l ! Il est alors possible de rcrire le code prcdent sous une forme
condense :
1
2
var monMessage : String = ( maVie == 0 ) ? " Vous tes mort . " : "
Vous tes toujours en vie . " ;
trace ( monMessage ) ;
Le principe est alors dcrire lensemble de la condition en une seule ligne et daffecter
directement la variable. Cest une forme dcriture qui peut tre pratique, mais sachez
quen ralit elle est trs peu utilise car elle est difficile lire. Utilisez donc les expressions ternaires pour diminuer le volume de votre code, mais tchez de garder un code
qui soit le plus facilement lisible !
Lcriture des expressions ternaires est assez spciale et souvent trompeuse.
Notez donc la prsence du symbole ? qui permet de tester la condition
place juste avant, ainsi que le signe : permettant de remplacer le motcl else et de sparer les instructions.
Le type boolen
En Actionscript, il existe un type de variable de type boolen : Boolean. Ces variables ne peuvent prendre que deux valeurs : true ou false. Les boolens sont trs
utiliss avec les conditions car ils permettent facilement dexprimer si une condition
est vraie ou fausse. Dailleurs, une condition est elle-mme exprime sous la forme
dun boolen. Pour sen assurer, vous allez tester le code suivant :
74
LINSTRUCTION IF. . .ELSE

1
2
3
4
if ( true )
trace ( " Ma condition est vraie . " ) ;
else
trace ( " Ma condition est fausse . " ) ;
5
6
// Affiche : Ma condition est vraie .
Nous pouvons remarquer quen effet la condition true est vraie, cest pourquoi lutilisation de variables de type boolen peut tre prfrable. Il nest alors plus ncessaire
dcrire le test == true pour une variable de type boolen. Ainsi, si vous utilisez
des noms judicieux pour vos variables, le code paratra plus clair :
1
var estEnVie : Boolean = true ;
2
3
4
5
6
7
8
9
10
if ( estEnVie )
{
}
else
{
}
11
12
// Affiche : Vous tes toujours en vie .
tant donn que le rsultat dune condition est un boolen, il est tout fait possible
de le stocker dans une variable :
1
2
3
var maVie : uint = 1 ;

var estEnVie : Boolean = ( maVie > 0 ) ;
trace ( estEnVie ) ; // Affiche : true
Lutilisation des boolens sert principalement allger votre code et le

rendre plus lisible. Encore une fois, choisissez des noms explicites pour vos
variables, cela permettra de faire plus facilement ressortir la logique de votre
programme.
La structure avec else if

Avant de clore cette partie sur la structure if...else, nous allons voir comment raliser
des tests supplmentaires avec else if. Ici, rien de bien compliqu, cest pourquoi vous
comprendrez aisment le code ci-dessous :
1
var monNombre : int = 1 ;
2
3
4
5
if ( monNombre < 0 )
{
trace ( " Ce nombre est n gatif . " ) ;
75

6
7
8
9
10
11
12
13
14
}
else if ( monNombre == 0 )
{
trace ( " Ce nombre est nul . " ) ;
}
else
{
trace ( " Ce nombre est positif . " ) ;
}
15
16
// Affiche : Ce nombre est positif .
Bien quil soit possible deffectuer plusieurs tests la suite laide de cette mthode,
cela peut savrer assez rptitif. Cest pourquoi, il existe une structure qui permet
dallger lcriture de telles conditions : il sagit de linstruction switch que nous allons
dtailler dans la suite.
Linstruction switch
Lutilisation conventionnelle
Face la structure if...else, la condition switch permet de simplifier et dallger
le code lorsque vous voulez tester diffrentes valeurs pour une mme variable. Cette
structure noffre pas plus de possibilits que celle en if...else, il sagit simplement
dune manire diffrente dcrire des conditions. Voici comment se prsente linstruction
switch :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
switch ( /* Variable */ )
{
case /* Argument */ :
// Instructions
break ;
// Instructions
break ;
// Instructions
break ;
default :
// Instructions
}
Pour utiliser cette structure, il suffit de renseigner la variable tester puis dtudier
les diffrents arguments. Notez la prsence de linstruction break; qui permet de
sortir du switch. Cette instruction est obligatoire, en cas dabsence, les instructions
situes en dessous seraient excutes. Enfin, le default correspond au cas par dfaut,
nous pouvons le comparer au else dune instruction if...else. Voici un exemple de
code que vous pouvez tester :
76
LINSTRUCTION SWITCH
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
var monNombre : int

switch ( monNombre )
{
case 0 :
trace ( " Ce
break ;
case 1 :
trace ( " Ce
break ;
case 2 :
trace ( " Ce
break ;
default :
trace ( " Ce
}
= 1;
nombre vaut 0 . " ) ;

nombre ne vaut ni 0 , ni 1 , ni 2 . " ) ;
Notez quaprs chaque argument vous devez crire un double point et non
un point-virgule.
Une utilisation spcifique lActionscript

Contrairement dautres langages tels que le C ou encore le Java, linstruction switch
en Actionscript ne permet pas uniquement de faire des galits. En plaant la valeur
true la place de la variable, il est alors possible de la comparer avec un autre boolen, en particulier une condition. Voici la structure switch pouvant tester diverses
conditions :
1
2
3
4
5
6
7
8
9
10
11
12
switch ( true )
{
case ( /* Condition */ ) :
// Instructions
break ;
// Instructions
break ;
// Instructions
break ;
}
Voici un exemple concret qui permet de tester si une variable monNombre est un nombre
ngatif, nul ou positif :
1
2
3
4
var monNombre : int = 1 ;

switch ( true )
{
case ( monNombre < 0 ) :
77

5
6
7
8
9
10
11
12
13
trace ( " Ce nombre est n gatif . " ) ;

break ;
case ( monNombre == 0 ) :
trace ( " Ce nombre est nul . " ) ;
break ;
case ( monNombre > 0 ) :
trace ( " Ce nombre est positif . " ) ;
break ;
En rsum
Grce aux conditions, nous pouvons effectuer des choses diffrentes suivant ltat
dune ou plusieurs variables.
Les conditions sont ralises laide doprateurs relationnels et logiques, dont
le rsultat est un boolen.
Linstruction if...else est la plus utilise.
Les expressions ternaires permettent de condenser lcriture dune instruction
if...else.
Lorsque vous avez une multitude de valeurs tester, linstruction switch est plus
approprie.
78
Chapitre
Les boucles
Difficult :
Dans le chapitre prcdent, nous avons vu comment raliser des conditions et permettre
ainsi aux machines de faire des choix. Cest dj un grand pas dans le monde informatique,
mais ce nest pas suffisant : prsent, nous allons introduire les boucles !
Les boucles sont lies la notion de rptitivit : il sagit en fait de ritrer une srie
dinstructions plusieurs fois. Les boucles sont indispensables dans tout un tas de situations, par exemple lorsque nous demandons lutilisateur de jouer tant que la partie nest
pas termine. Pour cela, nous disposons de trois boucles en Actionscript 3 que nous
dtaillerons au fil du chapitre. tant donn que nous avons dj vu comment crire une
condition, ce chapitre devrait tre relativement simple apprhender.
79
CHAPITRE 5. LES BOUCLES
La boucle while
Le principe
Comme nous lavons dit prcdemment, les boucles permettent de rpter des instructions un certain nombre de fois. La difficult est alors de savoir quand ces instructions
doivent cesser dtre rptes. Pour cela, nous aurons besoin des conditions. Sans plus
attendre, voici le genre dinstructions ralisables laide des boucles :
1
2
TANT QUE ma condition est vraie

ALORS effectuer mes instructions
Dans une boucle while, la condition sutilise exactement de la mme manire que pour
une instruction if...else. Il faudra donc dclarer une variable avant la boucle puis
la tester lintrieur de la condition. En revanche, dans ce cas, la variable devra tre
mise jour lintrieur de la boucle pour pouvoir en sortir. En effet, pour stopper
la rptition des instructions, la condition doit obligatoirement devenir fausse un
certain moment. Oublier de mettre jour cette variable conduirait une boucle infinie,
les instructions se rpteraient alors linfini.
Dans le cas dune boucle while, la condition est teste avant dentrer dans la
boucle. Ainsi, si la condition est dj fausse avant la boucle, les instructions
lintrieur de celle-ci ne seront jamais excutes.
Vous comprendrez mieux le fonctionnement des boucles au fur et mesure de la
lecture de ce chapitre.
criture en Actionscript
En Actionscript, la boucle while permet de grer toutes les situations : celles que
nous verrons plus tard sont lgrement diffrentes, mais noffrent aucune fonctionnalit
supplmentaire. La structure dune boucle est trs similaire celle des structures
conditionnelles vues prcdemment. Voici donc comment crire une boucle while en
Actionscript :
1
2
3
4
while ( /* Condition */ )
{
// Instructions si vraie
}
Comme pour linstruction if...else, les accolades deviennent facultatives sil ny a

quune seule condition :
1
2
80
while ( /* Condition */ )
// Instruction si vraie
LA BOUCLE WHILE
Cette seconde syntaxe est correcte : en crivant cela vous naurez pas de
message derreur. Cependant, dans une boucle digne de ce nom, vous naurez
en ralit que trs rarement une seule instruction. En effet, votre boucle
contiendra toujours au moins une instruction ainsi quune mise jour de
votre variable.
Afin de mieux comprendre le fonctionnement et la syntaxe dune boucle while, nous
allons voir diffrents exemples dans la suite de ce cours.
Exemples dutilisation
Pour commencer, nous allons tester une boucle qui affiche la valeur de notre variable
teste dans la condition. Voici le code source de notre boucle tester :
var i : uint = 0 ;
while ( i < 5 )
{
trace ( i ) ;
i = i + 1;
}
1
2
3
4
5
6
Si vous lancez le projet, vous devriez obtenir ceci dans la console de sortie :
0
1
2
3
4
Vous constaterez alors que la valeur 5 nest pas affiche. Effectivement,

lorsque notre variable i prend cette valeur, la condition i < 5 nest plus
vrifie ; linstruction trace(i) nest donc plus excute. Il faudra ainsi tre
vigilant sur lcriture de votre condition pour que votre boucle sexcute bien
comme vous le dsirez.
Lintrt dutiliser une boucle while est que nous navons pas besoin de connatre
lavance ou de nous soucier du nombre de rptitions. Pour illustrer cela, nous allons
prendre un exemple : imaginons que nous cherchions la puissance de 2 correspondant
1024. Nous devons alors calculer les puissances successives de 2 jusqu atteindre 1024.
Cependant, dans notre cas, nous ne savons pas combien de fois nous allons devoir
rpter lopration. Nous utiliserons donc une boucle while de la manire suivante :
1
2
3
4
5
6
var monNombre : uint = 2 ;

var i : uint = 1 ;
while ( monNombre != 1024 )
{
i = i + 1;
monNombre *= 2 ;
81

}
trace ( i ) ; // Affiche : 10
7
8
En effet, pour ceux qui connaissaient dj la rponse : 210 = 1024. Notre boucle sest
donc excute 9 fois ce qui correspond i = 10. Nous voyons bien ici que nous navions
pas besoin de connatre lavance le nombre de rptitions de la boucle.
Quelques astuces
Vous savez dj tout ce quil faut savoir sur la boucle while cependant, je vais vous
donner maintenant quelques astuces pour amliorer la lisibilit de votre code. Ces
conseils ne sont en aucun cas une obligation, il sagit principalement de pratiques trs
courantes chez les programmeurs. Elles permettront dallger votre code source mais
galement de le rendre plus lisible pour un autre programmeur. Voici donc ces astuces
fortement recommandes :
Traditionnellement, en Actionscript et dans beaucoup dautres langages, on utilise
les noms de variables i, j et k pour compter lintrieur dune boucle. En utilisant ces
noms, vous facilitez la lecture de votre code, surtout si celui-ci est assez consquent.
Lorsque vous utiliserez des boucles, vous serez trs souvent amen incrmenter ou
dcrmenter vos variables : i = i + 1 ou i = i- 1. Pour simplifier lcriture, nous
pouvons utiliser pour lincrmentation i++ et pour la dcrmentation i.
Enfin, nous allons revenir sur la notion de boucle infinie. Comme nous lavons dit, il
sagit dune boucle dont la condition est toujours vrifie. Les instructions lintrieur
sont alors rptes linfini. En voici un exemple :
var maCondition : Boolean = true ;
while ( maCondition )
{
trace ( " Ceci est une boucle infinie " ) ;
}
1
2
3
4
5
Vous vous en doutez certainement, cette boucle va afficher le message : Ceci est une
boucle infinie un nombre indfini de fois, comme ceci :
Ceci est une boucle infinie
...
En gnral, il faut tout prix viter dcrire ce genre de choses. Cependant, ce type de
boucles peut savrer utile dans certains cas.
La boucle do. . .while

Nous allons prsent parler de la boucle do...while qui est une voisine trs proche
de la boucle while. Toutefois, nous pouvons noter une diffrence dans la syntaxe par
82
LA BOUCLE DO. . .WHILE

lapparition du mot do ainsi que du transfert de la condition en fin de boucle. Ceci
apporte une lgre diffrence dans linterprtation du code, mais nous y reviendrons
aprs. Voici la syntaxe de cette nouvelle boucle :
1
2
3
4
do
{
// Instructions si vraie
} while ( /* Condition */ ) ;
Notez cependant lapparition dun point-virgule ; aprs la condition. Loubli de ce point-virgule est une erreur trs courante chez les dbutants. Veillez
donc ne pas commettre cette erreur, cela vous vitera des problmes de
compilation.
Quelle est la diffrence avec la boucle prcdente ?
Dans une boucle while classique, la condition est en dbut de boucle. Cest pourquoi la
boucle peut ne jamais tre excute si la condition est fausse ds le dpart. En revanche,
dans une boucle do...while, la condition est place la fin de la boucle. De ce fait,
la boucle sexcutera toujours au moins une fois. Il est donc possible dutiliser cette
boucle pour sassurer que le programme rentrera au moins une fois dans la boucle. Voici
un exemple de calcul de PGCD :
1
2
3
4
5
6
7
8
9
var nombre1 : uint = 556 ;

var nombre2 : uint = 148 ;
do
{
var reste : uint = nombre1 % nombre2 ;
nombre1 = nombre2 ;
nombre2 = reste ;
} while ( nombre2 != 0 ) ;
trace ( " PGCD = " + nombre1 ) ; // Affiche : PGCD = 4
Petit rappel : PGCD pour Plus Grand Commun Diviseur. Si vous ne vous
souvenez plus de lalgorithme, il faut diviser le plus grand nombre par le plus
petit. Ensuite, on prend le reste de la division euclidienne pour diviser le
nombre le plus petit. Puis on reprend le dernier reste pour diviser le reste de
la division prcdente. Et ainsi de suite jusqu ce quun reste soit nul. Vous
avez ainsi votre PGCD qui correspond au dernier reste non nul !
Une fois encore, vous pouvez remarquer quil nest pas ncessaire de connatre le nombre
dexcutions de la boucle contrairement une boucle for dont nous allons parler maintenant.
83
La boucle for
Prsentation
La syntaxe
Comme nous lavons dj dit dans ce cours, la boucle while permet de raliser toute
sorte de boucle. Cependant, son criture est quelque peu fastidieuse cest pourquoi, il
existe une criture condense utile dans certains cas : la boucle for. Celle-ci est utilise
lorsque nous connaissons lavance le nombre dexcutions de la boucle directement
ou travers une variable. Cette boucle permet de concentrer le traitement de la variable utilise, rappelez-vous avec une boucle while, nous devions passer par les tapes
suivantes :
Dclaration et initialisation de la variable avant la boucle.
Condition sur la variable en entre de boucle.
Incrmentation de la variable lintrieur de la boucle.
Grce la boucle for, nous pouvons maintenant condenser ces trois tapes au mme
endroit :
1
2
3
4
for ( /* Initialisation */ ; /* Condition */ ; /* Incr mentation */

)
{
// Instructions
}
Attention, l encore, la prsence des points-virgules ; pour sparer

chaque champ. Cest galement une source de problmes pour la compilation.
Quelques exemples
La boucle for est trs utilise en programmation, elle permet dviter davoir crire
des instructions rptitives et galement de faire des recherches dans les tableaux,
notion que nous aborderons trs bientt. En attendant, voici quelques exemples dutilisation de la boucle for :
1
2
3
4
for ( var i : int = 0 ; i < 10 ; i ++)

{
trace ( " La valeur de i est " + i ) ;
}
Ici galement, les accolades deviennent facultatives sil ny a quune seule instruction.
Aussi, il est possible dutiliser la boucle for en dcrmentation ou en encore par pas
de 10 si vous le dsirez :
1
2
84
for ( var i : int = 10 ; i > 0 ; i - -)

trace ( " La valeur de i est " + i ) ;
LA BOUCLE FOR
La boucle for na rien de difficile, il sagit simplement dune boucle while condense.
En revanche, la syntaxe est assez spciale, cest pourquoi il est ncessaire de la retenir
car cette boucle vous servira plus que vous ne limaginez !
En rsum
Les boucles permettent de rpter une srie dinstructions tant quune condition est
vrifie.
La boucle while permet de tout faire mais il est possible que les instructions
lintrieur ne soient jamais excutes.
La boucle do...while est identique la prcdente, nanmoins la boucle est excute
au moins une fois.
La boucle for est une forme condense du while dans le cas o on connat le nombre
de rptitions de la boucle.
Lincrmentation est utilise en permanence dans les boucles et son criture peut
tre simplifie par les expressions i++ et i .
85
86
Chapitre
Les fonctions
Difficult :
Maintenant, nous allons introduire les fonctions ! Sachez que cest un concept qui existe
dans tous les langages de programmation et que ces fonctions servent structurer notre
programme en petits bouts.
Nous verrons en quoi consistent rellement ces fonctions. Nous apprendrons comment
utiliser des fonctions toutes prtes, mais aussi comment en crer nous-mmes. Afin que
vous compreniez mieux toutes ces notions, je vous prsenterais quelques exemples qui
feront appel aux connaissances acquises jusquici.
87
CHAPITRE 6. LES FONCTIONS
Concept de fonction
Le principe de fonctionnement
Depuis le dbut de ce cours, tout ce que nous faisons se trouve lintrieur dune fonction nomme Main (ou peut-tre dune fonction init si vous utilisez FlashDevelop).
En effet, nous navons pas encore crit lextrieur des accolades de celle-ci. En gnral,
pour crire un programme, il faut compter entre une centaine de lignes de code jusqu
plusieurs milliers pour les plus consquents. Il nest donc pas envisageable dinsrer la
totalit du code lintrieur de la fonction Main. En effet, il faut organiser le code, ce
qui permet de le rendre plus lisible mais galement de faciliter le dbogage. Pour cela,
nous allons dcouper notre programme en morceaux. Nous regrouperons donc certaines
instructions ensemble pour crer des bouts de programme, puis nous les assemblerons
pour obtenir le programme complet. Chaque morceau est alors appel : fonction !
Comment se prsente une fonction ?
Une fonction est une srie dinstructions qui ont t regroupes pour une tche commune. Nous crons alors une fonction que nous appellerons chaque fois que nous en
avons besoin. Celle-ci se compose de la manire suivante :
Une ou des entres : il sagit dinformations qui seront utiles au cours de lexcution
de la fonction.
Le traitement et les calculs : cest le cur de la fonction, les instructions internes
sont excutes.
Une unique sortie : une fois les instructions de la fonction termines, celle-ci renvoie
un rsultat.
Pour rsumer tout ceci, vous trouverez la figure 6.1 un schma reprenant le principe
de fonctionnement.
Figure 6.1 Principe dune fonction

Notez quune fonction ne possde pas obligatoirement une entre et une sortie. Celle-ci peut trs bien se satisfaire uniquement dune entre ou dune sortie, et plus exceptionnellement aucune des deux. Nous reviendrons l-dessus
trs rapidement dans ce cours.
88
CONCEPT DE FONCTION
En rgle gnrale, on associe une fonction une tche bien prcise. Par exemple,
nous pourrions imaginer une fonction qui calcule et renvoie le carr dun nombre plac
en entre. Vous trouverez la figure 6.2 un schma de ce que cela donnerait.
Figure 6.2 Exemple dune fonction

Bien videmment, dans un programme, les fonctions sont gnralement plus complexes.
LActionscript possde dj des centaines de fonctions qui permettent par exemple
dafficher une image lcran ou encore de la transformer. Nous apprendrons les
utiliser ainsi qu crer nos propres fonctions.
Prsentation
Vous ne vous en doutez peut-tre pas, mais vous avez dj utilis des fonctions depuis
le dbut de ce cours ! Effectivement, nous avons dj utilis plusieurs fois la fonction
trace() et galement introduit la fonction toString(). Nanmoins, ces deux fonctions
sont lgrement diffrentes dans leur utilisation. Nous prsenterons donc brivement ici
ces diffrences entre les fonctions dites de base telle que la fonction trace() et les
mthodes comme la fonction toString(). Allons-y pour les fonctions de base !
Les fonctions de base
Lappel dune fonction telle que la fonction trace() se fait de manire la plus
basique qui soit. Rappelez-vous la faon dont nous crivions linstruction faisant appel
cette fonction :
1
trace ( " Texte afficher " ) ;
Vous remarquerez quil suffit simplement dcrire le nom de la fonction, ainsi que le
texte afficher entre parenthses. En revanche, ceci est diffrent pour les mthodes !
Les mthodes
Les mthodes sont lies la notion de POO ou Programmation Oriente Objet, je vous rappelle que nous y reviendrons dans une partie entirement consacre
ce concept. Contrairement aux fonctions de base, les mthodes sont associes
un objet. Pour vous montrer ceci, reprenons lexemple dutilisation de la fonction
toString() :
89

1
2

trace ( nombre . toString () == " 3 . 14 " ) ;
Ce quil faut noter par rapport la fonction trace(), cest que la mthode toString()
est lie lobjet nombre qui est de type Number. Notez le point . sparant lobjet
nombre de la mthode toString() ; il signifie que la mthode est lie lobjet et quelle
ne peut pas tre utilise indpendamment de lobjet auquel elle est associe. Quoi quil
en soit, vous aurez tout le temps de vous familiariser avec ceci au cours de la partie sur
la Programmation Oriente Objet.
Cration et appel de fonctions

Nous allons maintenant apprendre crer et appeler des fonctions. Nous verrons
quil existe deux faons de dclarer une fonction : les instructions de fonction et
les expressions de fonction. Commenons sans plus tarder par les instructions de
fonction.
Tout ce que nous allons voir ici concerne les fonctions de base. Nanmoins,
les mthodes ne sont pas trs diffrentes et reprendront tous les principes vus
tout au long du chapitre. Aussi, soyez attentifs tout ce qui sera dit ici ! Par
ailleurs, pour linstant, nous nous contenterons de tout crire lintrieur de
la fonction Main tel que nous le faisons depuis le dbut de ce cours.
Instructions de fonction
Dclaration
Linstruction de fonction est la premire technique permettant de dfinir une fonction. Il sagit sans aucun doute de la manire que vous serez le plus amens utiliser
lintrieur de vos programmes. Celle-ci dbute par le mot-cl function suivi du nom
donn cette fonction, dailleurs voici sa structure :
1
2
3
4
function nomDeLaFonction ( sesParametres ) : sonType

{
// Instructions ex cuter lors de l ' appel de la fonction
}
Pour faciliter la comprhension de tous ces champs, nous allons reprendre le modle
utilis plus haut pour dcrire une fonction :
Une ou des entres : il sagit des paramtres placs en entres, par ex :(monParam1:int,
monParam2:String). Vous pouvez galement ne renseigner aucun paramtre, vous
laisserez alors les parenthses vides, comme ceci ().
Le traitement et les calculs : cela correspond aux instructions places entre les
accolades de la fonction, qui seront excutes lappel de la fonction.
90
CRATION ET APPEL DE FONCTIONS

Une unique sortie : il est possible que la fonction ne renvoie aucune valeur, auquel cas
utilisez le mot-cl void comme type de renvoi. Dans le cas contraire, celle-ci ne peut
renvoyer quune unique variable. Le type de cette variable doit tre renseign aprs
les paramtres et prcd de deux-points : . Le renvoi de cette valeur seffectue
en utilisant le mot-cl return suivi de la valeur ou variable renvoyer.
Rien ne remplace un bon exemple, voici notre fonction qui lve un nombre au carr :
1
2
3
4
5
6
function carre ( nombre : int ) : int

{
var resultat : int = 0 ;
resultat = nombre * nombre ;
return resultat ;
}
Une variable dclare lintrieur dune fonction nest dfinie que pour cette
fonction. la fin de celle-ci, la variable est supprime de la mmoire et nest
donc plus accessible ! Ne tentez donc pas de rcuprer sa valeur en dehors
des accolades de la fonction !
Sachez quil est possible deffectuer des oprations aprs le mot-cl return, il est alors
prfrable de placer des parenthses autour du calcul. Veillez cependant ne pas en
faire trop, le code doit toujours rester ar et lisible. La fonction prcdente aurait donc
pu tre crite plus succinctement de la faon suivante :
1
2
3
4
function carre ( nombre : int ) : int

{
return ( nombre * nombre ) ;
}
Voil notre fonction est dfinie, il ne reste plus qu lappeler !
Appel
Lappel de la fonction nest pas bien compliqu sachant que vous avez dj ralis
cette opration ! omme pour la fonction trace(), nous allons maintenant appeler notre
fonction carre() en renseignant en paramtre le nombre que nous dsirons lever au
carr. La fonction nous renvoie une variable de type int, nous allons ainsi la stocker
dans une variable resultat dclare et de type int galement. Voici donc comment
procder :
1
2
var resultat : int = carre ( 4 ) ;

trace ( " le carr de 4 est " + resultat ) ; // Affiche : le carr
de 4 est 16
91

Lorsque votre fonction ne renvoie rien, le mot-cl void peut tre facultatif.
Cependant, je vous conseille fortement de lcrire quand mme. Dailleurs
le compilateur vous recommandera galement de prciser son type de renvoie : Warning: return value for function nomDeLaFonction has
no type declaration.
Ce nest pas trs flagrant dans ce cas, mais lutilisation des fonctions permet dorganiser
le code et de le rentre plus lisible. Ceci sera effectivement le cas lorsque vous aurez des
fonctions complexes, et que vous naurez plus qu les utiliser en les appelant en une
seule instruction ! Nous verrons diverses fonctions pour mieux comprendre juste aprs
les expressions de fonction.
Expressions de fonction
Les expressions de fonction sont beaucoup moins utilises que les instructions de
fonction et sont lgrement plus complexes. Les expressions de fonction utilisent
une instruction daffectation pour crire une fonction. Pour cela, il nous faut dfinir une fonction anonyme qui sera stocke dans une variable de type Function.
Pour viter de vous noyer dans des explications, voici la structure dune dclaration
dexpression de fonction :
1
2
3
4
var nomDeLaFonction : Function = function ( sesParametres )

{
// Instructions ex cuter lors de l ' appel de la fonction
};
Nous ne nous attarderons pas trop sur ces expressions de fonction, voici tout de
mme un exemple dutilisation :
1
2
3
4
5
var afficher : Function = function ( texte : String ) : void

{
trace ( texte ) ;
}
afficher ( " Ceci est la fonction afficher . " ) ;
Pour linstant, vous pouvez vous contenter uniquement des instructions de

fonction, ne vous compliquez pas la vie avec les expressions de fonction
qui sont moins utilises. En revanche, retenez bien comment utiliser ces instructions de fonction que nous utiliserons dsormais tout le temps.
Quelques exemples
Pour clore ce chapitre sur les fonctions, nous verrons quelques exemples de fonctions
qui pourront vous tre utile lavenir.
92
QUELQUES EXEMPLES
Message de bienvenue
Voici une fonction qui se contente dafficher un message de bienvenue la personne
indique en paramtre. Cette fonction ne renvoie aucune valeur.
1
2
3
4
5
function bienvenue ( nom : String ) : void

{
trace ( " Bonjour " + nom + " et bienvenue sur le Site du Z ro
!");
}
bienvenue ( " Marcel Dupont " ) ; // Affiche : Bonjour Marcel Dupont
et bienvenue sur le Site du Z ro !
Pour que votre code soit encore plus lisible, nhsitez pas donner des noms
explicites vos fonctions !
Calcul de PGCD
Dans cet exemple, nous allons calculer le PGCD entre deux nombres comme nous avons
appris le calculer dans le chapitre prcdent :
1
2
3
4
5
6
7
8
9
10
11
function calculPGCD ( nombre1 : int ,

{
do
{
var reste : uint = nombre1
nombre1 = nombre2 ;
nombre2 = reste ;
} while ( nombre2 != 0 ) ;
return nombre1 ;
}
trace ( " Le PGCD de 56 et 42 est :
Affiche : Le PGCD de 56 et 42
nombre2 : int ) : int
% nombre2 ;
" + calculPGCD ( 56 , 42 ) ) ; //
est : 14
Pour ceux qui voudraient rellement utiliser cette fonction, sachez quici le
nombre1 est suppos plus grand que le nombre2. Si vous le dsirez, nhsitez
pas rajouter une condition pour tester si cest effectivement le cas !
Calcul dun maximum

Voici une fonction qui pourrait vous tre utile, celle-ci vous renvoie le plus grand nombre
entre ces deux paramtres. Il ny a rien de trs compliqu, voici comment procder :
1
2
function max ( nombre1 : int , nombre2 : int ) : int

{
93

3
4
5
6
7
8
9
10
11
12
13
14
15
16
var resultat : int = 0 ;

if ( nombre1 > nombre2 )
{
resultat = nombre1 ;
}
else
{
}
return resultat ;
}
var nombre1 : int = 2 ;
trace ( " Le maximum entre " + nombre1 + " et " + nombre2 + " est
" + max ( nombre1 , nombre2 ) ) ; // Affiche : Le maximum entre 2
et 3 est 3
Lorsque vous raliserez des programmes assez consquents, vous devrez conomiser
au maximum les instructions dans vos programmes pour gagner en performance ou
simplement pour le rendre plus lisible. Il peut alors devenir intressant de regarder si
vos fonctions ne peuvent pas scrire diffremment, mais surtout en moins de lignes.
Ceci peut tre le cas pour cette fonction o nous pouvons aisment nous dispenser du
bloc dinstructions else. Effectivement, testez le code suivant, vous verrez quil fait
exactement la mme chose :
1
2
3
4
5
6
7
8
9
10
11
12
function max ( nombre1 : int , nombre2 : int ) : int

{
var resultat : int = nombre1 ;
if ( nombre2 > nombre1 )
{
}
return resultat ;
}
trace ( " Le maximum entre " + nombre1 + " et " + nombre2 + " est
" + max ( nombre1 , nombre2 ) ) ; // Affiche : Le maximum entre 2
et 3 est 3
Vous verrez que la recherche dun optimum (maximum ou minimum) est une pratique
assez courante avec les tableaux, mais nous verrons ceci dans le prochain chapitre !
En rsum
Les fonctions permettent dorganiser le code, de le rendre plus lisible mais galement
de se sparer de tches rptitives.
Pour dclarer une fonction, on utilise le mot-cl function.
94
QUELQUES EXEMPLES
Une fonction peut recevoir plusieurs paramtres en entre, mais ne peut retourner
quune valeur au plus.
On utilise le mot-cl return pour renvoyer une valeur.
On prfre gnralement les instructions de fonction auxquelles on peut attribuer
un nom.
95
96
Chapitre
Les tableaux
Difficult :
Pour clore cette premire partie du cours, nous verrons les tableaux qui sont trs utiliss
en programmation !
Les variables de base, prsentes dans un chapitre prcdent, sont trs utiles, mais possdent leurs limites lorsquil sagit de grer beaucoup de valeurs. Effectivement, laide de
variables nous pouvons associer une valeur un nom. Ceci peut tre handicapant lors du
traitement dune quantit de valeurs importante. Cest ici quentrent en jeu les tableaux !
Le principe des tableaux est de pouvoir stocker plusieurs valeurs sous un mme nom. Ceci
facilitera alors le traitement de ces donnes puisque celles-ci seront enregistres sous le
mme nom et seront simplement diffrencies par un indice lintrieur du tableau.
En Actionscript, nous avons plusieurs manires de crer et dutiliser des tableaux. Dans
ce chapitre, nous verrons les deux types de tableaux : Array et Vector.
97
CHAPITRE 7. LES TABLEAUX
Le type Array
Le premier type de tableau utilis en Actionscript est Array. En Actionscript, les
tableaux ne sont pas fixs en taille ce qui permet une programmation plus souple.
De plus, en ce qui concerne le type Array, les tableaux ne sont pas typs, cest--dire
quils ne sont pas rservs un seul type de variable. Il est alors possible dinsrer dans
un tableau des variables de type int, uint, Number, String ou encore tout ce qui vous
passe par la tte.
Cration
La cration dun tableau de type Array peut tre ralise de multiples faons. Cependant, les tableaux sont soumis aux mmes rgles que les variables. Cest pourquoi,
nous retrouverons donc la structure de base commune toute variable :
1
var nomDuTableau : Array = ceQueJeMetsDedans ;
En revanche, lorsquil sagit dinitialiser un tableau, nous avons le choix entre diverses mthodes. Voici quatre manires diffrentes dinitialiser une variable de type
Array :
1
2
3
4
var monTableau : Array = new Array ( 3 ) ; // Cr ation d ' un tableau

de 3 valeurs non renseign es
var monTableau : Array = new Array () ; // Cr ation d ' un tableau
vide
var monTableau : Array = new Array ( " Site " , " du " , " Z ro " ) ; // Cr
ation d ' un tableau contenant les 3 valeurs indiqu es
var monTableau : Array = [ " Site " , " du " , " Z ro " ]; // Cr ation du m
me tableau contenant les 3 valeurs indiqu es
Dans beaucoup de langages, la longueur dun tableau doit tre dfinie lors de
sa dclaration. Ce nest pas le cas en Actionscript, il est tout fait possible
de changer la longueur dun tableau en cours de programme.
La fonction trace() permet galement dafficher le contenu dun tableau. Vous pouvez
ainsi tout moment connatre ltat de votre tableau :
1
2
var monTableau : Array = [ " Site " , " du " , " Z ro " ];
trace ( monTableau ) ; // Affiche : Site , du , Z ro
Les lments du tableau

Mme si un tableau regroupe plusieurs valeurs, celles-ci doivent pouvoir tre utilises
sparment. Cest ici quentre en jeu la notion dindice lintrieur dun tableau. Ces
indices sont utiliss entre crochets [] pour prciser la position de llment dsir dans
le tableau. Les valeurs peuvent alors tre traites comme nimporte quelle variable :
98
LE TYPE ARRAY
1
2
3
4
5
var monTableau : Array = new Array ( 3 ) ;

monTableau [ 0 ] = 4 ;
monTableau [ 2 ] = monTableau [ 0 ] + monTableau [ 1 ];
trace ( monTableau [ 2 ]) ; // Affiche : 9
Attention, en programmation les indices des tableaux commencent toujours

0. Ainsi, le troisime lment du tableau se trouve lindice2. Ce nest pas
trs compliqu comprendre, mais on a souvent tendance loublier les
premires fois.
Comme nous venons de le voir, les valeurs lintrieur dun tableau se manipulent de
la mme manire que les variables. Toutefois, une valeur non initialise dans le tableau
aura une valeur par dfaut, undefined :
1
2
var monTableau : Array = new Array () ;

trace ( monTableau [ 0 ]) ; // Affiche : undefined
Proprits du type Array

Enfin, pour en finir avec le type Array, nous allons voir quelques mthodes et proprits qui pourront vous tre utiles. Tout dabord, lorsque vous utiliserez des tableaux, vous naurez pas besoin de connatre en permanence la taille de votre tableau.
En revanche, vous pouvez tout moment avoir besoin de connatre cette longueur de
tableau. Pour cela, vous pouvez utiliser la proprit length associe aux tableaux de
type Array. Voici comment lutiliser :
1
2
3
var monTableau : Array = new Array ( 5 ) ;

var taille : int = monTableau . length ;
trace ( taille ) ; // Affiche : 5
Nous allons prsent voir diffrentes mthodes permettant dinsrer ou de supprimer

des lments dans un tableau. Dabord, la mthode push() permet dajouter un ou
plusieurs lments la fin du tableau. loppos, la mthode unshift() insre un ou
plusieurs lments au dbut du tableau, cest--dire lindice 0. Pour finir, la mthode
splice() est un compromis car elle permet dinsrer des lments un indice spcifi.
Voici un exemple dutilisation de ces mthodes :
1
2
3
4
5
var monTableau : Array = [ " Site " , " du " , " Z ro " ];
monTableau . unshift ( " Bienvenue " ) ;
monTableau . splice (1 , 0 , " sur " ," le " ) ;
monTableau . push ( " ! " ) ;
trace ( monTableau ) ; // Affiche : Bienvenue , sur , le , Site , du , Z ro ,!
99

La mthode splice() peut avoir des finalits diffrentes suivant les paramtres renseigns. Voici donc la signification de chacun de ses paramtres :
Indice de dpart o on se place pour effectuer les oprations. Nombre dlments devant tre supprims partir de lindice de dpart. Srie dlments
qui doivent tre insrs la suite de lindice de dpart. Ainsi, la mthode
splice() permet la fois dinsrer des lments mais galement de supprimer ou remplacer des lments. Dans le cas prsent, la mise zro du
deuxime paramtre permet uniquement dinsrer des lments sans en supprimer.
Enfin, pour supprimer des lments nous avons galement trois mthodes : pop(),
shift(), et splice(). Symtriquement push() et unshift(), les mthodes pop()
et shift() permettent de supprimer des lments respectivement la fin ou au dbut
dun tableau. Pour supprimer des lments au milieu du tableau, il faut utiliser la
mthode splice() prsente juste avant. Encore une fois, voici un exemple pour bien
comprendre :
1
2
3
4
5
var monTableau : Array = [ " Bienvenue " , " sur " , " le " , " Site " , " du " ,
" Z ro " , " ! " ];
monTableau . pop () ;
monTableau . splice (1 , 2 ) ;
monTableau . shift () ;
trace ( monTableau ) ; // Affiche : Site , du , Z ro
Le type Vector
Le second type de tableaux utilis en Actionscript est Vector. Vous verrez que ces
tableaux sont trs proches de ceux de type Array, ils sont notamment galement non
fixs en taille. La principale diffrence vient du fait que les tableaux de type Vector
sont typs. Cest--dire quune fois dclar pour un certain type de variables, il nest
pas possible dy mettre autre chose. Voyons tout ceci plus en dtails !
Dclaration
Ici encore, la dclaration ressemble celle dune variable, mais une nuance prs.
tant donn que les tableaux de type Vector sont typs, il est ncessaire de prciser le
type de variables qui sera utilis laide des chevrons <> . Voici donc comment
dclarer un tel tableau :
1
var nomDuTableau : Vector . < Type > = ceQueJeMetsDedans ;
Pour initialiser un tableau de type Vector, voici les mthodes proposes :

1
2
3
var monTableau : Vector . < String > = new Vector . < String >() ;
var monTableau : Vector . < int > = new Vector . < int >( 3 ) ;
var monTableau : Vector . < String > = Vector . < String >([ " Site " , " du " ,
" Z ro " ]) ;
100
LE TYPE VECTOR
tant donn que ces tableaux sont typs, vous ne pouvez pas insrer une
valeur dont le type ne correspondrait pas celui dclar. En effet, ceci entrainerait des erreurs dexcution ou de compilation.
Notez que la taille du tableau peut toutefois tre fixe en utilisant un paramtre supplmentaire de type Boolean et valant true. Voici le code correspondant :
1
var monTableau : Vector . < int > = new Vector . < int >( 3 , true ) ;
Gestion des lments

Tout comme les tableaux Array, les valeurs internes peuvent tre manipules laide
dindices mis entre crochets [] . Voici encore quelques exemples de manipulations
de valeurs lintrieur dun tableau :
1
2
3
4
5
6
7
8
var monTableau : Vector . < int > = new Vector . < int >( 10 ) ;
for ( var i : int = 2 ; i < monTableau . length ; i ++)
{
monTableau [ i ] = monTableau [i - 1 ] + monTableau [i - 2 ];
}
trace ( monTableau ) ; // Affiche : 0 ,1 ,1 ,2 ,3 ,5 ,8 , 13 , 21 , 34
Pour les plus perspicaces dentre vous, vous aurez vu apparatre les premiers
termes de la Suite de Fibonacci qui sont en effet : 0,1,1,2,3,5,8,13,21,34.
En augmentant la taille du tableau, vous pourrez ainsi avoir tous les termes
de la suite que vous dsirez !
Grce cet exemple nous commenons cerner lintrt de lutilisation des tableaux.
Effectivement, lorsque nous utilisons des boucles par exemple, il devient relativement
simple de lier notre variable i de boucle avec les indices du tableau. Ceci avait dj
t dit prcdemment, mais nous allons le rappeler, les boucles sont extrmement utiles
et performantes pour parcourir des tableaux.
Pour allier tableaux et fonctions, nous allons transformer le code prcdent pour
crer une fonction renvoyant le nime terme de la suite de Fibonacci. Dcouvrons
cette fonction :
1
2
3
4
5
6
7
8
9
function suiteFibonacci ( terme : int ) : uint

{
var monTableau : Vector . < uint > = new Vector . < uint >( terme ) ;
{
monTableau [ i ] = monTableau [i - 1 ] + monTableau [i - 2 ];
}
101

10
11
12
13
14
return ( monTableau [ terme - 1 ]) ;

}
trace ( suiteFibonacci ( 10 ) ) ; // Affiche : 34
Enfin, vous noterez que les mthodes push(), pop(), shift, unshift() et splice()
fonctionnent galement avec les tableaux de type Vector.
Les tableaux multidimensionnels

Le concept
Nous allons maintenant dcouvrir les tableaux multidimensionnels : un nom barbare pourtant, cette notion nest pas si complique que a ! Les tableaux multidimensionnels ne sont en ralit que des tableaux imbriqus dans dautres tableaux.
Certes, cest une notion qui fait peur aux premiers abords cependant, il ny a rien de
nouveau en matire de code. Pour mieux comprendre de quoi il sagit, nous allons illustrer cette notion par un exemple. Nous pourrions crer une liste regroupant lensemble
des livres de la collection Le Livre du Zro , il serait alors possible de raliser cela
avec un tableau classique ou monodimensionnel. Imaginons maintenant quen plus de
stocker le nom des livres, nous souhaitions y ajouter le nom de lauteur et lanne de
sortie. Dans ce cas, nous avons besoin dutiliser un tableau bidimensionnel de la
manire suivante :
1
2
3
4
5
var livres : Array = new Array () ;

livres [ 0 ] = [ " R alisez votre site web avec HTML5 et CSS3 " , "
Mathieu Nebra " , 2011 ];
livres [ 1 ] = [ " Apprenez programmer en Java " , " Cyrille Herby " ,
2011 ];
livres [ 2 ] = [ " D butez dans la 3D avec Blender " , " Antoine Veyrat
" , 2012 ];
livres [ 3 ] = [ " R digez des documents de qualit avec LaTeX " , " No
l - Arnaud Maguis " , 2010 ];
Sachant que les lments du tableau principal sont des tableaux, vous obtiendrez donc
un tableau en utilisant la notation avec indice vue prcdemment :
1
trace ( livres [ 0 ]) ; // Affiche : R alisez votre site web avec

HTML5 et CSS3 , Mathieu Nebra , 2011
Il est bien videmment possible daccder une valeur lintrieur du second tableau.
Pour cela, nous devrons utiliser une notation double indice, cest ce qui rend ce
tableau multidimensionnel ! Regardez plutt ce code :
1
102
trace ( livres [ 0 ][ 0 ]) ; // Affiche : R alisez votre site web avec

HTML5 et CSS3
LES TABLEAUX MULTIDIMENSIONNELS

Pour bien comprendre, nous pouvons effectuer une analogie avec un tableau
Excel par exemple o le premier indice correspondrait au numro de la ligne
et le second au numro de la colonne. Si vous en avez besoin, sachez que
vous pouvez raliser des tableaux de la dimension que vous souhaitez.
Un peu de pratique
Dans cette section, nous allons raliser plusieurs fonctions pour apprendre bien manipuler les tableaux. Pour les tests, nous reprendrons le tableau prcdent :
1
2
3
4
5
var livres : Array = new Array () ;

livres [ 0 ] = [ " R alisez votre site web avec HTML5 et CSS3 " , "
Mathieu Nebra " , 2011 ];
livres [ 1 ] = [ " Apprenez programmer en Java " , " Cyrille Herby " ,
2011 ];
livres [ 2 ] = [ " D butez dans la 3D avec Blender " , " Antoine Veyrat
" , 2012 ];
livres [ 3 ] = [ " R digez des documents de qualit avec LaTeX " , " No
l - Arnaud Maguis " , 2010 ];
Pour viter de surcharger le code de ce cours, nous ne rcririons pas ces lignes avant
chaque fonction. vous de les copier si vous souhaitez raliser des essais.
Qui est-ce ?
La fonction prsente ci-dessous permet de retrouver lauteur dun livre. Pour cela,
nous raliserons donc une boucle lintrieur de laquelle nous rechercherons le livre
spcifi en paramtre. Une fois le livre trouv, il ne reste plus qu retenir lindice
correspondant dans le tableau et de renvoyer le nom de lauteur. Voici la fonction en
question :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
function auteur ( monTableau : Array , monLivre : String ) : String

{
var i : int = 0 ;
var continuer : Boolean = true ;
do
{
if ( monTableau [ i ][ 0 ] == monLivre )
continuer = false ;
i ++;
} while ( continuer ) ;
return monTableau [i - 1 ][ 1 ]
}
trace ( auteur ( livres , " Apprenez programmer en Java " ) ) ; //
Affiche : Cyrille Herby
trace ( auteur ( livres , " R alisez votre site web avec HTML5 et
CSS3 " ) ) ; // Affiche : Mathieu Nebra
103

Vous remarquerez que dans cet exemple, nous combinons la fois : condition, boucle,
fonction et tableau. Si vous avez bien compris cet exemple cest que vous tes au point
sur la premire partie et donc fin prt pour entamer la deuxime !
Trions par chronologie

Comme cela est annonc dans le titre, cette fonction va nous permettre de trier le
tableau en fonction de lanne de sortie des livres. Pour faire cela, nous allons devoir
crer un nouveau tableau que nous allons remplir au fur et mesure. Nous prendrons
donc chaque livre du premier tableau, puis nous chercherons o linsrer dans le second.
Pour raliser ceci, nous devrons utiliser deux boucles, une pour chaque tableau. Cette
fonction est plus complexe que la prcdente :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
function tri ( monTableau : Array ) : Array

{
var nouveauTableau : Array = new Array () ;
nouveauTableau [ 0 ] = monTableau [ 0 ];
{
var j : int = 0 ;
var continuer : Boolean = true ;
while ( continuer )
{
if ( j >= nouveauTableau . length || monTableau [ i ][ 2 ]
<= nouveauTableau [ j ][ 2 ])
continuer = false ;
j ++;
}
nouveauTableau . splice (j -1 , 0 , monTableau [ i ]) ;
}
return nouveauTableau
}
livres = tri ( livres ) ;
trace ( livres [ 0 ]) ; // Affiche : R digez des documents de qualit
avec LaTeX , No l - Arnaud Maguis , 2010
trace ( livres [ 1 ]) ; // Affiche : Apprenez programmer en Java ,
Cyrille Herby , 2011
trace ( livres [ 2 ]) ; // Affiche : R alisez votre site web avec
HTML5 et CSS3 , Mathieu Nebra , 2011
trace ( livres [ 3 ]) ; // Affiche : D butez dans la 3D avec Blender ,
Antoine Veyrat , 2012
Prenez le temps de bien assimiler ces deux exemples qui reprennent la quasi-totalit
des concepts de la premire partie.
104
PARCOURIR UN TABLEAU
Parcourir un tableau
Il existe plusieurs manires de parcourir un tableau, que ce soit un Array ou un
Vector. Il faut savoir que certaines sont plus rapides que dautres, il faut savoir choisir
laquelle utiliser en fonction des possibilits. Nous utiliserons chaque fois la boucle
for que nous avons dj vue prcdemment, nanmoins lActionscript en propose
quelques variantes encore plus efficaces.
La boucle for classique

Comme nous lavons vu, la boucle for est particulirement bien adapte au parcours
dun tableau. Pour rappel, voici un exemple de manipulation de ce type de boucle :
1
2
3
4
5
var monTableau : Array = [ " l ment n 1 " , " l ment n 2 " , " l ment
n 3 " , " l ment n 4 " ];
{
trace ( monTableau [ i ]) ;
}
Ce qui affichera :
l ment
l ment
l ment
l ment
n1
n2
n3
n4
Dans une boucle for classique, nous nous basons donc sur lindice, ou la position,
des diffrents lments lintrieur du tableau. Pour cela, nous avons alors besoin de
connatre la longueur de celui-ci, que nous pouvons dailleurs stocker dans une variable :
1
2
3
4
5
6
n 3 " , " l ment n 4 " ];
var longueur : int = monTableau . length ;
for ( var i : int = 0 ; i < longueur ; i ++)
{
}
Cependant, il est galement possible dutiliser dautres boucles o la connaissance de

la longueur dun tableau devient superflue ; jai nomm les boucles for...in et for
each !
La boucle for...in
La boucle for...in est trs proche de la boucle for classique, et sutilise quasiment de
la mme manire. Toutefois, il nest pas ncessaire de connatre le nombre dlments
105

contenus dans un tableau pour parcourir lintgralit de ce dernier. Voici un exemple
dutilisation de cette boucle :
1
2
3
4
5
n 3 " , " l ment n 4 " ];
for ( var i : String in monTableau )
{
}
Ce qui nous affichera comme prcdemment :

l ment
l ment
l ment
l ment
n1
n2
n3
n4
Ainsi, vous pouvez considrer que dans une boucle for...in la variable se comporte
comme un indice qui sincrmente automatiquement et qui parcourt lintgralit du
tableau.
Il est fort probable que certains dentre vous se demandent alors, pourquoi
diable la variable i est-elle de type String et non de type int ?
Pour comprendre cela, nous allons devoir brivement sortir du cadre de ce chapitre.
En ralit, la boucle for...in nest pas propre aux tableaux, mais peut tre utilise
pour parcourir dautres types dlments ou objets. Pour mieux cerner le problme,
nous allons imaginer lobjet ou la variable suivante :
1
var monObjet : Object = { a : " l ment A " , b : " l ment B " , c : " l ment
C " };
Nous avons donc ici une sorte de tableau contenant trois lments. Nanmoins, ces
lments ne sont pas rangs laide dun indice, mais plutt grce une tiquette ou
proprit et ne sont donc pas disposs suivant un ordre particulier. La seule manire
de faire rfrence un lment lintrieur de cette variable est donc dutiliser les
tiquettes associes chacun de ces lments.
Lutilisation de la boucle for...in prend alors tout son sens :
1
2
3
4
for ( var i : String in monObjet )

{
trace ( i + " : " + monObjet [ i ]) ;
}
Voici le rsultat :
a : l ment A
b : l ment B
c : l ment C
106
PARCOURIR UN TABLEAU
Pour utiliser correctement la boucle for...in, vous devez vous rappeler qu
lintrieur de celle-ci nous travaillons non pas laide dun indice numrique
mais bien avec une tiquette sous forme de chane de caractres. Dans
le cas dun tableau de type Array ou Vector, la variable utilise reprsente
nanmoins lindice, mais toujours sous la forme dune chane de caractres de
type String !
La boucle for each

La dernire boucle permettant de parcourir un tableau est la boucle for each. Contrairement ses congnres, la variable utilise lintrieur de celle-ci ne fait pas rfrence
lindice, ou ltiquette, associ aux lments dun tableau, mais aux lments euxmmes.
La manipulation des lments devient alors beaucoup plus simple :
1
2
3
4
5
var monTableau : Array = [ 12 , 42 , 10 , 3 ];

for each ( var nombre : int in monTableau )
{
trace ( nombre ) ;
}
Comme vous limaginez, dans ce cas, le type de la variable devra sadapter suivant la
nature des lments contenus lintrieur du tableau :
1
2
3
4
5
var monTableau : Array = [ 2 .3 , 24567673 , 42 , 3 . 14 , 276 . 54 ];

for each ( var nombre : Number in monTableau )
{
trace ( nombre ) ;
}
Ou encore :
1
2
3
4
5
var monTableau : Array = [ ' Hello ' , ' world ' , '! ' ];
for each ( var chaine : String in monTableau )
{
trace ( chaine ) ;
}
Notez toutefois quen utilisant cette boucle vous perdez la notion de reprage
lintrieur du tableau et vous ntes alors plus en mesure de relier llment
au tableau.
Bien videmment, ce qui est faisable avec un tableau de type Array, lest aussi avec un
autre tableau de type Vector :
1
2
var monVecteur : Vector . < String > = Vector . < String >([ ' Hello ' , '
world ' , '! ' ]) ;
for each ( var chaine : String in monVecteur )
107

3
4
5
trace ( chaine ) ;
En rsum
Grce aux tableaux, nous pouvons stocker plusieurs valeurs sous un mme nom de
variable.
Les lments dun tableau sont accessibles via un indice qui dmarre 0.
Les tableaux de type Array ne sont ni fixs, ni typs.
Les tableaux de type Vector ne sont pas fixs, mais en revanche ils sont typs.
Diffrentes mthodes permettent de manipuler des tableaux la fois de Array et de
type Vector.
On utilise gnralement les boucles for, for...in ou for each pour parcourir un
tableau.
Il est possible de crer des tableaux multidimensionnels en utilisant une notation
double indice.
108
Deuxime partie
La Programmation Oriente
Objet
109
Chapitre
La POO dans tous ses tats

Difficult :
Nous allons maintenant attaquer la deuxime partie du cours, traitant dune notion trs importante en Actionscript 3 : la Programmation Oriente Objet (ou POO). Apprhender
cette notion sera peut-tre difficile au dbut, mais vous finirez par tomber sous le charme
de cette faon de programmer, je vous le promets !
Cette partie sera galement loccasion de faire (enfin !) un peu de pratique loccasion de
quelques exercices que nous raliserons ensemble.
Attachez vos ceintures, cest parti ! La POO naura bientt plus aucun secret pour vous !
111
CHAPITRE 8. LA POO DANS TOUS SES TATS
Les notions-cls
Il tait une fois. . . un objet
Vous avez srement une ide de ce quest un objet : dans la vie de tous les jours, nous
en voyons, nous en touchons des centaines. Ils ont chacun une forme et remplissent
une ou plusieurs tches. On distingue rapidement plusieurs catgories dobjets qui
se ressemblent : quand vous mettez la table, vous manipulez des objets (fourchettes,
couteaux, cuillres, . . .) appartenant la catgorie couvert . Bien sr, vous pouvez
avoir plusieurs objets de cette catgorie, voire plusieurs fourchettes identiques. Les
objets de la catgorie fourchette font galement partie de la catgorie couvert
car les fourchettes ne sont en fait que des couverts particuliers.
La programmation oriente objet part de ces diffrentes observations pour introduire de nouveaux concepts en programmation afin de rendre le dveloppement de
logiciels plus efficace et intuitif.
Lautre faon de programmer est appele le procdural o il ny a grossomodo que des variables, des fonctions et des instructions effectues les
unes la suite des autres. La POO est diffrente par bien des aspects.
LObjet
Prenons une de vos fourchettes, comme la figure 8.1.
Figure 8.1 Une fourchette (image de ArnoldReinhold, tire du site Wikimedia Commons)
Il sagit dun objet ayant une forme particulire et une certaine utilit, caractristiques
que lon peut retrouver dans les autres fourchettes. Un objet en programmation
112
LES NOTIONS-CLS
est galement une entit possdant des proprits que lon peut retrouver sur dautres
objets de la mme catgorie. Il ne sagit ni dune variable, ni dune fonction, mais
dun mlange des deux : cest un nouveau concept part entire. Un objet peut donc
contenir plusieurs variables (appeles attributs) et plusieurs fonctions (appeles mthodes). Ces variables et fonctions (appeles proprits) sont profondment lies
lobjet qui les contient : les attributs stockent des informations sur cet objet. Par
exemple, si mon objet fourchette possde un attribut poids , cet attribut reprsente la masse de cette fourchette et non la masse dune autre fourchette pose
ct.
La Classe
Seulement, vous avez sur votre table non pas une mais dix fourchettes, quoique pas
exactement identiques. En effet, cette fourchette ci et plus lgre que cette fourchette l,
donc son attribut poids est plus faible. Mais ces deux objets restent des fourchettes,
malgr leur diffrence de poids. Fourchette est donc la catgorie de ces objets, appele
classe.
On dit que les objets dune classe sont des instances (ou occurrences) de
cette classe.
Une classe dcrit la nature de ses objets : cest un schma permettant de fabriquer et
de manipuler plusieurs objets possdant les mmes attributs et mthodes. Par exemple,
la classe Fourchette pourrait dcrire les attributs poids , taille , nombre de
dents , etc. (voir figure 8.2)
Nous pourrions aussi crer une classe Couteau pour les couteaux, et une classe Cuillre
pour les cuillres.
En Actionscript 3, les classes sont considres comme des types, au mme
titre que les int, Number ou String.
Un autre exemple
Une fois la table mise, vous tournez la tte et admirez travers la fentre votre magnifique voiture toute neuve (figure 8.3) : ne serait-ce pas un objet de la classe Voiture ?
Avec un objet aussi complexe, cette classe contient certainement plus dattributs et
de mthodes que la classe Fourchette. . .
Voici quelques exemples dattributs : taille (un grand classique), marque , couleur , nombre de pneus , nombre de siges ; et quelques exemples de mthodes :
verrouiller les portires , dmarrer le moteur , acclrer , freiner , tourner
gauche , tourner droite . . . (voir figure 8.4)
113
Figure 8.2 La classe Fourchette et quelques instances
Figure 8.3 Votre magnifique voiture
114
LES NOTIONS-CLS
Figure 8.4 La classe Voiture et une instance

Vous apercevez un peu plus loin la voiture de votre voisin gare en face (figure 8.5).
Cest galement un objet de la classe Voiture, avec une marque, une couleur, un
nombre de pneus et de siges, la possibilit dacclrer, de freiner, de tourner gauche
ou droite. . . Seulement, elle na ni la mme marque, ni la mme couleur que la vtre.
Ces deux objets sont des instances de la classe Voiture.
Figure 8.5 La voiture de mon voisin est une autre instance
Lencapsulation
Vous vous souvenez avoir ouvert le capot de votre voiture aprs lavoir gar : vous avez
intensment regard ce quil y a lintrieur (figure 8.6). Malgr votre immense effort
de concentration, le fonctionnement du moteur, de tous ces cbles, circuits lectriques
et autres tuyaux vous chappe encore. . .
Fort heureusement, lorsque vous refermez le capot et montez dans votre voiture, vous
115
Figure 8.6 Sous le capot. . .

oubliez toute cette mcanique trop complique, et vous conduisez laide dun volant,
de pdales et dun levier de bote de vitesse (figure 8.7). Grce eux, vous pouvez
utiliser votre voiture sans tre ingnieur en gnie mcanique ou lectronique !
Figure 8.7 Votre volant vous facilite bien la tche. . .

Imaginez maintenant que vous criviez une classe trs complexe, qui permet de faire
plein de choses incroyables (figure 8.8) ! Malheureusement, personne ne voudra de votre
magnifique classe : qui serait assez fou pour se plonger dans votre code et tentez de le
dchiffrer ?
En effet, votre code est un peu comme le bazar qui se trouve sous le capot de votre voiture. Mais vous tes malins et vous fournissez aux autres dveloppeurs des mthodes
116
LES NOTIONS-CLS
Figure 8.8 Ce quoi votre code pourrait ressembler. . .

trs simples et faciles comprendre, tout en cachant littralement sous le capot ce
quelles font, linstar du volant, des pdales et du frein main. Ainsi, les programmeurs qui utiliseront votre classe (y compris vous-mmes) auront un volant disposition
au lieu dun moteur et vingt-et-un tuyaux. On appelle ce principe lencapsulation.
Lhritage
Puis, votre regard se porte sur lautoroute au loin (figure 8.9) : vous distinguez dautres
voitures. Mais des formes diffrentes se dplacent parmi elles : ce ne sont de toute
vidence pas des voitures, mais plutt des camions et des motos. Vous remarquez que
ces objets comportent eux aussi des roues ; ils ont eux aussi une couleur et une marque ;
ils peuvent eux aussi acclrer, freiner, tourner gauche, tourner droite. . . Ce seraient
presque des objets de la classe Voiture.
Figure 8.9 Une autoroute belge (image de Purka, tire du site Wikimedia Commons)
117

Mince alors ! Il va falloir refaire de nouvelles classes quasiment identiques. . . Pourquoi
ne pas faire une classe Vhicule plus gnraliste, qui dcrirait les attributs et mthodes
communs aux classes Voiture, Camion et Moto ? Cest une excellente ide !
Notre nouvelle classe Vhicule dcrit donc les attributs et les mthodes communs
tous les vhicules routiers, comme le nombre de roues et de siges, la marque, la couleur,
les mthodes acclrer , freiner , tourner gauche , tourner droite . . . On
lappelle la classe mre (ou superclasse), par opposition aux classes Voiture, Camion
et Moto qui sont ses classes filles (ou sous-classes). On dit galement que les classes
Voiture, Camion et Moto hritent de la classe Vhicule.
Dsormais, inutile de rcrire les attributs et mthodes de la classe Vhicule dans la
classe Voiture, car cette dernire hrite des attributs et des mthodes de la classe
Vhicule (voir figure 8.10) ! Ainsi tous nos objets de la classe Voiture sont galement
des objets de la classe Vhicule, mais leur description dans la classe Voiture est plus
prcise (par exemple, les voitures ont un coffre, alors que les camions ont une remorque).
Lun des intrts de lhritage est donc de pouvoir crer plusieurs classes diffrentes
drivant dune classe-mre sans avoir recopier les attributs et les mthodes communes dans chaque classe. Cest aussi une faon de penser et concevoir le programme
de manire logique et cohrente.
Si nous revenions sur le premier exemple, la classe Fourchette, ainsi que les classes
Couteau et Cuillre, sont des sous-classes de la classe Couvert !
Manipuler des objets : les chanes de caractres

Lhorrible secret du type String
Vous souvenez-vous des chanes de caractres que nous avons vues dans la premire
partie ?
1
Regardez bien le type de la variable : String. . . Il cache un terrible secret : il sagit en

ralit dune classe ! Et oui ! En crivant la ligne au-dessus, nous avons sans le savoir,
cr une instance de la classe String. Et nous avons galement utilis des proprits
de cette classe !
Crer un objet
Tout dabord, il nous faut apprendre crer des objets. Il y a une syntaxe particulire
respecter :
1
new String () ; // Je cr un objet de la classe String ( je l ' ai

d ' ailleurs cr dans le vide , cette instruction ne servira
rien : D )
118
MANIPULER DES OBJETS : LES CHANES DE CARACTRES
Figure 8.10 Les trois classes sont des sous-classes de la classe Vhicule
119

Comme vous pouvez le voir, nous utilisons le mot-cl new, suivi du nom de la classe
de lobjet que nous voulons crer, et dventuels paramtres entre parenthses (comme
pour les fonctions). Par exemple, si nous voulions crer un objet de la classe String
contenant la chane "Hello world!", nous procderions ainsi :
1
var coucou : String = new String ( " Hello world ! " ) ; // Je cr un

objet String contenant la cha ne " Hello world !"
Mais, avant nous navions pas besoin de new pour faire a !
Effectivement, la classe String possde une particularit : cest un type de donnes.

Cela signifie que les objets de cette classe sont un peu spciaux : ils peuvent agir en
tant que simple donne (nombre, chane de caractres, etc.). Ainsi, nous pouvons nous
passer de la syntaxe de cration dun objet :
1
revient crire :
1
var coucou : String = new String ( " Hello world ! " ) ;
Quen est-il de int, uint et Number ?
Et bien, figurez-vous que ce sont galement des classes, qui fonctionnent de la mme
manire que la classe String !
Il est impossible dutiliser le mot-cl new pour crer des objets des classes int
et uint ! Cest la raison pour laquelle elles commencent par une minuscule,
cela permet de bien marquer la diffrence avec les autres classes.
En effet, ces deux classes sont encore plus spciales et nutilisent quune seule syntaxe :
celle que vous avez apprise dans la premire partie du cours. Par contre, la classe
Number fonctionne tout fait normalement, comme la classe String :
1
2
var entier : int = new int ( - 47 ) ; // INTERDIT ! ! !

var entier2 : int = - 42 ; // Autoris
3
4
5
var entierNonSigne : uint = new uint ( 47 ) ; // NOOON ! Tout sauf a

!
var entierNonSigne2 : uint = 47 ; // Ouf !
6
7
8
var nombre : Number = new Number ( 3 . 1415 ) ; // Pas de probl me

var nombre2 : Number = 3 . 1415 ; // Pour les flemmards
120
DES POINTEURS SOUS LE CAPOT

10
11
var monNom : String = new String ( " Bryan " ) ; // Je sens que je
connais cette phrase ...
var ouSuisJe : String = " In the kitchen ! " ; // Argh !
Accder aux proprits dun objet

Reprenons un peu plus de code que nous avons crit dans la premire partie :
1
2
3
var coucou : String = new String ( " Hello world ! " ) ;

trace ( " Cette cha ne contient " + coucou . length + " caract res . "
);
// Affiche : Cette cha ne contient 13 caract res .
et observons plus particulirement cette expression : coucou.length.
Nous avons utilis la proprit length de la classe <minicode type="actionscript"String</minicode>

qui renvoie la longueur de la chane ! Dcortiquons cette instruction :
Tout dabord, nous renseignons le nom de la variable contenant notre objet. Ici, il
sagit de coucou, variable que nous avons dclar plus haut avec cette ligne : var
coucou:String = "Hello world !"..
Ensuite, nous utilisons le caractre point . pour signaler que nous allons utiliser
un attribut ou une mthode de cet objet-l.
Enfin, nous spcifions quelle proprit nous voulons utiliser : ici, nous tapons donc
length, la proprit de la classe String qui nous intresse.
Nous obtenons ainsi la longueur de lobjet chane de caractres contenu dans la
variable coucou ! En franais, cela donnerait quelque chose comme : Lis la proprit
longueur de lobjet contenu dans ma variable coucou.
Des pointeurs sous le capot

Plantons le dcor
Prenons notre classe Voiture, et supposons quelle ait une proprit marque de type
String qui contient le nom de la marque des voitures.
Crons un objet de la classe Voiture et spcifions sa marque :
1
2
var lienVoiture : Voiture = new Voiture () ; // Je cr ma voiture

...
lienVoiture . marque = " Peugeot " ; // ... de marque Peugeot .
Dclarons une deuxime variable :

1
var lienVoiture2 : Voiture ; // Je d clare une autre variable
121
La variable nest pas initialise, elle contient donc null.
Ensuite, procdons une affectation :

lienVoiture2 = lienVoiture ; // C ' est bien une affectation ...
Mais que fait - elle r ellement ?
Nous allons regarder de quelle marque sont les voitures (vous avez srement devin) :
trace ( lienVoiture . marque ; // Affiche : Peugeot
trace ( lienVoiture2 . marque ) ; // Affiche : Peugeot
1
2
Bien ! Maintenant, modifions la marque de lienVoiture2 :

1
2
3
lienVoiture2 . marque = " Renault " ;

// Nous pourrions galement faire :
lienVoiture2 . marque = new String ( " Renault " ) ;
Enfin, regardons nouveau la marque des voitures :

1
2
trace ( lienVoiture . marque ) ; // Affiche : Renault

trace ( lienVoiture2 . marque ) ; // Affiche : Renault
Horreur ! Les deux ont la mme marque ! La rponse est simple : il sagit du mme
objet ! Et oui, il ny en a quun seul et unique !
Explications
Lorsque nous crons lobjet de classe Voiture, il est stock dans la mmoire vive de
votre systme. Ensuite, quand nous laffectons une variable, un lien vers cet objet est
cr, puis stock dans la variable. On dit alors que les variables sont des pointeurs :
elles pointent du doigt lobjet qui leur est associ, afin que nous, programmeurs, puissions accder cet objet. Dailleurs, vous aurez peut-tre remarqu le nom prcis que
jai donn mes variables : lienVoiture et lienVoiture2 ; nest-ce pas vocateur ?
(voir figure 8.11 )
Bien videmment, jai nomm les variables ainsi dans un but pdagogique :
vitez dappeler vos variables de cette faon, cela ne servirait rien (et tous
vos collgues vous dvisageraient dun air bizarre).
Donc, lorsque nous crivons notre affectation, nous nous contentons en ralit de recopier le pointeur vers lobjet initialement cr :
1
lienVoiture2 = lienVoiture ; // Recopions le pointeur de

lienVoiture dans lienVoiture2
Ainsi, en utilisant les proprits de lobjet de lienVoiture2, nous utilisons galement

celles de lobjet de lienVoiture. Logique : il sagit du mme objet !
122
DES POINTEURS SOUS LE CAPOT
Figure 8.11 Les variables-pointeurs sont toutes les deux lies lobjet.
Et si nous crions un autre objet de classe Voiture ?
Trs bonne ide ! Crons un nouvel objet et affectons-le la variable lienVoiture2 :

1
lienVoiture2 = new Voiture () ; // Un deuxi me objet Voiture

entre en sc ne !
Modifions sa marque :
1
lienVoiture2 . marque = " Citro n " ;
Et regardons la marque des deux voitures :

1
2
trace ( lienVoiture . marque ) ; // Affiche : Renault

trace ( lienVoiture2 . marque ) ; // Affiche : Citro n
Ouf ! Quel soulagement ! Nous avons bien deux objets distincts de la classe Voiture !
En rsum
Les objets contiennent des proprits : les variables sont appeles attributs et les
fonctions mthodes.
Chaque objet est dcrit par une classe : il sagit dune sorte de plan de construction
des objets. On dit que les objets sont des instances (ou occurrences) de leur classe.
Lencapsulation est un principe important en POO qui consiste cacher le fonctionnement interne des classes, et montrer seulement une interface simplifie.
Lhritage est un autre principe, tout aussi important, consistant faire hriter des
classes (dites classes filles) dune classe mre.
En Actionscript 3, tout est objet : tout ce que vous manipulerez, ce sera des objets.
Le mot-cl new permet de crer des objets.
La plupart des variables sont en ralit des pointeurs (ou liens) vers des objets
stocks en mmoire.
123
124
Chapitre
Les classes (1re partie)

Difficult :
Dans le chapitre prcdent, nous avons introduit la notion de classe et nous avons mme
appris utiliser la classe String. Cest dj un bon dbut dans la dcouverte de la Programmation Oriente Objet, mais ce nest pas suffisant. partir de maintenant, nous
allons apprendre crer nos propres classes. En utilisant le concept dobjets ou de classes,
la Programmation Oriente Objet permet dorganiser le code vraiment diffremment de
la programmation procdurale.
tant donn quil y a beaucoup de choses dire sur le sujet, la thorie sur les classes
stalera sur deux chapitres. Ce chapitre portera sur les principes fondamentaux, nous le
complterons avec quelques notions supplmentaires dans le prochain chapitre.
125
CHAPITRE 9. LES CLASSES (1RE PARTIE)
Crer une classe

La Classe
Rappels
Comme nous lavons dj mentionn, une classe est lensemble du code permettant de
reprsenter un objet dans un programme. Celle-ci est constitue de variables appeles
attributs et de fonctions appeles mthodes. On parle galement de proprits
pour dfinir lensemble des attributs et des mthodes dune classe. Ainsi, grce
ces proprits, nous allons pouvoir structurer notre objet et dfinir lintgralit de ses
caractristiques.
Une fois que la classe est dfinie, nous pouvons alors crer des instances ou occurrences de cette classe. Pour vous faire une ide, on peut considrer une instance
comme un objet physique , en opposition la classe qui dfinit plutt une description gnrale de lobjet. Ainsi, nous pouvons crer plusieurs instances dun mme objet,
mais dont les caractristiques pourront varier lgrement.
Il est important de bien faire la diffrence entre la classe, qui est unique et
qui dcrit un certain objet, et ses instances qui peuvent tre multiples et
qui sont les objets rels . Ceux-ci peuvent tre dcrits partir des mmes
proprits dont les valeurs peuvent varier.
Pour rassurer tout le monde, nous allons prendre un petit exemple concret :
Une classe Voiture permet de dfinir lensemble du parc automobile europen. Cette
classe Voiture dfinit lensemble des caractristiques que peut possder une automobile. Il serait par exemple possible dy retrouver la marque de celle-ci, mais galement
sa couleur ou encore son immatriculation que nous pourrions dfinir comme attributs.
Maintenant nous savons ce quest une Voiture, nous aurions peut-tre lenvie den
crer quelques-unes. Cest une trs bonne ide, et nous allons commencer par crer
une Renault de couleur grise et immatricule dans le Rhne . Voil maintenant que nous en avons besoin dune seconde ; trs bien, voici une Peugeot de
couleur noire et immatricule dans le Cantal .
Dans cet exemple, nous avons donc utilis une classe Voiture pour en crer deux
instances qui sont la Renault et la Peugeot.
Structure
Si vous avez bien suivi le deuxime chapitre de la premire partie, vous devriez vous
rappeler dun schma reprsentant la structure de la classe principale. Je vous propose de gnraliser ce schma et de le complter un peu plus avec ce que nous venons de
dcouvrir. Nous pouvons y ajouter notamment les attributs et les mthodes. Vous
verrez la figure 9.1 comment sont structures les classes.
126
CRER UNE CLASSE
Figure 9.1 Schma gnral de la structure dune classe.

Vous ne devriez donc pas tre surpris de la manire dont nous dfinissons une classe
lintrieur du code :
1
2
package
{
public class NomDeLaClasse

{
// Attributs
4
5
6
7
// M thodes
8
9
10
11
12
Nous allons prsent apprendre dfinir chacune des proprits de la classe !
Construire la classe
Package
Avant toute chose, nous allons brivement reparler de la notion de package. Nous
lavions dfini comme dcrivant la position de la classe dans larborescence des fichiers
de votre projet. Rassurez-vous, cest toujours le cas ! Cependant, je voudrais prsenter
ici la manire adopter pour positionner ses propres classes dans diffrents dossiers.
Pour linstant, il est vrai que nous ne disposons pas dun projet consquent
et que le nombre de classes est assez faible. Cependant, lorsque nos projets
grandiront et que les classes vont se multiplier, nous devrons faire le tri et
ranger nos classes dans diffrents dossiers afin dy voir plus clair.
Voici donc un conseil quil serait prudent de suivre : organisez vos classes en fonction
de leur nature et de leur utilit !
Par exemple, nous pourrions imaginer un package nomm vehicules qui contiendrait les classes Voiture, Camion et Moto. Puis nous crons deux nouvelles classes
127

Fourchette et Couteau, qui nont apparemment strictement rien faire dans le package
vehicules. Il nous faut alors en insrer un nouveau que nous pourrions nommer
couverts.
Attributs
Nous allons maintenant prsenter le premier type de proprits dune classe : il sagit
des attributs ! Les attributs ont en ralit des variables, nous pouvons donc les
dclarer comme nimporte quelle variable :
1
var _unAttribut : String ;
Lorsquon programme en POO, on a lhabitude de ne pas initialiser les variables lors

de la dclaration, mais plutt lintrieur dun constructeur que nous dtaillerons
un peu aprs dans ce cours.
Nous introduisons galement le mot-cl private devant la dclaration de lattribut,
dont nous reparlerons aussi plus tard :
private var _unAttribut : String ;
a y est, nous avons notre premier attribut !

Par convention, en Actionscript 3, nous ajouterons un caractre underscore
_ devant le nom de tous nos attributs. Cela nous sera pratique lorsque
nous crirons des accesseurs et mutateurs.
Mthodes
Comme nous lavons prcis plus haut, les mthodes sont des fonctions. Il peut donc
sagir aussi bien dinstructions de fonction que dexpressions de fonction (pour
ceux qui auraient tout oubli, allez faire discrtement un tour dans le chapitre sur les
fonctions !). Nanmoins, je vous avais dit que les instructions de fonction taient
prfrables, nous utiliserons donc ce type de fonctions :
1
2
3
4
function uneM thode () : void

{
// Instructions
}
Bien entendu, lintrieur de ces mthodes nous avons accs aux diffrents attributs
afin de pouvoir modifier leur valeur ou simplement lire leur contenu. Au final, seuls les
attributs peuvent mmoriser des choses et ainsi se souvenir de ltat de lobjet en
question. Cest la raison pour laquelle, en gnral, vos mthodes serviront lire ou
modifier le contenu dun ou plusieurs attributs.
Voil comment notre mthode pourrait modifier un attribut :
1
128
function uneM thode ( nouvelleValeur : String ) : void
CRER UNE CLASSE

2
3
4
unAttribut = nouvelleValeur ;
Bien sr, nous pouvons faire toutes sortes de manipulations lintrieur dune mthode
et pas simplement affecter ou lire le contenu dun attribut.
Contrairement dautres langages, lActionscript ne prend pas en compte la
surcharge de mthodes. Pour ceux qui dcouvrent ce terme, ne vous inquitez
pas, nous en reparlerons avant la fin de ce chapitre.
Enfin, les mthodes prennent galement un mot-cl devant leur dclaration, qui est
cette fois-ci public :
1
2
3
4
public function uneM thode () : void

{
// Instructions
}
Les mots-cls private et public sont lis la notion dencapsulation que

nous dcouvrirons plus en profondeur au cours du chapitre. En attendant,
sachez que ces mots-cls existent et considrez quils font partie de la dclaration des proprits dune classe.
Constructeur
prsent, il est temps dintroduire une mthode un peu particulire : le constructeur !
Le constructeur est la mthode appele par dfaut lors de linitialisation dun objet,
vous savez lorsque vous utilisez le mot-cl new. Vous noterez que cette mthode possde
obligatoirement le mme nom que celui de la classe. Par exemple, pour notre classe
nomme Voiture, notre constructeur pourrait ressembler ceci :
1
2
3
4
public function Voiture ()

{
// Instructions
}
Le constructeur dune classe sert principalement initialiser lensemble des attributs dclars dans celle-ci.
Vous remarquerez que le constructeur ne peut pas renvoyer de valeur, aussi
vitez dinsrer le mot-cl return lintrieur de celui-ci. Une instruction de
renvoi serait ignore lexcution, et pourrait entraner des messages derreur
lors de la compilation.
Ne vous inquitez pas si certains points sont encore flous dans votre esprit, nous allons
crer ensemble une classe pas pas la fin du chapitre !
129
Des paramtres facultatifs pour nos mthodes

La surcharge de mthodes
Dans beaucoup de langages utilisant la Programmation Oriente Objet, on retrouve le concept de surcharge de mthodes, mais ce nest pas le cas en ActionScript 3. Contrairement son nom abominable, ce concept est relativement simple et
consiste a dfinir plusieurs mthodes portant le mme nom. Il est alors possible de
dfinir des paramtres de types diffrents ou encore dutiliser un nombre de paramtres
diffrent. Ceci est trs utile et permet, par exemple, de dfinir plusieurs constructeurs
nayant pas le mme nombre de paramtres :
1
2
package
{
public class MaClasse

{
// Attribut
private var _unAttribut : int ;
4
5
6
7
8
// Constructeurs
public function MaClasse ()
{
_unAttribut = 0 ;
}
9
10
11
12
13
14
public function MaClasse ( entier : int )

{
_unAttribut = entier ;
}
15
16
17
18
19
20
21
22
Dans lexemple prcdent, il serait possible dinstancier une classe sans renseigner de
paramtres avec le premier constructeur, ou en prcisant la valeur de lentier avec le
second. Cette technique servirait donc rendre lutilisation dune classe plus simple
et plus souple, en permettant lappel dune mme fonction avec des paramtres
diffrents.
Malheureusement donc, la surcharge de mthodes est strictement interdite en Actionscript, vous ne trouverez donc jamais deux mthodes ayant le mme nom au sein
dune classe, et ceci est aussi valable pour les constructeurs. En revanche, il est possible
de contourner le problme, voire mme de le simplifier : cest le rle des paramtres
facultatifs !
130
DES PARAMTRES FACULTATIFS POUR NOS MTHODES
Les paramtres facultatifs

Dfinition
En Actionscript, il existe un concept qui permet dobtenir une utilisation similaire
une surcharge de mthodes. Il sagit des paramtres facultatifs ! Cette nouvelle
notion est associe en ralit la dfinition de fonctions et nest donc pas limite aux
seules mthodes. Ainsi, pour insrer un paramtre facultatif, il suffit de lui prciser
une valeur par dfaut dans lors de la dfinition de la fonction, comme ceci :
1
2
3
4
function maFonction ( entier : int , texte : String = " Valeur par d

faut " , nombre : Number = 0 ) : void
{
trace ( nombre , texte ) ;
}
En utilisant ici des valeurs par dfaut pour les deux derniers paramtres, il alors possible
de les omettre lors de lappel de la fonction. Ainsi, contrairement la surcharge
de mthode, nous navons pas besoin, en Actionscript, de rcrire lintgralit du
contenu de la fonction pour chaque dfinition de nouveaux paramtres.
Attention cependant lordre de dfinition des paramtres. Les paramtres
facultatifs doivent obligatoirement tre placs la fin de la liste des paramtres. Ils doivent galement tre crits dans un ordre dutilisation prcis que
nous allons prciser en parlant des appels de ces fonctions.
Appels
Comme leur nom lindique, les paramtres facultatifs peuvent tre omis lors de
lappel de la fonction. Ainsi, la fonction dfinie prcdemment, peut tre appele en
renseignant uniquement le premier paramtre :
1
maFonction ( 10 ) ;
Il est galement possible de renseigner les deux premiers paramtres, sans le troisime :
1
maFonction ( 10 , " Nouveau texte " ) ;
Attention toutefois lordre de dfinition des paramtres facultatifs. En

effet, sil est possible de renseigner le premier paramtre facultatif et domettre
le second, linverse est impossible. Ainsi, lappel suivant nest pas correct :
maFonction(10, 5). Cest pourquoi, vous devez tre vigilant dans lordre
de dfinition des paramtres facultatifs de vos fonctions !
Enfin, voici dernier appel possible de votre fonction, qui comprend lintgralit des
paramtres :
1
maFonction ( 10 , " Nouveau texte " , 5 ) ;
131

Ainsi, grce la dfinition de paramtres facultatifs, nous avons trois manires
diffrentes dappeler la mme fonction !
Encapsulation
Lencapsulation que nous allons redcouvrir maintenant est lun des concepts les
plus importants de la Programmation Oriente Objet ! Vous rappelez-vous du
mot-cl private que nous avons introduit avant chacun de nos attributs ? Il permet
de masquer la proprit laquelle il est associ, celle-ci nest donc pas visible depuis
lextrieur de la classe en question. Ainsi, partir de maintenant, nous masquerons
obligatoirement lensemble de nos attributs ! Pour y accder, nous serons donc dans
lobligation de faire appel une mthode intermdiaire qui nous permettra de vrifier
les donnes et daffecter les attributs en consquence, hors du champ de vision de
lutilisateur.
Lintrt de lencapsulation est de simplifier lutilisation des objets en masquant lensemble des attributs et des mthodes qui sont utiles simplement au fonctionnement
de lobjet. Ainsi, vu de lextrieur, nous pourrons manipuler ces objets facilement, sans
nous soucier de leur fonctionnement interne.
Ce concept introduit donc la notion de droits daccs que nous allons voir tout de
suite !
Les diffrents droits daccs

Il nest pas possible de parler dencapsulation sans toucher un mot des droits daccs
ou portes. Ces droits daccs dfinissent la visibilit dune proprit au sein de votre
code. En Actionscript, il existe trois portes qui sont public, private et internal.
Ces mots-cls se placent juste avant la dclaration des proprits auxquelles ils
sont associs.
En ralit, il existe une quatrime porte nomme protected. Cependant,
celle-ci est profondment lie la notion dhritage dont nous reparlons dans
le chapitre qui lui est consacr.
Privs
Les droits daccs dits privs sutilisent avec le mot-cl private. Ils permettent
de restreindre lutilisation de la proprit la classe o elle est dfinie. Ainsi, cette
proprit ne sera pas visible depuis lextrieur de cette classe. Voici un attribut dont
la porte est de type private :
1
132
private var _monAttribut : String ;
ENCAPSULATION
Je rappelle que tous nos attributs doivent tre invisibles depuis lextrieur de
la classe o ils sont dfinis, utilisez donc la porte private.
Publiques
Les droits daccs publics sont associs au mot-cl public, que nous avons dj
crois plusieurs fois. Celui-ci permet de rendre visible partout dans le code la proprit
laquelle il est associ. Ce sera donc le cas pour la majorit de vos mthodes. Dailleurs,
il est impossible daffecter une autre porte que public un constructeur :
1
2
3
4
public function MonConstructeur () : void

{
...
}
Internes
Les droits daccs internes sont un peu spciaux. Ils sont associs au motcl internal. Les proprits dfinies avec ce type de portes sont visibles depuis
lensemble du package, dont la classe o elle est dclare appartient.
1
internal var _monAttribut : int ;
Cette porte nest pas trs utilise en gnral, mais sachez quil sagit de la
porte par dfaut lorsquaucune autre nest spcifie.
Les accesseurs
Syntaxe
Il existe un type de mthodes un peu spcial, directement li la notion dencapsulation :
les accesseurs ! On dsigne par accesseurs lensemble des accesseurs et mutateurs,
galement appeles getters et setters. Ceux-ci permettent laccs direct un attribut
de porte private en lecture par laccesseur et en criture par le mutateur. Ainsi,
dans beaucoup de langages de programmation, on retrouve un ensemble daccesseurs
dont le nom dbute par get (de langlais to get qui signifie obtenir ) et un ensemble
de mutateurs dont le nom dbute par set (de langlais to set qui signifie dfinir ).
Pour grer lensemble des accesseurs, lActionscript a introduit deux mots-cls get
et set qui permettent notamment de donner un nom identique aux deux accesseurs.
Illustrons cela par dun exemple. Voici un attribut quelconque dont la porte est de
type private :
133

private var _texte : String ;
tant donn que cet attribut est de type private, il nest pas accessible depuis lextrieur de la classe o il a t dfini. Cependant, il est probable que nous ayons besoin de
modifier cet attribut depuis la classe principale. Si nous voulons respecter le concept
dencapsulation, nous devons donc conserver la porte de cet attribut et dfinir des
accesseurs pour y avoir accs :
1
2
3
4
5
// Accesseur
public function get texte () : String
{
return _texte ;
}
6
7
8
9
10
11
// Mutateur
public function set texte ( nouveauTexte : String ) : void
{
_texte = nouveauTexte ;
}
Comme vous le voyez, mes deux accesseurs utilisent le mme nom de fonction, ce
qui est drlement pratique. Mais lutilisation des accesseurs va plus loin que a, car
leur utilisation est un peu particulire. Ainsi, laccesseur get dune instance nomme
MonObjet sutilise sans les parenthses :
1
var maVariable : String = MonObjet . texte ;
Quant lui, le mutateur sutilise galement sans parenthses, mais avec le symbole
gal = qui est considr comme un signe daffectation :
MonObjet . texte = " Nouvelle cha ne de caract res " ;
Une telle utilisation des accesseurs est spcifique lActionscript. Cette technique permet de manipuler les accesseurs comme sil sagissait de lattribut
lui-mme. Cependant, en utilisant les getters et setters, vous respectez le
concept dencapsulation. Ainsi, les proprits cres partir daccesseurs
sont considres comme tant des attributs, et non des mthodes.
Une raison supplmentaire dutiliser les accesseurs

Lorsque vous utilisez des accesseurs, vous ntes pas obligs de vous contenter de lire
un attribut dans un getter ou de lui affecter une nouvelle valeur dans un setter :
en effet, il est tout fait possible dajouter du code supplmentaire, voire de ne pas
manipuler dattribut en particulier !
Prenons la classe suivante :
1
2
package
{
134
ENCAPSULATION
/* *
* Une classe d ' exemple
*/
public class Voiture
{
private var _largeur : int ;
3
4
5
6
7
8
9
public function Voiture ()

{
10
11
12
13
14
public function get largeur () : int

{
return _largeur ;
}
15
16
17
18
19
public function set largeur ( value : int ) : void

{
_largeur = value ;
}
20
21
22
23
24
25
26
27
28
29
public function mettreAJour () : void

{
// Mettre jour l ' affichage
}
30
31
Dans un premier temps, imaginons que dans notre classe, nous disposions dune mthode mettreAJour() qui met jour laffichage de notre objet en fonction de la valeur
de lattribut _largeur. Pour spcifier la largeur de la voiture, nous procderions ainsi :
1
2
3
4
5
var voiture : Voiture = new Voiture () ;

voiture . largeur = 100 ; // Largeur de la voiture
voiture . mettreAJour () ; // Mettons jour l ' affichage de la
voiture pour une largeur de 100
voiture . largeur = 150 ; // Changeons la largeur de la voiture
voiture . mettreAJour () ; // Mettons jour l ' affichage de la
voiture pour une largeur de 150
Grce aux accesseurs, il est possible de lappeler automatiquement ds que lon modifie
la largeur de lobjet :
1
2
3
4
5

{
_largeur = value ;
mettreAJour () ;
}
135

Ainsi, au lieu davoir appeler manuellement la mthode mettreAJour(), il suffit de
modifier la largeur :
1
2
3
4
5

// L ' affichage de la voiture est automatiquement mis jour
dans l ' accesseur set largeur !
// Encore une fois , l ' affichage de la voiture est
automatiquement mis jour , il n 'y a rien d ' autre faire !
Maintenant, nous aimerions limiter les valeurs possibles de lattribut largeur ; disons
quil doit tre suprieur 100 et infrieur 200.
1
2
3
4
5
6
7
8
9
10
11
12

// On v rifie que la largeur est dans les limites
if ( voiture . largeur < 100 )
{
voiture . largeur = 100 ;
}
else if ( voiture . largeur > 200 )
{
}
trace ( voiture . largeur ) ; // Affiche : 100
13
14
15
16
17
18
19
20
21
22
23
24

// On v rifie une fois de plus que la largeur est dans les
limites
if ( voiture . largeur < 100 )
{
}
else if ( voiture . largeur > 200 )
{
}
Vous remarquerez que cest plutt fastidieux. Bien sr, nous pourrions utiliser une
fonction, mais il vaut mieux mettre dans la classe Voiture ce qui appartient la classe
Voiture ! Encore une fois, les accesseurs nous facilitent grandement la tche, voyez
plutt :
1
2
3

{
_largeur = value ;
4
5
6
136
// _largeur doit tre comprise entre 100 et 200

if ( _largeur < 100 )
ENCAPSULATION
{
_largeur = 100 ;
}
else if ( _largeur > 200 )
{
_largeur = 200 ;
}
8
9
10
11
12
13
14
15
16
mettreAJour () ;
Le code principal serait alors crit ainsi :

1
2
3
4

// Plus besoin de v rifier que la largeur est dans les limites ,
l ' accesseur le fait pour nous !
5
6
7

Avouez que cest extrmement pratique ! Je vous conseille dappliquer cette faon de
faire le plus souvent possible, cela vous rendra service.
Gnrateur de code dans Flashdevelop

Il existe un outil trs pratique disponible dans la plupart des IDE, dont Flashdevelop,
pour gnrer automatiquement des portions de codes. Nous pouvons lutiliser, entre
autres, pour gnrer les accesseurs de nos attributs ! Pour cela, il faut suivre trois
tapes : voir les figures 9.2, 9.3 et 9.4.
Il est galement possible de se passer de la deuxime tape en utilisant directement le raccourci Ctrl + Maj + 1.
Le code ainsi gnr, ressemblera ceci :
1
2
3
4
public function get texte () : String

{
return _texte ;
}
5
6
7
8
9
public function set texte ( value : String ) : void

{
_texte = value ;
}
137
Figure 9.2 1. Placer le curseur sur la ligne de lattribut dont il faut gnrer les
accesseurs
Figure 9.3 2. Slectionner loption Code Generator
138
EXERCICE : CRONS NOTRE PREMIRE CLASSE
Figure 9.4 3. Slectionner une des trois options
Exercice : Crons notre premire classe

Prsentation de la classe
Description
Afin de mieux apprivoiser toutes ces nouvelles notions, nous allons maintenant crire
notre premire classe pas pas ! Nous allons donc crer une classe Voiture, que je vous
propose de dcouvrir maintenant. Nous y intgrerons les attributs suivants, ainsi que
les accesseurs correspondants :
SaMarque : cet argument de type String permet de dfinir la marque de la voiture.
Celui-ci sera dfini dans le constructeur et il sagit du seul attribut qui ne possdera pas de mutateur. En effet, une voiture peut tre repeinte, modifie par divers
accessoires qui influeront sur sa longueur ou encore elle peut changer de plaque
dimmatriculation. En revanche, elle ne peut pas changer sa marque de fabrique.
SaCouleur : cet argument de type String reprsente la couleur de peinture de la
voiture. Celle-ci sera manipule par les deux accesseurs nomms couleur.
SaLongueur : la longueur du vhicule sera dfinie par une variable de type int. Deux
accesseurs longueur permettront de manipuler cet lment. Lors dune affectation,
nous devrons vrifier si la valeur renseigne est positive. Dans le cas contraire, nous
utiliserons la valeur -1 pour prciser que la longueur est non renseigne .
SonImmatriculation : enfin limmatriculation du vhicule sera stocke dans un attribut de type String, qui possdera deux accesseurs immatriculation.
Lanons-nous donc dans la conception de cette classe. Lisez avec attention afin de noter
les diffrentes tapes de cration dune classe.
139

UML : Unified Modeling Language
Lorsque lon programme, il est possible de reprsenter les diffrentes classes sur un
schma pour rsumer leurs proprits. Il existe diffrentes modlisations standards
dont lUnified Modeling Language ou UML. Cette reprsentation est trs souvent
associe aux langages orients objets comme lActionscript. Sans donner plus de dtails, je vous propose de dcouvrir la figure 9.5 la reprsentation correspondant
notre classe Voiture.
Figure 9.5 Reprsentation UML de la classe Voiture

Comme vous le voyez, notre classe est divise en deux parties : les attributs et les
mthodes ! Ceux-ci sont donc lists en spcifiant de quels types ils sont, ainsi que
les paramtres renseigner en ce qui concerne les mthodes. Cela permet de dresser
une sorte de plan de construction de la classe coder, mais galement son mode
demploi pour dventuels autres programmeurs. Cela permet galement de mettre en
vidence les relations liant les classes les unes aux autres, comme nous le verrons au
cours des chapitres venir. Vous aurez trs certainement remarqu les signes - et
+ qui prcdent lensemble de nos proprits. Ceux-ci permettent de reprsenter
les diffrents droits daccs lis chacune de nos proprits de la manire suivante :
- pour privs, + pour publiques, ~ pour internes et # pour protgs.
Lobjectif du cours nest pas de vous apprendre utiliser lUML, cependant,
nous utiliserons quelques schmas qui sont souvent bien plus parlants que des
mots. Vous apprendrez lire et utiliser les bases de cette modlisation au fil
des chapitres de cette partie.
criture du code
Prparation du nouveau fichier
Tout dabord, pour crer une nouvelle classe, nous aurons besoin dun nouveau fichier
Actionscript ! Nous allons donc insrer une classe nomme Voiture avec File > New
> AS3 Document si vous tes sous FlashDevelop ou crer un nouveau fichier nomm
140

Voiture.as si vous nutilisez pas ce logiciel.
Puis, nous insrerons lintrieur le code de dfinition de la classe, comme ceci :
1
2
3
4
package
{
{
6
7
8
Dclaration des attributs

Prcdemment, nous avons dfini les quatre attributs qui sont saMarque, saCouleur,
saLongueur et sonImmatriculation. Tous ces attributs ont videmment des droits
daccs de type private, pour respecter le concept dencapsulation.
Voici donc les diffrentes dclarations dattributs :
1
2
3
4
private
private
private
private
var
var
var
var
_marque : String ;
_couleur : String ;
_longueur : int ;
_immatriculation : String ;
Le constructeur
Comme nous lavons rapidement introduit, le constructeur de cette classe devra recevoir en paramtre la marque de fabrication du vhicule. Sachant que les autres attributs
possdent des setters, nous ne les introduirons pas dans la liste des paramtres spcifier au constructeur. Nanmoins, ceux-ci devront tout de mme tre initialiss.
Il est recommand dutiliser, ds que cela est possible, les accesseurs et les
mutateurs au sein mme de la classe, exception faite du constructeur, o
cela nest gnralement pas ncessaire.
Dcouvrons tout de suite ce constructeur :
1
2
3
4
5
6
7
public function Voiture ( marque : String )

{
_marque = marque ;
_couleur = " Sans couleur " ;
_longueur = -1 ;
_immatriculation = " Non immatricul e " ;
}
141

Vous pouvez utiliser des noms de paramtres identiques aux noms de vos
proprits (ici marque) : ils sont en effet prioritaires. Pour pouvoir utiliser
explicitement une proprit de lobjet, il faut ajouter le mot-cl this devant : si nous avions un mutateur pour lattribut marque, nous devrions
crire this.marque = marque; pour lutiliser.
Les accesseurs
Chaque attribut possde un ou deux accesseurs, nous ne les dtaillerons donc pas
tous. Je vous propose plutt de dcouvrir un getter et un setter. Nous allons prendre
lexemple des accesseurs longueur, dont voici le getter :
1
2
3
4
public function get longueur () : int

{
return _longueur ;
}
Cet accesseur na rien de trs compliqu, nous ne nous y attarderons donc pas davantage. En revanche, pour le mutateur, nous devons vrifier si la valeur spcifie est
positive, je vous rappelle. Nous devrons donc utiliser une condition en if...else pour
faire la vrification.
Voici donc le mutateur en question, que vous tes normalement en mesure de comprendre par vous-mmes maintenant :
1
2
3
4
5
6
7
public function set longueur ( nouvelleLongueur : int ) : void

{
if ( nouvelleLongueur > 0 )
_longueur = nouvelleLongueur ;
else
_longueur = -1 ;
}
Flicitations, nous avons termin lcriture de votre premire classe !
La classe complte
Parce quil est probable que certains ne soient pas pleinement satisfaits avant davoir vu
lintgralit de celle-ci, je vous propose ici un rcapitulatif intgral de la classe Voiture :
1
2
3
4
5
6
7
8
9
package
{
{
/* ************** Attributs ************** */
private var _marque : String ;
private var _couleur : String ;
private var _longueur : int ;
private var _immatriculation : String ;
142

10
11
12
13
14
15
16
17
18
/* ************ Constructeur ************ */

{
_marque = marque ;
_longueur = -1 ;
}
19
20
21
22
23
24
/* ************** Accesseurs ************** */

public function get marque () : String
{
return _marque ;
}
25
26
27
28
29
public function get couleur () : String

{
return _couleur ;
}
30
31
32
33
34

{
return _longueur ;
}
35
36
37
38
39
public function get immatriculation () : String

{
return _immatriculation ;
}
40
41
42
43
44
45
/* ************** Mutateurs ************** */

public function set couleur ( nouvelleCouleur : String ) :
void
{
_couleur = nouvelleCouleur ;
}
46
47
48
49
50

{
_longueur = ( nouvelleLongueur > 0 ) ?
nouvelleLongueur : -1 ;
}
51
52
53
54
55
public function set immatriculation (

n ou ve ll e Im ma tr i cu la ti o n : String ) : void
{
_immatriculation = no uv e ll eI mm a tr ic u la ti on ;
}
56
143

}
57
58
59
Vous
pouvez lafficher pour la copier
en utilisant le code web ci-dessous.
Classe Voiture
B
Code web : 255948
En rsum
Le mot-cl this fait rfrence lobjet lui-mme.
Les classes sont tries dans diffrents package en fonction du type dobjets quelles
reprsentent.
Le constructeur est une mthode particulire appele la cration dune instance,
o on initialise gnralement les attributs.
Il est possible de dfinir des paramtres facultatifs lintrieur de nos fonctions
et mthodes pour palier limpossibilit de surcharger celles-ci.
Lencapsulation est le concept permettant de masquer le fonctionnement interne
dune classe.
Pour grer les droits daccs, nous disposons des diffrents mots-cls public,
private, internal et protected (que nous aborderons plus loin).
Des accesseurs peuvent tre dclars laide des mots-cls get et set, et simplifient
laccs aux attributs dune classe.
144
Chapitre
10
Les classes (2nde partie)

Difficult :
Dans le chapitre prcdent, nous avons prsent les bases de la thorie des classes. Nous
allons maintenant introduire des notions complmentaires qui vous permettront de structurer votre code encore plus facilement et proprement. Contrairement la plupart des notions
de cette partie sur la POO, celles que nous allons dcouvrir dans ce chapitre nont pas t
prsentes dans le premier chapitre et sont donc compltement nouvelles. Redoublez donc
dattention !
145
CHAPITRE 10. LES CLASSES (2NDE PARTIE)
Les lments statiques

Peut-tre que certains se rappellent de la classe Math que nous avons dj utilis. Ils
se demandent alors pourquoi nous lavions utilis en employant directement le nom de
la classe et sans passer par une instance de celle-ci :
1
var monNombre : Number = Math . sqrt ( 2 ) ;
Comment cela est-ce possible ?
Maintenant que vous avez dj quelques connaissances en POO, il est tout fait
justifi de se poser ce genre de question. En fait, la classe Math utilise des lments
qui sont un peu particuliers : les lments statiques ! Comme nous le verrons, ces
lments statiques ne sont pas dfinis pour les instances dune classe, mais pour la
classe elle-mme. Il existe deux types dlments statiques qui sont :
Les variables statiques.
Les mthodes statiques.
Nous verrons donc comment crer ces lments et leur intrt.
Les variables statiques

Les variables statiques sont dclares laide du mot-cl static, et sont associes,
donc dfinies, pour la classe. Prenons lexemple de notre classe Voiture du chapitre
prcdent et ajoutons-y une variable statique reprsentant le nombre de fois o celle-ci
a t instancie :
public static var occurences : int = 0 ;
Cette variable est donc partage par la classe, elle nappartient pas aux instances de
celle-ci. Toutefois, cette variable est accessible depuis nimporte quel point de la classe.
Nous pourrions notamment incrmenter cette variable lintrieur du constructeur de
la classe Voiture afin de comptabiliser le nombre doccurrences de celle-ci :
occurrences ++;
Grce cette variable statique, nous pourrions obtenir le nombre dinstances de la

classe Voiture, nimporte o dans le code. Pour cela, nul besoin de crer une nouvelle
instance de la classe, il suffit dutiliser le nom de la classe lui-mme :
1
2
3
4
var uneRenault : Voiture = new Voiture ( " Renault " ) ;

var unePeugeot : Voiture = new Voiture ( " Peugeot " ) ;
var uneCitroen : Voiture = new Voiture ( " Citro n " ) ;
trace ( Voiture . occurrences ) ; // Affiche : 3
146
LES LMENTS STATIQUES

Un lment statique ne peut tre utilis quavec la classe o celui-ci est
dclar. Il est impossible de faire rfrence un lment statique laide
dune instance de cette classe : des erreurs seraient alors engendres.
Les mthodes statiques

Il existe un second type dlments statiques : il sagit des mthodes statiques.
Dans le chapitre prcdent, je vous avais dit que les mthodes servaient principalement la lecture ou la modification dun attribut. Nous pouvons donc introduire les
mthodes statiques comme lensemble des mthodes qui offrent des fonctionnalits
naffectant pas au moins lun des attributs dune classe.
Ces lments statiques sont galement dclars laide du mot-cl static :
1
2
3
4
public static function uneMethode () : void

{
// Instructions
}
laide de ces mthodes statiques, il nous est possible de recrer la classe Math,
que nous pourrions renommer MaClasseMath. Voici par exemple la redfinition de la
mthode pow() en puissance() :
1
2
3
4
5
6
7
8
9
public static function puissance ( nombre : int , exposant : int ) : int

{
var resultat : int = nombre
for ( var i : int = 1 ; i < exposant ; i ++)
{
resultat *= nombre ;
}
return resultat ;
}
Le code complet de la classe serait :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package
{
public class MaClasseMath
{
public static function puissance ( nombre : int , exposant :
int ) : int
{
var resultat : int = nombre
for ( var i : int = 1 ; i < exposant ; i ++)
{
resultat *= nombre ;
}
return resultat ;
}
}
147

15
Vous remarquerez que cette classe ne possde pas de constructeur : en effet,

il est permis de ne pas mettre de constructeur si vous ne vous en servirez
pas. Ici, nous navons pas mis de constructeur car nous nallons jamais crer
dinstance de cette classe.
Nous pouvons ainsi lutiliser sans crer doccurrences de cette nouvelle classe :
1
2
var monNombre : int = MaClasseMath . puissance (2 , 10 ) ;

trace ( monNombre ) ; // Affiche : 1024
Des classes telles que Math ont t conues pour tre utilises uniquement grce des
lments statiques. En utilisant ce principe, vous pouvez ainsi regrouper un ensemble
de fonctionnalits lintrieur dune mme classe. Vous naurez donc pas besoin de crer
doccurrences de celle-ci et vous ferez ainsi lconomie des instructions de dclarations
et dinitialisations des instances.
Il est impossible dutiliser le mot-cl this dans les mthodes statiques, car
elles ne sont lies aucun objet en particulier.
Une nouvelle sorte de variable : la constante !

Lorsque nous avons introduit les variables dans la premire partie, nous navons pas
parl des constantes ! Comme son nom lindique, la valeur dune constante est
fige contrairement celle dune variable qui est voue voluer au cours du programme. Ces constantes sont principalement utilises en POO et reprsentent des
caractristiques constantes dun objet.
Je vous invite dcouvrir ce nouveau type dlment sans plus attendre !
Prsentation
Dclaration
De la mme faon que nous avions linstruction ou mot-cl var pour dclarer une variable, nous disposons du mot-cl const en ce qui concerne les constantes. Comme
les variables, ces dernires possdent galement un type. Voici par exemple la dclaration dune constante de type String :
1
148
const MA_CONSTANTE : String ;
UNE NOUVELLE SORTE DE VARIABLE : LA CONSTANTE !

Vous remarquerez quici nous nutilisons pas la notion Camel. Effectivement,
il est de coutume dcrire les noms de constantes en lettres majuscules. Cela
permet de les diffrencier des variables, et de prciser quil sagit bien dune
constante. Utilisez lunderscore _ pour sparer les diffrents mots lintrieur du nom de votre constante.
Le code prcdent na malheureusement aucun intrt et ne sert rien sans linitialisation
de la constante !
Initialisation
Tout comme une variable, il est important dinitialiser une constante. Vous pouvez procder exactement de la mme manire que pour une variable. La technique
dinitialisation dpend bien entendu du type de la constante.
Voici donc comment initialiser notre constante prcdente de type String :
1
const MA_CONSTANTE : String = " Valeur " ;
Contrairement aux variables, Il est strictement impossible dinitialiser la valeur

dune constante ailleurs que lors de sa dclaration. tant donn que la valeur
dune constante est non modifiable, nessayez pas non plus de procder une
affectation.
Intrt des constantes

Il y a certainement plus de la moiti, voire mme les trois quarts dentre vous qui se
sont pos la question suivante :
quoi ces constantes peuvent-elles bien servir ?
Contrairement ce que vous pensez, les constantes ont plusieurs utilits.

Tout dabord, elles permettent de mettre des noms sur des valeurs. Votre programme
ne marchera pas mieux avec cela, cest uniquement une question de clarification
du code. Avouez quil est quand mme plus ais de comprendre la signification
dune expression si celle-ci utilise des noms plutt que des valeurs : prixRoue *
NOMBRE_DE_ROUES plutt que prixRoue * 4. Dans le second cas, nous pourrions
nous demander sil sagit dune augmentation du prix dune roue, une conversion du
prix des euros aux dollars, ou bien une multiplication par le nombre de roues. Dans
la premire expression, lopration est tout fait claire ; ce qui simplifie grandement
le travail de relecture dun code.
Une autre utilit des constantes est de sassurer de la prennisation du code. Imaginez que le nombre de roues de votre voiture puisse servir plusieurs calculs comme
149

le prix de lensemble, son poids, etc. Vous devrez donc utiliser cette valeur plusieurs
fois dans votre code et des endroits diffrents. Ainsi, en utilisant une constante la
place de la valeur relle, vous facilitez une ventuelle mise jour de votre programme
dans lhypothse de linvention de la voiture 6 roues ! Essayez dimaginer le travail
quil aurait fallu fournir pour remplacer chacune des valeurs prsentes dans des coins
opposs de votre code.
Nutilisez pas non plus des constantes tour de bras dans vos programmes.
Leur but est de simplifier la lecture du code ; nallez donc pas le compliquer
davantage !
Un objet dans un objet (dans un objet. . .)

Jusqu prsent, nous navions utilis quune seule classe la fois. Mais l o la POO
devient vraiment intressante, cest lorsque nous combinons les classes entre elles !
Le problme du ptrole
Reprenons la classe Voiture :
1
2
3
4
5
6
7
8
9
package
{
{
/* ************** Attributs ************** */
10
11
12
13
14
15
16
17
18
/* ************ Constructeur ************ */

{
_marque = marque ;
_longueur = -1 ;
}
19
20
21
22
23
24
/* ************** Accesseurs ************** */

{
return _marque ;
}
25
26
150
UN OBJET DANS UN OBJET (DANS UN OBJET. . .)

{
27
28
29
return _couleur ;
30

{
return _longueur ;
}
31
32
33
34
35

{
}
36
37
38
39
40
/* ************** Mutateurs ************** */

void
{
}
41
42
43
44
45
46

{
}
47
48
49
50
51

{
}
52
53
54
55
56
57
58
59
Nous voulons prsent que nos objets contiennent de lessence. Pour cela, nous serions
tent de procder ainsi :
1
2
3
4
5
6
7
8
9
package
{
{
/* ************** Attributs ************** */
10
11
private var _typeEssence : String ;
151

12
13
private var _prixEssence : Number ;

private var _quantiteEssence : Number ;
14
15
16
17
18
19
20
21
22
23
24
25
/* ************ Constructeur ************ */

{
_marque = marque ;
_longueur = -1 ;
_typeEssence = " Sans Plomb " ;
_prixEssence = 1 . 4 ; // Euros par litre
_quantiteEssence = 10 ; // Litres
}
26
27
28
29
30
31
/* ************** Accesseurs ************** */

{
return _marque ;
}
32
33
34
35
36

{
return _couleur ;
}
37
38
39
40
41

{
return _longueur ;
}
42
43
44
45
46

{
}
47
48
49
50
51
public function get typeEssence () : String

{
return _typeEssence ;
}
52
53
54
55
56
public function get prixEssence () : Number

{
return _prixEssence ;
}
57
58
59
60
61
152
public function get quantiteEssence () : Number

{
return _quantiteEssence ;
}

62
/* ************** Mutateurs ************** */

void
{
}
63
64
65
66
67
68

{
}
69
70
71
72
73

{
}
74
75
76
77
78
public function set typeEssence ( nouveauType : String ) :

void
{
_typeEssence = nouveauType ;
}
79
80
81
82
83
public function set prixEssence ( nouveauPrix : Number ) :

void
{
_prixEssence = nouveauPrix ;
}
84
85
86
87
88
public function set quantiteEssence ( nouvelleQuantite :

Number ) : void
{
_quantiteEssence = nouvelleQuantite ;
}
89
90
91
92
93
94
95
96
Notre classe commence devenir complique, il vaudrait mieux crer une nouvelle
classe pour partager les proprits.
Une nouvelle classe

Crons une classe Essence mettre dans le fichier Essence.as :
1
package
153

2
3
4
5
6
7
8
public class Essence

{
/* ************** Attributs ************** */
private var _type : String ;
private var _prix : Number ;
private var _quantite : Number ;
/* ************ Constructeur ************ */

public function Essence ()
{
_type = " Sans Plomb " ;
_prix = 1 . 4 ; // Euros par litre
_quantite = 10 ; // Litres
}
10
11
12
13
14
15
16
17
/* ************** Accesseurs ************** */

public function get type () : String
{
return _type ;
}
18
19
20
21
22
23
public function get prix () : Number

{
return _prix ;
}
24
25
26
27
28
public function get quantite () : Number

{
return _quantite ;
}
29
30
31
32
33
/* ************** Mutateurs ************** */

public function set type ( nouveauType : String ) : void
{
_type = nouveauType ;
}
34
35
36
37
38
39
public function set prix ( nouveauPrix : Number ) : void

{
_prix = nouveauPrix ;
}
40
41
42
43
44
public function set quantite ( nouvelleQuantite : Number ) :

void
{
_quantite = nouvelleQuantite ;
}
45
46
47
48
49
50
154

51
52
Vous
pouvez lafficher pour la copier
en utilisant le code web ci-dessous.
Classe Essence
B
Code web : 750046

Nous transfrons donc toutes les proprits relatives lessence de la voiture dans la
nouvelle classe. Il va falloir maintenant adapter la classe Voiture :
1
2
3
4
5
6
7
8
9
package
{
{
/* ************** Attributs ************** */
10
11
private var _carburant : Essence ; // Nouvel attribut

pointant sur un objet de classe Essence !
12
13
14
15
16
17
18
19
20
21
/* ************ Constructeur ************ */

{
_marque = marque ;
_longueur = -1 ;
_carburant = new Essence () ; // Nous cr ons un objet
Essence par d faut dans le constructeur
}
22
23
24
25
26
27
/* ************** Accesseurs ************** */

{
return _marque ;
}
28
29
30
31
32

{
return _couleur ;
}
33
34
35
36
37

{
return _longueur ;
}
38
39
155

{
40
41
42
43
public function get carburant () : Essence // Nouvel

accesseur , renvoyant un objet de classe Essence
{
return _carburant ;
}
44
45
46
47
48
/* ************** Mutateurs ************** */

void
{
}
49
50
51
52
53
54

{
}
55
56
57
58
59

n ou ve ll e Im ma t ri cu la t io n : String ) : void
{
_immatriculation = no uv e ll eI mm a tr ic ul a ti on ;
}
60
61
62
63
64
65
66
67
68
69
public function set carburant ( nouveauCarburant : Essence )

: void // Nouveau mutateur , affectant un objet de
classe Essence
{
_carburant = nouveauCarburant ;
}
70
71
Comme vous pouvez le constater, nous pouvons crire des attributs pointant sur des
objets. Nous pourrions mme mettre un attribut de type Voiture !
private var ancienneVoiture : Voiture ; // L ' ancienne voiture du
propri taire
Pour modifier le carburant de notre voiture, il faut procder ainsi :

1
2
3
var maVoiture = new Voiture ( " Peugeot " ) ;

maVoiture . carburant . type = " Diesel " ;
trace ( " Type de carburant : " + maVoiture . carburant . type ) ; //
Affiche : Type de carburant : Diesel
156
EXERCICE : JEU DE RLE

Vous remarquerez que nous procdons de la mme faon que pour toutes les proprits,
en utilisant le caractre point . , comme nous lavons vu dans le premier chapitre
cette partie. Il suffit donc de mettre un point chaque fois que nous voulons accder
la proprit dun objet :
Une premire fois lorsque nous voulons accder la proprit carburant de notre
objet maVoiture.
Une seconde fois lorsque nous voulons modifier le type du carburant de la voiture.
Pour rsumer la situation, je vous propose un petit schma UML des classes Voiture
et Essence que nous venons de crer (voir figure 10.1).
Figure 10.1 Les classes Voiture et Essence

En ralit, nous combinons depuis le dbut la classe Voiture et la classe
String : beaucoup de nos attributs sont du type String. Rappelez-vous :
les chanes de caractres sont aussi des objets !
Exercice : Jeu de rle

Prsentation de lexercice
Le combat final contre le grand Mchant approche ! Votre personnage, son pe lgendaire au poing, se dresse devant cet immense monstre arm jusquaux dents !
Le moment est venu de passer la pratique ! Je propose la ralisation dun petit programme ressemblant un jeu de rle afin de bien revoir les notions essentielles du
chapitre.
Lobjectif de cet exercice est de crer la (ou les) classe(s) ncessaires au bon fonctionnement du programme principal (que nous adapterons si besoin). Voici le droulement
de ce programme :
Nous crons un objet reprsentant votre personnage, puis nous larmons.
157

Nous crons de faon similaire lobjet reprsentant le Mchant.
Le Mchant attaque une fois votre personnage.
Votre personnage riposte et attaque une fois le Mchant.
Pour apporter un peu de piment ce programme, les personnages peuvent succomber
aux attaques, et leur arme peut infliger un coup critique (elle a des chances dinfliger
le double de dgts ladversaire).
Nous allons passer par trois tapes successives, que jai nommes solutions, pour voir
comment programmer correctement en Orient Objet pas pas : chaque tape, nous
amliorerons notre code.
Il ne sagit pas dun TP : nous allons programmer ensemble et progressivement.
Solution initiale
Cration de la classe
Commenons par crer notre premire classe : jai choisi de lappeler Personnage.
En effet, ce sera la classe des objets reprsentant nos deux personnages (vous et le
Mchant). Dans un nouveau fichier, appel Personnage.as, crivons la structure de
base de notre classe : le package, la classe et le constructeur :
1
2
package
{
public class Personnage

{
4
5
6
// Constructeur
public function Personnage ()
{
7
8
9
10
11
12
13
Les attributs
Ensuite, ajoutons les attributs de la classe. Pour cela, rflchissons aux donnes utiles
pour notre combat. Comme dans tous les jeux avec des combats (ou presque), donnons
un niveau de sant nos personnages, que nous initialiserons 100. Et pour les armer,
indiquons la puissance de lattaque quils vont porter leur adversaire ainsi que les
chances de coup critique :
1
// Sant du personnage
158
EXERCICE : JEU DE RLE

2
private var _sante : int ;
3
4
5
// D g ts de base
private var _degats : int ;
6
7
8
// Chances de faire une critique ( sur 100 )

private var _chanceCritique : int ;
Les accesseurs
Noublions pas daccompagner les attributs de leurs accesseurs :
1
2
3
4
public function get sante () : int

{
return _sante ;
}
5
6
7
8
9
public function set sante ( value : int ) : void

{
_sante = value ;
}
10
11
12
13
14
public function get degats () : int

{
return _degats ;
}
15
16
17
18
19
public function set degats ( value : int ) : void

{
_degats = value ;
}
20
21
22
23
24
public function get chanceCritique () : int

{
return _chanceCritique ;
}
25
26
27
28
29
public function set chanceCritique ( value : int ) : void

{
_chanceCritique = value ;
}
Le contructeur
Ensuite, initialisons nos attributs au sein du constructeur :
1
2
3
// Constructeur
public function Personnage ()
{
159

4
5
6
7
sante = 100 ;
degats = 0 ;
chanceCritique = 0 ;
La mthode
Enfin, ajoutons une mthode, afin que nos personnages puissent attaquer un autre
personnage :
1
2
3
public function attaquer ( cible : Personnage ) : void

{
var degatsAppliques : int = degats ;
// On jette un d 100 faces : si le r sultat est inf

rieur ou gal la chance de coup critique , l '
attaque fait un coup critique !
if ( Math . random () * 100 <= chanceCritique )
{
trace ( " Critique ! " ) ;
// On double les d g ts !
degatsAppliques *= 2 ;
}
6
7
8
9

Langue

Programmez en Actionscript 3

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Programmez en Actionscript 3

Transféré par

Droits d'auteur :

Formats disponibles

Sauf mention contraire, le contenu de cet ouvrage est publi sous la licence :

Creative Commons BY-NC-SA 2.0

Contrairement aux ides prconues, lActionscript ne se cantonne pas uniquement

Quallez-vous apprendre en lisant ce livre ?

Comment lire ce livre ?

Pratiquez en mme temps

Utilisez les codes web !

Table des matires

Quallez-vous apprendre en lisant ce livre ? . . . . . . . . . . . . . . . . . . . .

Comment lire ce livre ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Suivez lordre des chapitres . . . . . . . . . . . . . . . . . . . . . . . . .

Pratiquez en mme temps . . . . . . . . . . . . . . . . . . . . . . . . . .

Utilisez les codes web ! . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Les bases de lActionscript

1 Vous avez dit Actionscript ?

Les drivs de Flash . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Quelques exemples dutilisation . . . . . . . . . . . . . . . . . . . . . . . . . .

Le dynamisme apport au web par lActionscript . . . . . . . . . . . . .

Cration de sites web orients vers le visuel . . . . . . . . . . . . . . . .

Introduction dAdobe Air . . . . . . . . . . . . . . . . . . . . . . . . . .

TABLE DES MATIRES

2 Votre premier programme avec Flex SDK

Installation des outils . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Version de dbogage du lecteur Flash . . . . . . . . . . . . . . . . . . . .

Crer les sources . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Compiler le programme de test . . . . . . . . . . . . . . . . . . . . . . .

Dis bonjour au monsieur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Structure de notre programme . . . . . . . . . . . . . . . . . . . . . . .

Commentez votre code ! . . . . . . . . . . . . . . . . . . . . . . . . . . .

Afficher un message dans la console . . . . . . . . . . . . . . . . . . . . .

Crons un projet Actionscript . . . . . . . . . . . . . . . . . . . . . . . .

Bien utiliser Flashdevelop . . . . . . . . . . . . . . . . . . . . . . . . . .

Compiler et tester notre projet . . . . . . . . . . . . . . . . . . . . . . .

Dclarer et utiliser des variables . . . . . . . . . . . . . . . . . . . . . . . . . .

Utiliser les variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Les diffrents types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Oprations sur les nombres . . . . . . . . . . . . . . . . . . . . . . . . .

TABLE DES MATIRES

chappement des caractres spciaux . . . . . . . . . . . . . . . . . . . .

Utiliser les variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Quelques variables et fonctions utiles . . . . . . . . . . . . . . . . . . . .

criture dune condition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Quest-ce quune condition ? . . . . . . . . . . . . . . . . . . . . . . . . .

Les oprateurs relationnels . . . . . . . . . . . . . . . . . . . . . . . . . .

Les oprateurs logiques

La priorit des oprateurs . . . . . . . . . . . . . . . . . . . . . . . . . .

Linstruction if. . .else . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

La structure avec else if . . . . . . . . . . . . . . . . . . . . . . . . . .

Une utilisation spcifique lActionscript . . . . . . . . . . . . . . . . .

La boucle do. . .while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Cration et appel de fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . .

TABLE DES MATIRES

Calcul dun maximum . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Les lments du tableau . . . . . . . . . . . . . . . . . . . . . . . . . . .

Proprits du type Array . . . . . . . . . . . . . . . . . . . . . . . . . .

Le type Vector . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100

La Programmation Oriente Objet

8 La POO dans tous ses tats

Les notions-cls . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112

TABLE DES MATIRES

Les lments statiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146

Une nouvelle classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153

Prsentation de lexercice . . . . . . . . . . . . . . . . . . . . . . . . . . 157