Avec Flash, il existe une méthode de programmation connue de beaucoup, la programmation procédurale. Cette méthode utilise les images clés pour la saisie du code et est basée sur l'utilisation de fonctions qui s'exécutent dans un ordre précis et qui assurent le bon fonctionnement du programme.

Sur un programme assez important, cela peut devenir difficile à maintenir car les comportements ne sont pas isolés.

La seconde méthode, la programmation orientée objet (POO), va permettre de séparer les tâches d'une application

La programmation orientée objet propose une nouvelle façon de concevoir et de développer des applications, de manière à améliorer :

• La structuration du code, afin de mieux pouvoir le comprendre
• La réutilisabilité du code, afin de réduire les coûts de développement
• La robustesse du code, afin de réduire les bugs et les arrêts brutaux des logiciels

Programmer de manière objet, consiste à abstraire les personnes et objets du monde qui nous entoure, de manière à pouvoir les recréer sous forme d'objet dans la mémoire d'un ordinateur. Chaque objet possède des données propres et des données partagées avec d'autres objets de même nature, et offre des services aux autres objets

Voici un exemple de programmation orientée objet :

• porte.ouvrir()
• ampoule.allumer()

La programmation orientée objet va engendrer la réalisation de tâches fréquentes :

• Définition des classes
• Création de propriétés, méthodes et accesseurs de lecture et de définition (méthodes accesseurs)
• Contrôle de l'accès aux classes, propriétés, méthodes et accesseurs
• Création de propriétés et de méthodes statiques
• Création de structures d'énumération
• Définition et utilisation d'interfaces
• Utilisation de l'héritage, y compris lors de la redéfinition des éléments des classes

Une classe est une représentation abstraite d'un objet. Une classe est assimilée à :

• Un moule
• Un modèle

Une classe conserve des informations sur les types de données contenues par un objet et sur les comportements possibles de cet objet. Une classe est un type de données, et permet de créer des objets. Une classe est un fichier avec l'extension .as. Toute classe dérive (soit directement, soit indirectement de la classe Object) Autopsie d'une classe :

Les packages permettent dans un premier temps d'organiser les classes en indiquant dans quel répertoire est située une classe.

Le compilateur trouvera la classe selon le chemin renseigné par lepackage, afin de définir un paquetage nous utilisons le mot clé package.

package fr.as3.bases.poo
{
 
}

Le package correspond à l'arborescence des répertoires.

La syntaxe d'une définition de classe utilise le mot-clé class suivi du nom de la classe. Une classe est enregistré dans un fichier portant le même nom que la classe et avec l'extension .as.

Le corps de la définition de classe est inséré entre des accolades ({}) après le nom de la classe.

Le nom de la classe commence par une majuscule.

package fr.as3.bases.poo
{
	public class Voiture
	{
		public function Voiture()
		{
 
		}
	}
} 

Afin de pouvoir instancier notre classe depuis l'extérieur nous devons utiliser l'attribut de classe public.

ActionScript 3 propose 4 attributs pour les classes :

• internal(par défaut)

Visible uniquement dans le package dans lequel elle se trouve

• public

visible par tous

• final

La classe ne peut pas être étendue par une autre

• dynamic

Permet d'ajouter des propriétés aux instances lors de l'exécution.

Les attributs final et dynamic se combinent avec les attributs d'accès internal et public :

• public final class Voiture
• public dynamic class Voiture
• internal dynamic class Voiture

Pour pouvoir utiliser une classe, nous spécifierons son chemin au compilateur en utilisant l'instruction import.

import fr.as3.bases.poo.Voiture;

Pour pouvoir créer une instance de notre classe, nous utiliserons le mot clé new.

package fr.as3.bases.vues
{
	import flash.display.MovieClip;
	import fr.as3.bases.poo.Voiture;
 
	public class Main extends MovieClip
	{
		public function Main()
		{
			var voiture:Voiture = new Voiture("Renault", "Grise");
		}
	}
}

Sémantiquement parlant, les propriétés ou membres d'un objet sont l'ensemble de ses attributs et méthodes. Un abus de langage quasi-systématique consiste à appeler “propriétés” uniquement les attributs de l'objet.

Adobe ayant opté pour cette option, nous utiliserons aussi le terme de propriétés pour définir les attributs d'une classe.

Les propriétés d'un objet décrivent ses caractéristiques. Elles sont utilisées comme conteneur de données.

Généralement, les propriétés d'une classe sont définies juste en dessous de la définition de la classe.

package fr.as3.bases.poo
{
	public class Voiture
	{
		var marque:String;
		var couleur:String;
 
		public function Voiture()
		{
		}
	}
}

Les propriétés peuvent utiliser un des 5 attributs suivants :

• internal (par défaut) :

Par défaut, le membre est accessible uniquement depuis le paquetage en cours.

• public :

Accessible depuis n'importe quelle partie du code.

• private :

Le membre n'est accessible que depuis la même classe. Les sous-classes n'ont pas accès au membre.

• protected :

Le membre est accessible depuis la même classe, et les sous-classes.

• static :

Le membre est accessible uniquement depuis la classe, non depuis les instances.

Les méthodes sont des fonctions associées à la définition d'une classe. Lorsqu'une instance de la classe est créée, une méthode est liée à cette instance.

Pour déclarer une méthode, utilisez le mot-clé function.

function fonctionExample() :void
{
}

Les propriétés peuvent utiliser un des 5 attributs suivants :

• internal (par défaut) :

Par défaut, le membre est accessible uniquement depuis le paquetage en cours.

• public :

Accessible depuis n'importe quelle partie du code.

• private :

Le membre n'est accessible que depuis la même classe. Les sous-classes n'ont pas accès au membre.

• protected :

Le membre est accessible depuis la même classe, et les sous-classes.

• static :

Le membre est accessible uniquement depuis la classe, non depuis les instances.

La méthode constructeur, parfois appelées simplement constructeur, est une fonction qui porte le nom de la classe dans laquelle elle est définie. Tout code figurant dans une méthode constructeur est exécuté lorsqu'une instance de la classe est créée à l'aide du mot-clé new.

La méthode constructeur est obligatoirement publique, mais l'attribut public est facultatif. Il est impossible d'utiliser l'un des autres spécificateurs de contrôle d'accès (private, protected ou internal) avec un constructeur.

package fr.as3.bases.poo
{
	public class Voiture
	{
		var marque:String;
		var couleur:String;
 
		public function Voiture()
		{
		}
	}
}

Le constructeur peut-être utilisé pour initialiser les propriétés de l'objet. Dans ce cas, le constructeur possède des paramètres et ces paramètres sont utilisés pour valoriser les propriétés de l'objet.

package fr.as3.bases.poo
{
	public class Voiture
	{
		var marque:String;
		var couleur:String;
 
		public function Voiture(valMarque:String, valCouleur:String)
		{
			marque = valMarque;
			couleur = valCouleur;
		}
	}
}

Les paramètres peuvent être facultatifs. On leur donne donc une valeur initiale qui sera utilisé si le paramètre n'est pas utilisé.

package fr.as3.bases.poo
{
	public class Voiture
	{
		var marque:String;
		var couleur:String;
 
		public function Voiture(valMarque:String, valCouleur:String = "blanche")
		{
			marque = valMarque;
			couleur = valCouleur;
		}
	}
}

En programmation orienté objet, l'encapsulation est l'idée de cacher l'information contenue dans un objet et de ne proposer que des méthodes de manipulation de cet objet.

L'objet est ainsi vu de l'extérieur comme une boîte noire ayant certaines propriétés et ayant un comportement spécifié.

Pour manipuler notre objet et modifier certaines de ses caractéristiques, nous utiliserons des méthodes spécifiques, appelées accesseurs.

Les méthodes accesseurs de lecture et de définition, également appelées getters et setters, permettent d'adhérer aux principes de l'encapsulation d'informations tout en offrant une interface de programmation d'emploi facile pour vos classes.

Les fonctions de lecture et de définition (get et set) permettent de garder privées les propriétés d'une classe, tout en permettant à l'utilisateur de cette classe d'accéder à ces propriétés comme s'ils accédaient à une variable de classe au lieu d'appeler une méthode de classe.

Nous allons définir nos propriétés comme étant privés. Elles ne seront pas accessibles directement par les développeurs qui utilisent notre classe.

Par convention, nous utilisons l'underscore pour débuter le nom de la propriété. Les conventions d'écritures proposées par Adobe sont traitées dans un autre sujet.

package fr.as3.bases.poo
{
	public class Voiture
	{
		private var _marque:String;
		private var _couleur:String;
 
		public function Voiture()
		{
 
		}
	}
}

Afin de définir les accesseurs, nous utilisons 2 mots clés :

• get : définit une méthode de lecture
• set : définit une méthode d'écriture

Le nom de l'accesseur sera celui de la propriété sans l'underscore.

Un getter utilise la syntaxe suivante :

public function get maPropriete() :type
{
	return _maPropriete ;
}

Il ne doit posséder aucun paramètre et renvoyer la valeur de la propriété.

Un setter utilise la syntaxe suivante :

public function set maPropriete(nouvelleValeur :type) :void
{
	_maPropriete = nouvelleValeur ;
}

Il doit posséder au moins un paramètre et ne retourner aucune valeur (void).

package fr.as3.bases.poo
{
	public class Voiture
	{
		private var _marque:String;
		private var _couleur:String;
 
		public function Voiture(valMarque:String, valCouleur:String)
		{
			marque = valMarque;
			couleur = valCouleur;
		}
 
		public function get marque():String
		{
			return _marque;
		}
 
		public function set marque(value:String):void
		{
			_marque = value;
		}
 
		public function get couleur():String
		{
			return _couleur;
		}
 
		public function set couleur(value:String):void
		{
			_couleur = value;
		}
	}
} 

Tout comme en Java, il nous est possible d'utiliser des méthodes en tant qu'accesseurs.

public function getCouleur():String
{
	return _couleur;
}
 
public function setCouleur(value:String):void
{
	_couleur = value;
}

Un autre intérêt de l'encapsulation est de pouvoir contrôler l'affectation de valeurs aux propriétés. Avec un accès direct aux propriétés, il nous serait par exemple impossible de formater la marque du véhicule en majuscules.

Le setter va nous permettre ce formatage.

public function set marque(value:String):void
{
	marque = value.toUpperCase();
}

Les méthodes d'instance Les méthodes d'une classe définissent les actions, les capacités d'une classe. Les noms des méthodes sont des verbes à l'infinitif, car ils désignent des actions. Les méthodes d'instance sont affectées à une instance et non à la classe elle-même.

public function toString():String
{
	return "Voiture " + _marque + " de couleur " + _couleur;
}

var voiture:Voiture = new Voiture("Renault", "Grise");
trace(voiture.toString()); //affiche Voiture RENAULT de couleur Grise

Les méthodes statiques, également appelées méthodes de classe, sont déclarées avec le motclé static. Les méthodes statiques sont affectées à une classe, plutôt qu'à une instance de classe.

Elles permettent d'encapsuler des fonctionnalités qui ont une portée plus étendue que l'état d'une instance individuelle. Comme les méthodes statiques sont affectées à une classe en tant que telle, elles ne sont accessibles que via une classe, et non pas par une instance de la classe.

Dans une méthode statique, on ne peut accéder qu'à des membres statiques.

package fr.as3.bases.poo
{
	public class Voiture
	{
		private var _marque:String;
		private var _couleur:String;
		private static var _nombreVoitures:int;
 
		public function Voiture(valMarque:String, valCouleur:String)
		{
			marque = valMarque;
			couleur = valCouleur;
			_nombreVoitures++;
		}
 
		public function get marque():String
		{
			return _marque;
		}
 
		public function set marque(value:String):void
		{
			_marque = value;
		}
 
		public function get couleur():String
		{
			return _couleur;
		}
 
		public function set couleur(value:String):void
		{
			_couleur = value;
		}
		public function toString():String
		{
			return "Voiture " + _marque + " de couleur " + _couleur;
		}
 
		public static function getNombreVoitures():int
		{
			return _nombreVoitures;
		}
	}
} 

var voiture:Voiture = new Voiture("Renault", "Grise");
trace(voiture.toString()); //affiche Voiture RENAULT de couleur Grise
var voiture3:Voiture = new Voiture("Opel", "Noire");
trace(Voiture.getNombreVoitures());//affiche 2

Dans une seconde partie, nous étudierons d'autres fonctions : héritage, polymorphisme, interface…