« Patrons de conception/Prototype » : différence entre les versions

Contenu supprimé Contenu ajouté
m 32 versions depuis w:Prototype (patron de conception) : pour Patrons de conception/Prototype
+ liens + image + traduction en->fr
Ligne 1 :
{{Patrons de conception}}
{{Voir homonymes|Prototype}}
Le [[patron de conception]] '''prototype''' est utilisé lorsque la création d'une [[instance]] est complexe ou consommatrice en temps. Plutôt que créer plusieurs instances de la classe, on copie la première instance et on modifie la copie de façon appropriée.
 
Le [[../|patron de conception]] '''prototype''' est utilisé lorsque la création d'une [[instance]] est complexe ou consommatrice en temps. Plutôt que créer plusieurs instances de la classe, on copie la première instance et on modifie la copie de façon appropriée.
Pour implanter ce patron il faut déclarer une classe abstraite spécifiant une méthode virtuelle pure appelée ''clone()''. Toute classe nécessitant un [[Constructeur (programmation informatique)|constructeur]] [[Polymorphisme (informatique)|polymorphique]] dérivera de cette classe abstraite et implantera la méthode ''clone()''.
 
Pour implanter ce patron il faut déclarer une classe abstraite spécifiant une méthode abstraite (virtuelle pure en C++) appelée ''clone()''.
Le client de cette classe, au lieu d'écrire du code invoquant directement l'opérateur "new" sur une classe explicitement connue, appellera la méthode ''clone()'' sur le prototype ou passera par un mécanisme fourni par un autre patron de conception (par exemple une méthode de [[Fabrique (patron de conception)|fabrique]] avec un paramètre désignant la classe concrète à instancier).
Toute classe nécessitant un constructeur polymorphique dérivera de cette classe abstraite et implantera la méthode ''clone()''.
 
Le client de cette classe, au lieu d'écrire du code invoquant directement l'opérateur "new" sur une classe explicitement connue, appellera la méthode ''clone()'' sur le prototype ou passera par un mécanisme fourni par un autre patron de conception (par exemple une méthode de [[../Fabrique (patron de conception)|fabrique]] avec un paramètre désignant la classe concrète à instancier).
 
== Structure ==
 
Le [[diagramme UML de classes]] est le suivant :
 
[[Image:UML DP Prototype.png|center|Diagramme UML des classes du patron de conception prototype]]
[[Image:Prototype classdia.png]]
 
La classe ''Prototype'' sert de modèle principal pour la création de nouvelles copies.
Les classes ''ConcretePrototype1PrototypeA'' et ''ConcretePrototype2PrototypeB'' viennent spécialiser la classe ''Prototype'' en venant par exemple modifier certains attributs.
La méthode ''clone()'' doit retourner une copie de l'objet concerné.
Les sous-classes peuvent hériter ou surcharger la méthode ''clone()''.
La classe ''Client''utilisatrice va se charger d'appeler les méthodes de clonage via sa méthode ''operation()''.
 
== Exemple de code en C# ==
 
<source lang="csharp">
public enum RecordType
{
Car,
Person
}
 
/// <summary>
/// Record is the Prototype
/// </summary>
public abstract class Record
{
public abstract Record Clone();
}
 
/// <summary>
/// PersonRecord is the Concrete Prototype
/// </summary>
public class PersonRecord : Record
{
string name;
int age;
 
public override Record Clone()
{
return (Record)this.MemberwiseClone(); // default shallow copy
}
}
 
/// <summary>
/// CarRecord is another Concrete Prototype
/// </summary>
public class CarRecord : Record
{
string carname;
Guid id;
 
public override Record Clone()
{
CarRecord clone = (CarRecord)this.MemberwiseClone(); // default shallow copy
clone.id = Guid.NewGuid(); // always generate new id
return clone;
}
}
 
/// <summary>
/// RecordFactory is the client
/// </summary>
public class RecordFactory
{
private static Dictionary<RecordType, Record> _prototypes = new Dictionary<RecordType, Record>();
 
/// <summary>
/// Constructor
Ligne 73 ⟶ 79 :
public RecordFactory()
{
_prototypes.Add(RecordType.Car, new CarRecord());
_prototypes.Add(RecordType.Person, new PersonRecord());
}
 
/// <summary>
/// The Factory method
Ligne 82 ⟶ 88 :
public Record CreateRecord(RecordType type)
{
return _prototypes[type].Clone();
}
}
</source>
 
Ligne 90 ⟶ 96 :
 
<source lang="java">
/* PrototypeClasse ClassPrototype */
public class Cookie implements Cloneable
{
public class Cookie implements Cloneable
{
public Object clone()
{
try
{
// InDans anune actualimplémentation implementationréelle ofde thisce patternpatron youde wouldconception, nowil attach references tofaudrait
// thecréer expensivela tocopie produceen partsdupliquant fromles theobjets copiescontenus thatet areen heldattribuants inside the prototype.des
// valeurs valides (exemple : un nouvel identificateur unique pour la copie).
 
return this.getClass().newInstance();
}
catch(InstantiationException e)
{
e.printStackTrace();
return null;
}
}
}
 
/* ConcretePrototype Prototypesconcrets toà clonecopier */
public class CoconutCookie extends Cookie { }
 
public class CoconutCookie extends Cookie { }
/* Classe utilisatrice */
public class CookieMachine
/* Client Class */
{
private Cookie cookie; // peut aussi être déclaré comme : private Cloneable cookie;
public class CookieMachine
 
{
public private CookieMachine(Cookie cookie; // could have been a private Cloneable cookie;)
{
public CookieMachine(Cookie this.cookie) = cookie;
{ }
 
this.cookie = cookie;
public Cookie makeCookie()
}
{
public return (Cookie) makeCookiecookie.clone();
{}
 
return (Cookie) cookie.clone();
public Object clone() { }
}
 
public Objectstatic clonevoid main(String args[]) { }
{
Cookie tempCookie = cm.makeCookie() null;
public static void main(String args[])
Cookie prot = new CoconutCookie();
{
CookieMachine Cookiecm tempCookie = new nullCookieMachine(prot);
 
Cookie prot = new CoconutCookie();
for (int i=0; i<100; i++)
CookieMachine cm = new CookieMachine(prot);
tempCookie = cm.makeCookie();
}
for (int i=0; i<100; i++)
}
tempCookie = cm.makeCookie();
}
}
</source>
 
== Exemples ==
 
Exemple où '''prototype''' s'applique : supposons une classe pour interroger une [[base de données]].
À l'instanciation de cette classe on se connecte et on récupère les données de la base avant d'effectuer tous types de manipulation.
Par la suite, il sera plus performant pour les futures instances de cette classe de continuer à manipuler ces données que de réinterroger la base.
Le premier objet de connexion à la base de données aura été créé directement puis initialisé.
Les objets suivants seront une copie de celui-ci et donc ne nécessiteront pas de phase d'initialisation.
 
=== Liens externes ===
Ligne 153 ⟶ 161 :
* {{fr}} [http://jvillage.wordpress.com/2007/09/12/design-pattern-de-creation-%e2%80%9cprototype%e2%80%9d/ Explication du Prototype en Java avec exemple concret] par Java Village
 
[[Catégorie:PatronPatrons de conception (livre)]]
{{Portail informatique}}
 
[[Catégorie:Patron de conception]]
 
[[bg:Прототип (шаблон)]]
[[de:Prototyp (Entwurfsmuster)]]
[[en:Prototype pattern]]
[[es:Prototype (patrón de diseño)]]
[[it:Prototype]]
[[ko:Prototype 패턴]]
[[pl:Prototyp (wzorzec projektowy)]]
[[pt:Prototype]]
[[ru:Прототип (шаблон проектирования)]]
[[uk:Прототип (шаблон проектування)]]
[[zh:原型模式]]