Le modèle fabrication(Factory Method Pattern)

Intention de factory method

Le pattern factory method définit une interface pour la création d'un objet en laissant à des sous-classes le choix des classes à instancier.

Contents Haut

Motivation de factory method

Les utilisent des classes abstraites pour définir et gérer les relations entre les objets. Un framework est souvent responsable de la création de ces objets.

Considérons un framework pour des aplications qui présentent des documents multiples à l'utilisateur. Deux clés abstraites fondamentales de ce framework sont les classes Application et Document. Nous devons dériver des sous-classes concrètes pour réaliser les implémentations spécifiques de ces deux classes. Pour créer une application de dessin par exemple, nous devons créer les classes DrawingApplication et DrawingDocument. La classe Application est responsable de la gestion des Documents, et de leur création si nécessaire - lorsque l'utilisateur sélectionne Open ou New dans un menu, par exemple.

Puisque la sous-classe particulière de Document à instancier est dépendante du type d'application, la classe Application ne peut prévoir la sous-classe de Document qu'il convient d'instancier - la classe Application connait seulement le moment où un Document doit être créé, mais pas le type de Document à créer. Cette situation crée un dilemne : le framework doit instancier des classes, mais il ne connait que des classes abstraites, qui ne peuvent être instanciées.

Le pattern factory method nous offre donc une solution : encapsuler la connaissance du type de sous-classe de Document à créer, et déplacer cette connaissance hors du framework.

Les sous-classes d'Application redéfinissent par surcharge une opération abstraite d'Application nommée createDocument, afin de retourner la sous-classe de Document qui convient. Dès qu'une sous-classe Application est instanciée, elle peut à son tour instancier des Documents spécifiques de l'Application, sans connaître leur classe. La méthode createDocument est une factory method car elle est responsable de la fabrication d'un objet.

Contents Haut

Utilisation de factory method

Le modèle fabrique peut nous aider dans les cas suivants :

• Une classe ne peut prévoir la classe des objets qu'elle devra créer.
• Une classe désire que ses sous-classes spécifient les objets qu'elle crée
• Les classes délèguent des responsabilités à une de leurs nombreuses sous-classes assistantes, et nous désirons localiser le fait de savoir quelle sous-classe assistante a reçu cette délégation.

Contents Haut

Structure de factory method

Contents Haut

Constituants de factory method

• Product (produit abstrait ou interface)
  Définit l'interface des objets créés par l'opération factoryMethod. Dans le cadre de notre exemple, le produit est Document.
• ConcreteProduct (produit concret)
  Implémente l'interface Product. Dans le cadre de notre exemple, le produit concret est MyDocument.
• Creator (facteur - )
  Déclare l'opération factoryMethod qui retourne un objet de type Product. Creator peut aussi définir une implémentation par défaut de factoryMethod, qui retourne un objet ConcreteProduct par défaut. Il peut en outre faire un appel à factoryMethod pour créer un objet Product. Dans le cadre de notre exemple, le facteur est Application.
• ConcreteCreator (facteur concret)
  Override (surcharge) l'opération factoryMethod pour retourner une instance du ConcreteProduct approprié. Dans le cadre de notre exemple, le facteur concret est MyApplication.

Contents Haut

Collaborations de factory method

Creator confie à ses sous-classes le soin de la définition de la fabrication, de sorte qu'il renvoie une instance du ConcreteProduct approprié.

Contents Haut

Conséquences de factory method

Implémentation de factory method

Deux variantes principales :

• Creator est une classe abstraite et ne fournit pas d'implémentation pour la fabrication qu'elle déclare.
• Creator est une classe concrète qui fournit une implémentation par défaut pour la fabrication.

NB : nous pouvons aussi plus rarement trouver le cas d'une classe abstraite qui fournit une implémentation par défaut.

Fabrication paramétrée. Dans ce cas, nous permettons à la méthode factory de créer de nombreuses espèces de produits. La méthode factory utilise alors un paramètre pour déterminer le type d'objet à créer, pourvu que chaque type implémente Product.

Contents Haut

Exemples de codes

using System;
class Document
{
public:
virtual void setPosition( int x, int y ) =0 ;
virtual void redisplay() =0 ;
//...
} ;
class Application
{
public:
int run()
{
//...
newDocument() ;
//...
moveDocument(3,5) ;
//...
}
protected:
virtual void newDocument() =0 ;
Document * doc_ ;
private:
void moveDocument( int x, int y )
{
doc_->setPosition(x,y) ;
doc_->redisplay() ;
}
} ;
//...
class WordDocument: public Document
{
public:
void setPosition( int x, int y ) { /***/ }
void redisplay() { /***/ }
//...
}
class Word: public Application
{
protected:
void newDocument() { doc_ = new WordDocument ; }
}
int main()
{
Word appli ;
appli.run() ;
}

public abstract class Editor {
    private Document doc;
    public abstract Document createDocument();
    public void newDocument() {
        doc = createDocument();
        doc.open();
    }
    public void saveDocument() {
        if (doc != null)
        doc.save();
    }
    public void closeDocument() {
        if (doc != null)
        doc.close();
    }
}
public class RTFEditor extends Editor {
    public Document createDocument() {
        return new RTFDocument();
    }
}
public abstract class Document {
    public abstract void open();
    public abstract void save();
    public abstract void close();
}
public class RTFDocument extends Document {
    public void RTFDocument() {
        System.out.println("RTF Document Created");
    }
    public void open() {
        System.out.println("RTF Document Open");
    } 
    public void save() {
        System.out.println("RTF Document Saved");
    }
    public void close() {
        System.out.println("RTF Document Closed");
    }
}
public class Main {
    public static void main(String[] args) {
        Editor editor = new RTFEditor();
        editor.newDocument(); 
        editor.saveDocument();
        editor.closeDocument();
    }
}

Contents Haut

Patterns apparentés au factory method

• Abstract Factory
• Template Methods
• Prototype

U bevindt zich op de Engels versie van de site, maar uw systeem geeft aan dat u liever de Nederlandse taal gebruikt.
De hele site is nog niet vertaald, maar de menu's en knoppen op de interface zijn grotendeels vertaald.

Wilt u de pagina in het Nederlands bereiken?
Klik hier om door te gaan in het Nederlands: Raadpleeg de Nederlandse versie van deze pagina

Sie befinden sich in der Englisch Version der Website, Ihr System gibt jedoch an, dass Sie die deutsche Sprache bevorzugen.
Die gesamte Site ist noch nicht übersetzt, aber die Menüs und Schaltflächen auf der Benutzeroberfläche sind weitgehend übersetzt.

Möchten Sie die Seite auf Deutsch erreichen?
Klicken Sie hier, um fortzufahren: Konsultieren Sie die deutsche Version dieser Seite

Vous vous trouvez sur la version anglaise du site, mais votre système indique que vous préférez utiliser la langue française.

Souhaitez-vous atteindre la page en français?
Cliquez ici pour continuer en français: Consulter la page en français