Prototype (motif de conception)
Un article de Wikipédia, l'encyclopédie libre.
Le motif 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 motif, il faut déclarer une classe abstraite spécifiant une méthode virtuelle pure appelée clone(). Toutes classes nécessitant un constructeur polymorphique dérivera de cette classe abstraite et implentera 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, appelera la méthode clone() sur le prototype ou passera par un mécanisme fourni par un autre motif de conception (par exemple une méthode de fabrique avec un paramètre désignant la classe concrète à instancier).
Sommaire |
[modifier] Structure
Le diagramme de classes est le suivant :
[modifier] Exemple de code en C#
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
/// </summary>
public RecordFactory()
{
_prototypes.Add(RecordType.Car, new CarRecord());
_prototypes.Add(RecordType.Person, new PersonRecord());
}
/// <summary>
/// The Factory method
/// </summary>
public Record CreateRecord(RecordType type)
{
return _prototypes[type].Clone();
}
}
[modifier] Exemple de code en JAVA
/* Prototype Class */
public class Cookie implements Cloneable {
public Object clone()
{
try{
//In an actual implementation of this pattern you would now attach references to
//the expensive to produce parts from the copies that are held inside the prototype.
return this.getClass().newInstance();
}
catch(InstantiationException e)
{
e.printStackTrace();
return null;
}
}
}
/* Concrete Prototypes to clone */
public class CoconutCookie extends Cookie { }
/* Client Class*/
public class CookieMachine {
private Cookie cookie;//could have been a private Cloneable cookie;
public CookieMachine(Cookie cookie) {
this.cookie = cookie;
}
public Cookie makeCookie() {
return (Cookie)cookie.clone();
}
public Object clone() { }
public static void main(String args[]){
Cookie tempCookie = null;
Cookie prot = new CoconutCookie();
CookieMachine cm = new CookieMachine(prot);
for(int i=0; i<100; i++)
tempCookie = cm.makeCookie();
}
}
[modifier] 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.
 |
Portail de l'informatique – Accédez aux articles de Wikipédia concernant l’informatique. |
