I. Introduction▲
De nos jours, il est de plus en plus important de développer des applications fiables, robustes et évolutives.
Pour résoudre ces problèmes, vous pouvez suivre un modèle de conception (ou design patterns).
Avec la méthode "Développement Facile", vous allez comprendre comment utiliser les modèles de conception, et ainsi réaliser des applications fiables, robustes et évolutives !
Retrouvez un extrait de la formation "Efficacité Boostée", composée de plus de 30 cours professionnels pour vous aider à progresser rapidement.
II. Comment créer des objets uniques avec une seule instance ?▲
Découvrez dans ce cours vidéo, le design pattern Singleton.
Vous verrez comment créer une instance unique d'un objet et avoir un accès identique depuis n'importe quel endroit de votre code.
Ci-dessous, deux exemples de singleton très pratique.
Sélectionnez
/**
The Initial Developer of the Original Code is
Matthieu - http://www.programmation-facile.com/
Portions created by the Initial Developer are Copyright (C) 2013
the Initial Developer. All Rights Reserved.
Contributor(s) :
*/
package
{
import flash.display.Sprite;
import com.demonsters.debugger.MonsterDebugger;
public class Config
{
private static var _oInstance : Config = null;// contient l'instance unique de la classe
private static var allowInstance:Boolean = false; // empêche l'instanciation de la classe à partir du constructeur
/* paramètres de notre classe de Configuration */
private var oSpriteDebug:Sprite;
private var oVueInter1:Sprite;
private var oVueInter2:Sprite;
/**
* Returns singleton instance of <code>Config</code> class.
*
* @return The singleton instance of <code>Config</code> class.
*/
public static function getInstance() : Config
{
// si l'instance n'existe pas, on la crée
if ( !(Config._oInstance is Config) )
{
allowInstance = true;// autorise la création d'une instance
Config._oInstance = new Config();
allowInstance = false;// désactive la création d'autre instance
}
// renvoie toujours la même instance de la classe
return Config._oInstance;
}
/**
* Constructeur
*/
public function Config() : void
{
if (!allowInstance)// test s'il est possible d'instancier la classe
{
MonsterDebugger.trace(this, 'This class cannot be instantiated from the constructor' );
// throw new Error ('This class cannot be instantiated from the constructor');
}
}
/**
* Définis les display objet utilisés par les vues et le debug.
*
*/
public function setDisplay( oVuesInterface1:Sprite, oVuesInterface2:Sprite,oDebug:Sprite) : void
{
oVueInter1 = oVuesInterface1;
oVueInter2 = oVuesInterface2;
oSpriteDebug = oDebug;
}
/**
* Renvoie le display objet pour toutes les interfaces graphiques de l'application.
*
*/
public function getDisplayInter1() : Sprite
{
return oVueInter1;
}
/**
* Renvoie le display objet pour toutes les interfaces graphiques de l'application.
*
*/
public function getDisplayInter2() : Sprite
{
return oVueInter2;
}
/**
* Renvoie le display objet pour le debug.
*
*/
public function getDisplayDebug() : Sprite
{
return oSpriteDebug;
}
}
}
Sélectionnez
<?php
/**
The Initial Developer of the Original Code is
Matthieu - http://www.programmation-facile.com/
Portions created by the Initial Developer are Copyright (C) 2013
the Initial Developer. All Rights Reserved.
Contributor(s) :
*/
/**
* @file Debugger.class.php
* @desc Cette classe permet d'effectuer du debug dans un fichier de log notamment avec AMFPHP.
*
* @author Matthieu
*
*
* @version 0.1
*/
/**
* @details :
* - si l'url du fichier de debug n'est pas precisee, celui ci se cree dans le meme repertoire que le fichier php qui instancie la classe Debugger.
*
*
* @usage :
* - Debugger::GetInstance()->init("fichier_log.txt", NULL, false); ou Debugger::GetInstance()->init("fichier_log.txt"); // initialisation de la classe
* - Debugger::GetInstance()->addlog("message de test"); // ajouter un message dans le fichier
* - Debugger::GetInstance()->clearlog(); // efface le contenu du fichier
* - Debugger::GetInstance()->output(); // afficher le contenu du fichier dans la fenetre courante
*
*/
class Debugger
{
/* constantes */
private static $o_instance = NULL; // instance unique de reference e la classe
/* configuration du fichier de sortie */
private $s_fileLocation; // url complete du fichier de log
private $b_newFile; // booleen creation d'un nouveau fichier de log ou si = false continuer l'ecriture de l'ancien fichier.
private $s_newLog = "\n--------------------------------- NOUVEAU LOG ---------------------------------\n"; // e chaque initialisation du fichier, creation d'une ligne de separation
// ---------------------------------- __construct() ----------------------------------------------------------
/**
* @brief Constructeur de la classe. vide pour l'instant.
* @param -
*/
private function __construct()
{
self::$o_instance = $this; // Sert pour la methode static GetInstance()
}
// -----------------------------------------------------------------------------------------------------------
// -------------------------------------- Methodes publiques ------------------------------------------------
// -----------------------------------------------------------------------------------------------------------
// ---------------------------------- init() ----------------------------------------------------------
/**
* @brief Initialisation de la classe.
*
* @param (string) le nom du fichier de log.
* @param (string) l'url du fichier de log (optionnel).
* @param (booleen) creation d'un nouveau fichier true->oui, efface le fichier de meme nom si present (optionnel).
*/
public function init($s_fileName, $s_fileUrl="", $b_newF=true)
{
$this->s_fileLocation = $s_fileUrl.$s_fileName;
$this->b_newFile = $b_newF;
$this->addlog($this->s_newLog);
}
// ---------------------------------- addlog() ----------------------------------------------------------
/**
* @brief Ajoute un message dans le fichier de log.
*
* @param (string) le message a ajouter.
* @return -
*/
public function addlog($s_message)
{
// si on doit creer un nouveau ficheir
if( $this->b_newFile ) $s_param = "w+";// place le pointeur de fichier au debut du fichier et reduit la taille du fichier a 0. Si le fichier n'existe pas, on tente de le creer.
else $s_param = "a+b";// ouvre le fichier, le curseur se place la fin pour continuer l'ecriture, creation si il n'existe pas, ecriture des donnees en mode binaire
$handle = fopen($this->s_fileLocation, $s_param);
$i_nb_octet = fwrite($handle, $s_message."\n"); // ecriture dans le fichier
if( $i_nb_octet===FALSE )
{
echo "impossible d'ecrire dans le fichier.";
exit;
}
// sinon ecriture reussi, on ferme le fichier
fclose($handle);
return;
}
// ---------------------------------- clearlog() ----------------------------------------------------------
/**
* @brief Efface le contenu du fichier de log.
*
* @param -
* @return -
*/
public function clearlog()
{
$s_message = "--------------- New Log--------------------";
$handle = fopen($this->s_fileLocation, "w+");
$i_nb_octet = fwrite($handle, $s_message."\n"); // ecriture dans le fichier
if( $i_nb_octet===FALSE )
{
echo "impossible d'ecrire dans le fichier.";
exit;
}
// sinon ecriture reussi, on ferme le fichier
fclose($handle);
return;
}
// ---------------------------------- output() ----------------------------------------------------------
/**
* @brief Effectue un echo de tous le contenu du fichier de log
*
* @param -
* @return -
*/
public function output()
{
if( file_exists($this->s_fileLocation) )
{
// affiche dans une zone textarea html
$file = fopen($this->s_fileLocation,'r');
?>
<input type="hidden" id="purge" name="purge" value="purge" />
<textarea name="infos" id="infos" rows="15" cols="150" class="menu"><?php while (!feof($file)){$donnees = fgets($file,255);echo $donnees ;} ?>
</textarea>
<?php
}
}
// ---------------------------------- GetInstance() ----------------------------------------------------------
/**
* @return (Debugger) Renvoie l'instance (unique) du Debugger
*/
public static function GetInstance()
{
if ( self::$o_instance == NULL ) self::$o_instance = new Debugger();
return self::$o_instance;
}
// -------------------------------------------------------------------------------------------------
// ---------------------------------------- Divers ------------------------------------------------
// -------------------------------------------------------------------------------------------------
/**
* @brief Destructeur de la classe
* Utilise pour enregistrer des messages pour le debogage, fermer les fichier ouverts en ecriture ou en lecture, realiser des operations
* de nettoyage des objets utilises...
*
* @param
* @return
*/
public function __destruct()
{
}
/**
* @brief Determine comment la classe doit reagir lorsqu'elle est convertie en chaene de caracteres.
*
* @usage echo(myObject) ou print(myObject)
* @return la representation de l'objet sous forme de chaene.
*/
public function __toString()
{
$s_classContent = "[Object ".__CLASS__."]<br />";
// parcours toutes les proprietes de la classe et les renvoie
foreach($this as $prop => $value)
{
$s_classContent .= "$prop => $value <br />";
}
return $s_classContent;
}
}
?>
III. Comment créer une API avec le modèle de conception "Command" ?▲
Dans cette vidéo, découvrez comment créer une Interface de Programmation d'Application (ou API),
qui permettra à d'autres développeurs d'utiliser votre application sans avoir accès à votre code.
Utilisez le modèle de conception "Command".
Ci-dessous, un exemple de modèle de conception Command en Action Script 3.
Le fichier ICommande.as :
Sélectionnez
/**
The Initial Developer of the Original Code is
Matthieu - http://www.programmation-facile.com/
Portions created by the Initial Developer are Copyright (C) 2013
the Initial Developer. All Rights Reserved.
Contributor(s) :
*/
package commande
{
/**
* Toutes les objets Commande implémentent les méthodes ci-dessous
*
* @author Matthieu
*/
public interface ICommande
{
function execute() : void;// pour exécuter la commande
function callBack() : void;// pour annuler la dernière commande exécutée "bouton annuler"
}
}
Le fichier Lampe.as :
Sélectionnez
/**
The Initial Developer of the Original Code is
Matthieu - http://www.programmation-facile.com/
Portions created by the Initial Developer are Copyright (C) 2013
the Initial Developer. All Rights Reserved.
Contributor(s) :
*/
package commande
{
import com.demonsters.debugger.MonsterDebugger;
/**
* Une lampe qui peut s'éteindre et s'allumer.
*
* @author Matthieu
*/
public class Lampe
{
private var sName:String;
public function Lampe(sValue:String)
{
sName = sValue;
MonsterDebugger.trace(this, "Création de la Lampe : "+sName);
}
public function marche() : void
{
MonsterDebugger.trace(this, "Lampe allumée : "+sName);
}
public function arret() : void
{
MonsterDebugger.trace(this, "Lampe éteinte : "+sName);
}
}
}
Le fichier LampeOff.as :
Sélectionnez
/**
The Initial Developer of the Original Code is
Matthieu - http://www.programmation-facile.com/
Portions created by the Initial Developer are Copyright (C) 2013
the Initial Developer. All Rights Reserved.
Contributor(s) :
*/
package commande
{
import commande.ICommande;
/**
* @author Matthieu
* La commande pour éteindre une lampe.
*
*/
public class LampeOff implements ICommande
{
private var oLampe:Lampe;// objet Lampe
/**
* constructeur
*/
public function LampeOff(oValue:Lampe)
{
oLampe = oValue;
}
/**
* Appui sur le bouton de la télécommande.
*
*/
public function execute() : void
{
oLampe.arret();
}
/**
* Appui par l'utilisateur sur le bouton Annuler.
*
*/
public function callBack() : void
{
oLampe.marche();
}
}
}
Le fichier MacroCommande.as :
Sélectionnez
/**
The Initial Developer of the Original Code is
Matthieu - http://www.programmation-facile.com/
Portions created by the Initial Developer are Copyright (C) 2013
the Initial Developer. All Rights Reserved.
Contributor(s) :
*/
package commande
{
/**
* Une MacroCommande lance plusieurs Commandes les unes à la suite des autres
*
* @author Matthieu
*/
public class MacroCommande implements ICommande
{
private var aCommandes:Array;// tableau contenant des références aux objets Commande
public function MacroCommande(aCmds:Array)
{
aCommandes = aCmds;
}
/**
* Parcours le tableau et exécute toutes les commandes
*
*/
public function execute() : void
{
// lancer la méthode execute() pour toutes les commandes.
for (var i : int = 0; i < aCommandes.length; i++)
aCommandes[i].execute();
}
/**
* Parcours le tableau et lance la méthode annulation de toutes les commandes
*
*/
public function callBack() : void
{
// lancer la méthode callBack() pour toutes les commandes.
for (var i : int = 0; i < aCommandes.length; i++)
aCommandes[i].callBack();
}
}
}
Le fichier Main.as :
Sélectionnez
/**
The Initial Developer of the Original Code is
Matthieu - http://www.programmation-facile.com/
Portions created by the Initial Developer are Copyright (C) 2013
the Initial Developer. All Rights Reserved.
Contributor(s) :
*/
package
{
import commande.MacroCommande;
import commande.LampeOff;
import commande.LampeOn;
import commande.ICommande;
import commande.Lampe;
import commande.Telecommande;
import com.actionscriptfacile.ui.text.UITextField;
import com.as3facile.DefaultButton;
import flash.events.MouseEvent;
import flash.display.Sprite;
import flash.events.Event;
import com.demonsters.debugger.MonsterDebugger;
/**
* Exemple d'utilisation du modèle de conception Observer.
*
*
*
* @author Matthieu
*/
public class Main extends Sprite
{
private var nPosX : Number;// position du champ texte
private var nPosY : Number;// position du champ texte
public function Main()
{
// attend la fin de l'initialisation de la scène
this.addEventListener(Event.ADDED_TO_STAGE, onReady, false, 0, true);
}
/**
* Démarrage de l'application.
*
*/
protected function onReady(event : Event) : void
{
this.removeEventListener(Event.ADDED_TO_STAGE, onReady);
// Init De MonsterDebugger
MonsterDebugger.initialize(this);
MonsterDebugger.trace(this, "Modele de conception : Command");
// construction de la page
this.setupUI();
}
/**
* Création d'un bouton pour le pattern Decorator.
*
*/
private function setupUI():void
{
nPosX = 30;
nPosY = 15;
var oBtnStart:DefaultButton = new DefaultButton();
oBtnStart.getObject().label = "Lancez Commande !";
oBtnStart.getObject().x = nPosX;
oBtnStart.getObject().y = nPosY;
oBtnStart.getObject().addEventListener ( MouseEvent.CLICK, onRunCommand );
this.addChild(oBtnStart);
nPosY += 50;
}
/**
* Après le click sur le bouton.
*
*/
private function onRunCommand(e : MouseEvent) : void
{
this.removeEventListener(MouseEvent.CLICK, onRunCommand);
var sTxt1:String = "Création de la Télécommande";
MonsterDebugger.trace(this, sTxt1);
var oText1:UITextField = this.addText( sTxt1, nPosX, nPosY);
nPosY += 32;
this.addChild(oText1);
/* test de notre télécommande */
var oTelecommande:Telecommande = new Telecommande();
// création des lampes
var oLampeCuisine:Lampe = new Lampe("Cuisine");
var oLampeSejour:Lampe = new Lampe("Séjour");
var oLampeChambre:Lampe = new Lampe("Chambre");
// création des objets commandes de lampes (les interrupteurs)
var oCmdLampeOnCuisine:ICommande = new LampeOn(oLampeCuisine);
var oCmdLampeOffCuisine:ICommande = new LampeOff(oLampeCuisine);
var oCmdLampeOnSejour:ICommande = new LampeOn(oLampeSejour);
var oCmdLampeOffSejour:ICommande = new LampeOff(oLampeSejour);
var oCmdLampeOnChambre:ICommande = new LampeOn(oLampeChambre);
var oCmdLampeOffChambre:ICommande = new LampeOff(oLampeChambre);
// chargement des commandes dans la télécommande
oTelecommande.addCommande(0, oCmdLampeOnSejour, oCmdLampeOffSejour);
oTelecommande.addCommande(1, oCmdLampeOnCuisine, oCmdLampeOffCuisine);
oTelecommande.addCommande(2, oCmdLampeOnChambre, oCmdLampeOffChambre);
var oText2:UITextField = this.addText( sTxt1, nPosX, nPosY);
nPosY += 32;
this.addChild(oText2);
// allume et éteind les différentes lampes
oTelecommande.onBtnOn(0);
oTelecommande.onBtnOn(1);
oTelecommande.onBtnOn(2);
oTelecommande.onBtnOff(2);
oTelecommande.onBtnOff(1);
oTelecommande.onBtnOff(0);
MonsterDebugger.trace(this, "Bouton Annuler");
oTelecommande.onBtnAnnuler();
oTelecommande.onBtnOn(2);
// création d'une MacroCommande
var aAllumeAll:Array = [oCmdLampeOnCuisine, oCmdLampeOnSejour, oCmdLampeOnChambre];
var aEteindAll:Array = [oCmdLampeOffCuisine, oCmdLampeOffSejour, oCmdLampeOffChambre];
var oAllumeAll:ICommande = new MacroCommande(aAllumeAll);
var oEteindAll:ICommande = new MacroCommande(aEteindAll);
oTelecommande.addCommande(3, oAllumeAll, oEteindAll);// ajout de la MacroCommande
MonsterDebugger.trace(this, "MacroCommande");
oTelecommande.onBtnOff(3);// exécution du groupe de Commande (la MacroCommande)
oTelecommande.onBtnAnnuler();
}
/**
* Création d'un champ texte.
*
*/
private function addText(sValue:String, nX:Number, nY:Number) : UITextField
{
var oTxtField:UITextField = new UITextField();
oTxtField.text = sValue;
oTxtField.selectable = false;
oTxtField.autoSizeNone();
oTxtField.wordWrap = true;
//oTxtField.multiline = true;// plusieurs lignes dans le champ texte
oTxtField.maxHeight = oTxtField.height = 26;
oTxtField.maxWidth = oTxtField.width = 450;
oTxtField.x = nX;
oTxtField.y = nY;
oTxtField.background = true;
oTxtField.backgroundColor = 0xcccccc;
oTxtField.changeFormat("size", 15);// changement de la taille de la police du texte
oTxtField.changeFormat("font", "Arial");// changement de la taille de la police du texte
oTxtField.changeFormat("color", Math.random() *0X006f77);// changement de la couleur
return oTxtField;
}
}
}
Le fichier Telecommande.as :
Sélectionnez
/**
The Initial Developer of the Original Code is
Matthieu - http://www.programmation-facile.com/
Portions created by the Initial Developer are Copyright (C) 2013
the Initial Developer. All Rights Reserved.
Contributor(s) :
*/
package commande
{
import com.demonsters.debugger.MonsterDebugger;
import flash.utils.getQualifiedClassName;
/**
* @author Matthieu
* La télécommande gère plusieur commandes marche ou arrêt.
*
*/
public class Telecommande
{
// tableaux contenant les commandes
private var aTurnOn:Array;// la liste des boutons (commandes) marche - on
private var aTurnOff:Array;// la liste des boutons (commandes) arrêt - off
private var oCmdAnnuler:ICommande;// pour le bouton annuler - lance la commande d'annulation
/**
* constructeur.
*
*/
public function Telecommande()
{
aTurnOn = new Array();
aTurnOff = new Array();
/**
* PasDeCommande est un Objet Null pour éviter d'ajouter un test avant d'appeler la méthode execute.
* L'utilisation d'un Objet Null est utilisé dans de nombreux modèle de conception.
* Cela permet de simplifier et d'optimiser le code.
*/
var oCommande:PasDeCommande = new PasDeCommande();
// initialisation par défaut de tous les boutons
for (var i : int = 0; i < 7; i++) // il y a 7 boutons différents sur notre télécommande
{
aTurnOff[i] = oCommande;
aTurnOn[i] = oCommande;
}
oCmdAnnuler = oCommande;
}
/**
* Ajout d'une commande.
* Permet de configurer un bouton de la télécommande.
*
* @param nPos : la position du bouton
* @param oOn : la commande marche
* @param oOff : la commande arrêt
*
*/
public function addCommande(nPos:int, oOn:ICommande, oOff:ICommande) : void
{
aTurnOn[nPos] = oOn;
aTurnOff[nPos] = oOff;
}
/**
* Appuie sur le bouton marche
*
*/
public function onBtnOn(nPos:int) : void
{
aTurnOn[nPos].execute();// Appel sur l'objet sa méthode execute()
oCmdAnnuler = aTurnOn[nPos];// mémorise la dernière commande exécutée
}
/**
* Appuie sur le bouton arrêt.
*
*/
public function onBtnOff(nPos:int) : void
{
aTurnOff[nPos].execute();// Appel sur l'objet sa méthode execute()
oCmdAnnuler = aTurnOff[nPos];// mémorise la dernière commande exécutée
}
/**
* L'utilisateur appuie sur le bouton annuler de la télécommande.
*
*/
public function onBtnAnnuler() : void
{
oCmdAnnuler.callBack();// exécute la commande d'annulation du bouton
}
/**
* Renvoie une représentation de la classe sous forme de caractères.
*
*/
public function toStringe() : String
{
MonsterDebugger.trace(this, "toString");
var sOutput:String = "commande.Telecommande";
//sOutput += "\n\n";
MonsterDebugger.trace(this, "sOutput "+sOutput);
for (var i : int = 0; i < aTurnOn.length; i++)
{
sOutput += "emplacement : "+ getQualifiedClassName(aTurnOn[i])+" arrêt : "+getQualifiedClassName(aTurnOff[i])+"\n";
}
return sOutput;
}
}
}
IV. Comment créer des architectures faiblement couplées ?▲
Découvrez dans cette vidéo un nouveau modèle de conception : la Fabrique Simple.
Ci-dessous un exemple de code de la fabrique simple en Action Script 3
Le fichier AbstractPizza.as
Sélectionnez
/**
The Initial Developer of the Original Code is
Matthieu - http://www.programmation-facile.com/
Portions created by the Initial Developer are Copyright (C) 2013
the Initial Developer. All Rights Reserved.
Contributor(s) :
*/
package fabriquepizza.pizza
{
import fabriquepizza.fabriqueingredients.IFactoryIngredientsPizza;
import fabriquepizza.ingredients.Fromage;
import fabriquepizza.ingredients.Legumes;
import fabriquepizza.ingredients.Moules;
import fabriquepizza.ingredients.Pate;
import fabriquepizza.ingredients.Poivrons;
import fabriquepizza.ingredients.Sauce;
import com.demonsters.debugger.MonsterDebugger;
import flash.errors.IllegalOperationError;
import flash.utils.getQualifiedClassName;
/**
* @author Matthieu
* Le produit de la Fabrique (les fabriques).
*
* Classe abstraite Pizza.
* Nos pizzas doivent utiliser uniquement les ingrédients de notre fabrique.
*
*/
public class AbstractPizza implements IAbstractPizza
{
/* liste des ingrédients d'une pizza */
protected var sName:String;
protected var oPate:Pate;
protected var oSauce:Sauce;
protected var aLegumes:Legumes;
protected var oFromage:Fromage;
protected var oPoivrons : Poivrons;
protected var oMoules : Moules;
protected var oFabriqueIngredients:IFactoryIngredientsPizza;// les ingrédients pour créer la pizza
/**
* Constructeur protégé pour ne pas être instancié directement.
*
*/
public function AbstractPizza()
{
if(getQualifiedClassName(this) == "AbstractPizza")
throw new IllegalOperationError("AbstractPizza est une classe Abstraite, vous ne pouvez pas l'instancier directement.");
}
/**
* Récupération de tous les ingrédients nécessaires pour la pizza.
*
*/
public function preparer() : void
{
MonsterDebugger.trace(this, "Préparation de la Pizza : "+sName);
}
/**
* La cuisson de la pizza
*
*/
public function cuir() : String
{
return "Cuisson 25 minutes à 180°";
}
/**
* Emballage de la pizza.
*
*/
public function emballer() : String
{
return "Emballage dans une boîte officielle de la maison mère";
}
/**
* Découpe de la pizza.
*
*/
public function couper() : String
{
return "Découpe la pizza en huit parts égales";
}
/**
* Pour définir le nom de la pizza.
*
*/
public function setName(sValue:String) : void
{
sName = sValue;
}
public function getName() : String
{
return sName;
}
}
}
Le fichier FabriqueSimplePizza.as
Sélectionnez
/**
The Initial Developer of the Original Code is
Matthieu - http://www.programmation-facile.com/
Portions created by the Initial Developer are Copyright (C) 2013
the Initial Developer. All Rights Reserved.
Contributor(s) :
*/
package fabriquepizza.pizzeria
{
import fabriquepizza.AbstractPizzeria;
import fabriquepizza.fabriqueingredients.FactoryIngredientsPizzaBrest;
import fabriquepizza.pizza.AbstractPizza;
import fabriquepizza.pizza.PizzaFromage;
import fabriquepizza.pizza.PizzaFruitsDeMer;
/**
* @author Matthieu
* Le client de la Fabrique.
*
* Création de la franchise à Brest.
*
*/
public class FabriqueSimplePizza
{
public function FabriqueSimplePizza()
{
}
public function creerPizza(sTypePizza : String) : AbstractPizza
{
/* création de la pizza en fonction de la demande du client */
if(sTypePizza == "fromage")
{
oPizza = new PizzaFromage();
oPizza.setName("Pizza au fromage style Brest");
}
else if(sTypePizza == "fruitsdemer")
{
oPizza = new PizzaFruitsDeMer();
oPizza.setName("Pizza aux fruits de mer style Brest");
}
else
{
oPizza = new PizzaFromage();
oPizza.setName("La Pizza demandée n'existe pas... Pizza au fromage par défaut !");
}
return oPizza;
}
}
}
Le fichier PizzaFromage.as
Sélectionnez
/**
The Initial Developer of the Original Code is
Matthieu - http://www.programmation-facile.com/
Portions created by the Initial Developer are Copyright (C) 2013
the Initial Developer. All Rights Reserved.
Contributor(s) :
*/
package fabriquepizza.pizza
{
import fabriquepizza.fabriqueingredients.IFactoryIngredientsPizza;
/**
* @author Matthieu
* Création de la pizza Fromage (le créateur concret).
*
* La fabrique d'ingrédients va gérer les ingrédients suivant la franchise.
*
*/
public class PizzaFromage extends AbstractPizza
{
public function PizzaFromage(oPizza:IFactoryIngredientsPizza)
{
oFabriqueIngredients = oPizza;
sName = "Fromage";
}
override public function preparer() : void
{
super.preparer();
/* création de notre pizza fromage avec les ingrédients dont nous avons besoin */
oPate = oFabriqueIngredients.creerPate();
oSauce = oFabriqueIngredients.creerSauce();
oFromage = oFabriqueIngredients.creerFromage();
}
}
}
Le fichier Pizzeria.as
Sélectionnez
/**
The Initial Developer of the Original Code is
Matthieu - http://www.programmation-facile.com/
Portions created by the Initial Developer are Copyright (C) 2013
the Initial Developer. All Rights Reserved.
Contributor(s) :
*/
package fabriquepizza
{
import avmplus.getQualifiedClassName;
import fabriquepizza.fabriqueingredients.IFactoryIngredientsPizza;
import fabriquepizza.pizza.AbstractPizza;
import flash.errors.IllegalOperationError;
/**
* @author Matthieu
* La fabrique (le créateur) pour créer les Pizzas (pattern factory)
*
* Notre maison mère la pizzeria déclinée pour toutes les franchises.
*
*/
public class Pizzeria
{
private var oPizza:AbstractPizza;
private var oFabriquePizza:FabriqueSimplePizza;
/**
* Constructeur protégé pour ne pas être instancié directement.
*
*/
public function Pizzeria(oFabPizzas:FabriqueSimplePizza)
{
oFabriquePizza = oFabPizzas;
}
/**
* Commande la pizza choisit par le client.
*
*/
public function commanderPizza(sTypePizza:String) : AbstractPizza
{
oPizza = oFabriquePizza.creerPizza(sTypePizza);
oPizza.preparer();
oPizza.cuir();
oPizza.couper();
oPizza.emballer();
return oPizza;
}
}
}
V. Comment structurer votre code avec MVC ?▲
Dans cette vidéo, découvrez le modèle de conception le plus utilisé, le Model View Controler.
Ce pattern permet de structurer vos applications avec une maintenance aisée, des évolutions simples et des performances optimales .
VI. Recevez gratuitement la formation "Efficacité Boostée"▲
Si vous souhaitez aller plus loin dans la création rapide d'application fiable, robuste et évolutive,
vous pouvez recevoir gratuitement la formation "Efficacité Boostée", une puissante méthode d'organisation pour faire plus en moins de temps..
Ainsi, vous progressez à votre rythme, avec un suivi personnalisé et individuel. Vous avez la possibilité de poser toutes vos questions à la fin de chaque cours.
Vous allez ainsi découvrir comment doubler voire tripler votre capacité de développement applicatif 
Cliquez simplement ici pour recevoir gratuitement la formation "Efficacité Boostée" !Cliquez simplement ici pour recevoir gratuitement la Formation Efficacité Boostée !
VII. Remerciements▲
Merci beaucoup à l'équipe de rédaction de Developpez.com de contribuer à la diffusion de ce tutoriel.
J'adresse également un merci tout particulier à Jean-PhilippeJean-Philippe pour sa relecture orthographique.
