{"id":251,"date":"2021-08-25T20:52:41","date_gmt":"2021-08-25T20:52:41","guid":{"rendered":"https:\/\/www.louismarchand.me\/?page_id=251"},"modified":"2024-09-06T15:12:27","modified_gmt":"2024-09-06T15:12:27","slug":"objet2-patrons-conceptuels","status":"publish","type":"page","link":"https:\/\/www.louismarchand.me\/index.php\/objet2-patrons-conceptuels\/","title":{"rendered":"Patrons conceptuels"},"content":{"rendered":"

Introduction<\/h2>\n

On appelle patrons conceptuels<\/strong> (ou \u00ab\u00a0Design pattern<\/strong> \u00ab\u00a0) un arrangement \u00e9prouv\u00e9 de classes afin de r\u00e9pondre \u00e0 un probl\u00e8me classique. Un patron de conception est consid\u00e9r\u00e9 comme un ensemble de bonnes pratiques dans le domaine du d\u00e9veloppement logiciel.<\/p>\n

Les patrons de cr\u00e9ation<\/h2>\n

Singleton<\/h3>\n

Un singleton<\/strong> est une instance unique d’une classe dans un programme.<\/p>\n

On utilise un singleton dans le cas o\u00f9 il est souhaitable ou obligatoire qu’une classe n’ait qu’une seule instance dans l’ex\u00e9cution du programme.<\/p>\n

Afin de garder le contr\u00f4le sur l’utilisation de ce singleton (et ainsi \u00e9viter les probl\u00e8mes de variables globales), le singleton doit avoir un point d’acc\u00e8s unique, tra\u00e7able et document\u00e9.<\/p>\n

Java:<\/p>\n

\n
import<\/span> java.util.List<\/span>;<\/span>\r\nimport<\/span> java.util.ArrayList<\/span>;<\/span>\r\n\r\npublic<\/span> class<\/span> MonSingleton<\/span> {<\/span>\r\n\r\n    static<\/span> private<\/span> MonSingleton<\/span> instance<\/span>;<\/span>\r\n\r\n    static<\/span> public<\/span> MonSingleton<\/span> getInstance<\/span>()<\/span> {<\/span>\r\n        if<\/span> (<\/span>instance<\/span> ==<\/span> null<\/span>)<\/span> {<\/span>\r\n            instance<\/span> =<\/span> new<\/span> MonSingleton<\/span>();<\/span>\r\n        }<\/span>\r\n        return<\/span> instance<\/span>;<\/span>\r\n    }<\/span>\r\n\r\n    private<\/span> MonSingleton<\/span>(){<\/span>\r\n        attribut1<\/span> =<\/span> 0<\/span>;<\/span>\r\n        attribut2<\/span> =<\/span> new<\/span> ArrayList<\/span><<\/span>String<\/span>><\/span>();<\/span>\r\n    }<\/span>\r\n\r\n    protected<\/span> int<\/span> attribut1<\/span>;<\/span>\r\n\r\n    protected<\/span> ArrayList<\/span><<\/span>String<\/span>><\/span> attribut2<\/span>;<\/span>\r\n\r\n    public<\/span> void<\/span> setAttribut1<\/span>(<\/span>int<\/span> aAttribut1<\/span>)<\/span> {<\/span>\r\n        attribut1<\/span> =<\/span> aAttribut1<\/span>;<\/span>\r\n    }<\/span>\r\n\r\n    public<\/span> int<\/span> getAttribut1<\/span>()<\/span> {<\/span>\r\n        return<\/span> attribut1<\/span>;<\/span>\r\n    }<\/span>\r\n\r\n    public<\/span> void<\/span> setAttribut2<\/span>(<\/span>List<\/span><<\/span>String<\/span>><\/span> aAttribut2<\/span>)<\/span> {<\/span>\r\n        attribut2<\/span> =<\/span> new<\/span> ArrayList<\/span><<\/span>String<\/span>><\/span> (<\/span>aAttribut2<\/span>);<\/span>\r\n    }<\/span>\r\n\r\n    public<\/span> List<\/span><<\/span>String<\/span>><\/span> getAttribut2<\/span>()<\/span> {<\/span>\r\n        return<\/span> new<\/span> ArrayList<\/span><<\/span>String<\/span>><\/span> (<\/span>attribut2<\/span>);<\/span>\r\n    }<\/span>\r\n\r\n}<\/span>\r\n<\/pre>\n<\/div>\n
Les trois (3) \u00e9l\u00e9ments importants de cet exemple sont les trois (3) premiers attributs et m\u00e9thodes de la classe.<\/p>\n
En premier lieu, l’attribut priv\u00e9 statique \u00ab\u00a0instance\u00a0\u00bb permet de placer l’instance unique de la classe \u00ab\u00a0MonSingleton\u00a0\u00bb dans un attribut statique. Un attribut statique repr\u00e9sente la m\u00eame valeur, peu importe d’o\u00f9 elle est acc\u00e9d\u00e9. \u00c7a permet \u00e9galement d’utiliser l’attribut \u00e0 partir d’une m\u00e9thode statique.<\/p>\n
La m\u00e9thode publique statique \u00ab\u00a0getInstance\u00a0\u00bb permet aux autres classes du syst\u00e8me d’acc\u00e9der \u00e0 l’instance du singleton sans n\u00e9cessairement permettre l’acc\u00e8s global de l’attribut \u00ab\u00a0instance\u00a0\u00bb (afin d’\u00e9viter qu’une autre classe y assigne une valeur). On peut \u00e9galement voir que la m\u00e9thode \u00ab\u00a0getInstance\u00a0\u00bb regarde si l’instance existe avant de le retourner et si l’instance n’existe pas, il le cr\u00e9e. On appelle cette technique le \u00ab\u00a0Lazy Loading\u00a0\u00bb. Il est \u00e9galement important de noter qu’il n’est pas n\u00e9cessaire d’avoir une instance de classe pour lancer une m\u00e9thode statique. Il est possible de faire un appel de m\u00e9thode, appliqu\u00e9 directement sur la classe.<\/p>\n
Finalement, on voit que le constructeur de la classe \u00ab\u00a0MonSingleton\u00a0\u00bb est d\u00e9clar\u00e9 comme priv\u00e9. Cette fonctionnalit\u00e9 permet de nous assurer que le constructeur ne sera pas lanc\u00e9 \u00e0 partir d’une autre classe que la classe en cours (dans ce cas, \u00ab\u00a0MonSingleton\u00a0\u00bb).<\/p>\n
On utilise le singleton de la mani\u00e8re suivante:<\/p>\n
\n
public<\/span> class<\/span> Programme<\/span> {<\/span>\r\n\r\n    static<\/span> public<\/span> void<\/span> main<\/span>(<\/span>String<\/span>[]<\/span> args<\/span>)<\/span> {<\/span>\r\n        MonSingleton<\/span> monSingleton<\/span> =<\/span> MonSingleton<\/span>.<\/span>getInstance<\/span>();<\/span>\r\n        monSingleton<\/span>.<\/span>setAttribut1<\/span>(<\/span>10<\/span>);<\/span>\r\n    }<\/span>\r\n\r\n}<\/span>\r\n<\/pre>\n<\/div>\n
Eiffel:<\/p>\n
\n
class<\/span>\r\n\tMON_SINGLETON<\/span>\r\n\r\ncreate<\/span> {<\/span>MON_SINGLETON_SHARED<\/span>}<\/span>\r\n\tmake<\/span>\r\n\r\nfeature<\/span> {<\/span>NONE<\/span>}<\/span> -- Initialisation<\/span>\r\n\r\n\tmake<\/span>\r\n\t\tdo<\/span>\r\n\t\t\tattribut1<\/span> :=<\/span> 0<\/span>\r\n\t\t\tcreate<\/span> {<\/span>ARRAYED_LIST<\/span>[<\/span>STRING<\/span>]<\/span>}<\/span> internal_attribut2<\/span>.<\/span>make<\/span> (<\/span>0<\/span>)<\/span>\r\n\t\tend<\/span>\r\n\r\nfeature<\/span> -- Access<\/span>\r\n\r\n\tattribut1<\/span>:<\/span>INTEGER<\/span> assign<\/span> set_attribut1<\/span>\r\n\r\n\tset_attribut1<\/span>(<\/span>a_attribut1<\/span>:<\/span>INTEGER<\/span>)<\/span>\r\n\t\tdo<\/span>\r\n\t\t\tattribut1<\/span> :=<\/span> a_attribut1<\/span>\r\n\t\tend<\/span>\r\n\r\n\tattribut2<\/span>:<\/span>LIST<\/span>[<\/span>STRING<\/span>]<\/span> assign<\/span> set_attribut2<\/span>\r\n\t\tdo<\/span>\r\n\t\t\tResult<\/span> :=<\/span> internal_attribut2<\/span>.<\/span>twin<\/span>\r\n\t\tend<\/span>\r\n\r\n\tset_attribut2<\/span>(<\/span>a_attribut2<\/span>:<\/span>LIST<\/span>[<\/span>STRING<\/span>]<\/span>)<\/span>\r\n\t\tdo<\/span>\r\n\t\t\tcreate<\/span> {<\/span>ARRAYED_LIST<\/span>[<\/span>STRING<\/span>]<\/span>}<\/span>\r\n\t\t\t\tinternal_attribut2<\/span>.<\/span>make_from_iterable<\/span> (<\/span>a_attribut2<\/span>)<\/span>\r\n\t\tend<\/span>\r\n\r\nfeature<\/span> {<\/span>NONE<\/span>}<\/span> -- Impl\u00e9mentation<\/span>\r\n\r\n\tinternal_attribut2<\/span>:<\/span>LIST<\/span>[<\/span>STRING<\/span>]<\/span>\r\n\r\nend<\/span>\r\n<\/pre>\n<\/div>\n
La classe \u00ab\u00a0MON_SINGLETON\u00a0\u00bb est une classe compl\u00e8tement standard. La seule et unique particularit\u00e9 \u00e0 observer est l’utilisation d’un constructeur ami avec la classe \u00ab\u00a0MON_SINGLETON_SHARED\u00a0\u00bb:<\/p>\n
create {MON_SINGLETON_SHARED}\r\n\tmake<\/pre>\n
La classe permettant le point d’acc\u00e8s au singleton est la classe \u00ab\u00a0MON_SINGLETON_SHARED\u00a0\u00bb qui est faite de cette mani\u00e8re:<\/p>\n
\n
deferred<\/span> class<\/span>\r\n\tMON_SINGLETON_SHARED<\/span>\r\n\r\nfeature<\/span> {<\/span>NONE<\/span>}<\/span> -- Implementation<\/span>\r\n\r\n\tmon_singleton<\/span>:<\/span>MON_SINGLETON<\/span>\r\n\t\tonce<\/span>\r\n\t\t\tcreate<\/span> Result<\/span>.<\/span>make<\/span>\r\n\t\tend<\/span>\r\n\r\nend<\/span>\r\n<\/pre>\n<\/div>\n
La particularit\u00e9 ici, est le mot cl\u00e9 \u00ab\u00a0once\u00a0\u00bb qui agit d’une mani\u00e8re similaire au \u00ab\u00a0static\u00a0\u00bb de java (pour les m\u00e9thodes seulement, pas les attributs). Ce qu’une m\u00e9thode \u00ab\u00a0once\u00a0\u00bb fait, c’est qu’elle ex\u00e9cute la m\u00e9thode une seule fois dans le programme et si cette m\u00e9thode retourne une valeur, donc la valeur retourn\u00e9e sera toujours la m\u00eame.<\/p>\n
Finalement, pour acc\u00e9der au singleton, il ne reste qu’\u00e0 h\u00e9riter de la classe \u00ab\u00a0MON_SINGLETON_SHARED\u00a0\u00bb et d’utiliser la m\u00e9thode \u00ab\u00a0mon_singleton\u00a0\u00bb. Par exemple:<\/p>\n
\n
class<\/span>\r\n\tAPPLICATION<\/span>\r\n\r\ninherit<\/span>\r\n\tMON_SINGLETON_SHARED<\/span>\r\n\r\ncreate<\/span>\r\n\tmake<\/span>\r\n\r\nfeature<\/span> {<\/span>NONE<\/span>}<\/span> -- Initialisation<\/span>\r\n\r\n\tmake<\/span>\r\n\t\t\t-- Ex\u00e9cute l'application.<\/span>\r\n\t\tdo<\/span>\r\n\t\t\tmon_singleton<\/span>.<\/span>set_attribut1<\/span> (<\/span>10<\/span>)<\/span>\r\n\t\tend<\/span>\r\n\r\nend<\/span>\r\n<\/pre>\n<\/div>\n
\u00c0 noter \u00e0 propos des singletons<\/h4>\n