Implémentation des design patterns en pascal

darrylsite

http://www.darrylsite.com/

- Titre : Implémentation des design patterns en pascal

- Auteur : darrylsite

- Parution : 1 janvier 2011

- Licence : Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright ® 2011 kpizingui darryl. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

Sommaire

- I. Introduction : Bienvenu dans le design pattern

- I-A. Qu'est ce que le Design Pattern?

- I-B. Importance du Design Pattern en Programmation Orientée Objet

- I-C. Le Design Pattern en Pascal

- II. La programmation Objet en Pascal : cas du compilateur Free-Pascal

- II-A. Le Pascal Objet

- II-B. Les classes en Free-Pascal

- II-C. Le systeme d'heritage en Free-Pascal

- II-D. Les interfaces en Free-Pascal

- II-E. Conventions et piège à éviter

- III. Design pattern singleton

- III-A. Implémentation

- III-B. Mauvaise pratique

I - Introduction : Bienvenu dans le design pattern

I-A - Qu'est ce que le Design Pattern?

Les design patterns sont un ensemble de bonnes pratiques visant à produire des logiciels de qualité. Ils définissent les motifs de conceptions à utiliser pour répondre à problèmes récurrents rencontrés dans le développement logiciel. Les design pattern permettent alors au programmeur de se concentrer sur la logique de son application sans avoir à réinventer la roue.

Les designs patterns les plus utilisés sont au nombre de 23. Ces motifs de conception répondent à des problèmes plus ou moins complexes et dans divers situations. Nous étudierons au cours de cet article chaqu'un de ces motifs de conceptions à l'aide d'exemple clair et précis.

I-B - Importance du Design Pattern en Programmation Orientée Objet

La programmation orientée object à pour but premier de segmenter un logiciel en composants réutilisables en analogie avec les composants électroniques. L'utilisation des bonnes partiques définis par ces 23 motifs de conception permettent d'harmoniser l'interaction entre ces composants.

Les 23 motifs de conceptions tels qu'identifiés ont été classés en trois grands groupes :

- Les motifs de création d'object permettent de choisir quel type d'objet faudra t-il créer selon les situations

- Les motifs de structuration d'object permettent de le regroupement d'objet pour former des ensembles plus complexe comme une interface graphique

- les motifs de conceptions permettant de gérer la commucation entre les objects afin de maitriser le flux d'échange de données entre les differents objets composant le systemes

I-C - Le Design Pattern en Pascal

Le langage pascal étendu en Pascal Objet contient tous les caractérisques d'un langage de programmation orientée objet tels les langages Java et C#.
Le Pascal Objet tel que défini en Free Pascal contient la notion de classe comparables à celle existant en JAVA, la notion d'héritage simple et multiple, la notion d'interface qui s'apparatente à des classes abstraites - pour faire la difference avec les interfaces utilisés dans les unités-, des trois types d'encapsulation, ...

En somme, le langage Pascal Objet dispose de tout ce qu'il faut pour l'écrire du code de qualité si les règles définies sont mise en pratique.

II - La programmation Objet en Pascal : cas du compilateur Free-Pascal

II-A - Le Pascal Objet

Le langage pascal était à l'origine limité à la programmation procédurale. Celui-ci à subit par la suite diverses évolutions et plusieurs projets ont tenté d'étendre les possibilité dudit langage pour lui offrir les concepts de la programmation objet.
L'un des premiers fût implémenter dans Turbo Pascal 7 qui a introduit les objets avec une notion non loin des structures -record- existant en Pascal standard mais offrant les notions d'encapsulation -public, private-, d'héritage et de polymorphisque grace à l'utilisation des pointeurs.

Plutard, plusieurs projets sont parvenus à élever le langage Pascal au rang des langages les plus populaires du marché en lui offrant les notions de la Programmation Orientée Objet tel que maintenant définies. Parmi ceux-ci, nous pouvons citer FreePascal et Delphi.
Dans cet article, nous étudierons les motifs de conception avec les notions de programmations orientées tels que défini par Free Pascal.

II-B - Les classes en Free-Pascal

Free Pascal utilise la notion de classe pour introduire la Programmation Orientée Objet. Une classe est une fabrique ou un modèle servant à produire des objects du même type que la classe. La classe définit les propriétès et les comportement que devrons avoir tous les ojects faits à partir de cette fabrique.

Les objets crée à partir d'un modele de classe sont accéssible à partir d'une réference que contient les variables dans le programme.

Une exemple de code portant sur la création d'un objet :

Unit UModele;

interface

type
Modele : class
Begin
private nom : String;
private prenom : String;
public constructor init(_nom : String; _prenom : String);
public procedure say();
End;

Implementation

constructor Modele.init(_nom : String; _prenom : String);
begin
nom := _nom;
prenom := _prenom;
end;

procedure Modele.say();
begin
writeln('mon nom est : '+nom+' et mon prénom est '+prenom);
end;

End.

On peut alors construire une classe comme suit :

var personne : Modele;
Begin
personne := Modele.init('Nabster', 'Darryl');
personne.say();
End.

Comme vous avez pu le constater, une classe se définit en deux partie : d'abord l'entête de la classe contenant les propriétés de cette classe ainsi que la signature des méthodes, ensuite vient la définition des méthodes.
Lors de l'instantiation de l'objet, on appelle le constructor de la classe avec les paramètre adéquats. Vous devez garder à l'esprit que la variable personne ne contient qu'une réference vers l'objet qui a été crée et non l'objet en lui même. Si l'on fait une analogie avec les pointeurs, la variable personne ne contiendrait que l'adresse mémoire de l'objet qui a été précedemment crée.

L'encapsulation est un autre point éssentiel de la programmation qui se définit simplement par la possibilié qu'à une classe de cacher certains de ses membres - propriétés ou méthodes- pour que ceux-ci ne soient pas accessibles que sous certaines conditions.
Aisin, Free Pascal définit trois niveau de visibilité qui sont :

- Private : les élements privés d'une classe ne sont accessible qu'à l'interieur de la classe elle même

- Protected : Comme les éléments privates mais, ceux sont aussi disponibles aux classes héritant de cette classe

- Public : Ces éléments sont directement accessible meme depuis l'exterieur de la classe.

II-C - Le systeme d'heritage en Free-Pascal

II-D - Les interfaces en Free-Pascal

II-E - Conventions et piège à éviter

III - Design pattern singleton

Le motif de conception singleton permet de définir une classe pour qu'il ne puisse avoir qu'une seule instance de cette classe.
Une exemple d'un singleton peut être l'objet Application en Lazarus qui contient les paramètres et les méthodes de systemes d'une application, ou encore une Classe System qui contiendrait les détails de l'environnement de travail Linux par exemple. Vous conviendrez avec moi, qu'il ne doit pas existant plusieurs instance d'objet System puisque l'environnement de travail en unique en soit.

III-A - Implémentation

L'implémentation la plus simple serait d'avoir une méthode static dans la classe qui contient l'instance de l'objet crée

Unit USingleton;

Interface
Type

TSingleton : class
begin
private TSingleton instance; static;

private constructor create();
public class function getInstance() : TSingleton;
end;

Implementation

constructor TSingleton.create();
begin
end;

class function TSingleton.getInstance() : TSingleton;
begin
if(instance == null)
instance := TSingleton.create();

result := instance;
end;

End.

L'attribut instance étant statique, il n'est donc pas lié une instance de classe mais à la classe elle même. Nous pouvons alors, verifier lors de l'appel de la méthode de classe -classe statique- qu'il n'existe qu'une seule instance de la classe TSingleton à chaque fois.
En mettant le constructeur de lasse private, il ne sera donc pas possible de contruire directement un objet de cette classe sans passer par le méthode getInstance().
Nous pouvons alors obtenir l'instance de la classe TSingleton par :

var singleton : TSingleton;
singleton := TSingleton.getInstance();

III-B - Mauvaise pratique

Très souvent en pascal, on peut voir une implémentation du design pattern Singleton de la maniere suivante :

Type
TMauvaseParique : class
begin
{ ... }
end;

var    Application : TMauvaseParique;

implemenation
Begin
Application = TMauvaseParique.create();
End.

Puis par convention, nous pouvons nous dire qu'il ne faudra pas qu'un développeur instantie un autre objet de la classe TMauvaseParique, mais qu'il faut utiliser l'objet referencié par la variable Applcation.
Ce cas résulte avant tout d'une erreur de conception si on tient compte des possibilités que nous offre le langage Pascal.