J'ai pratiqué les modèles de conception afin de pouvoir écrire du code conscient du design. D'autres modèles de conception seront publiés fréquemment.

Préface

Introduction aux modèles de conception appris en langage Java est passé de Java à Python. (Python est 3.4.2)
Le code est sur github (certains d'entre eux ne fonctionnent toujours pas)

L'objectif principal est de comprendre quand, quoi et comment utiliser les modèles de conception. (Je suis nouveau en Java ou dans un langage à typage statique, et je n'ai pas une longue histoire de python, donc je pense qu'il y a des choses qui ne ressemblent pas à Pythonista. Si vous avez des suggestions, apprenez-moi s'il vous plaît.)

Cette fois, le modèle FactoryMethod pour la génération.

Qu'est-ce que la méthode d'usine?

Séparez l'interface de création d'objets et le rôle de création d'objets, remplacez les constructeurs d'autres classes par vos propres méthodes qui peuvent être écrasées par des sous-classes et laissez la création d'objets aux sous-classes pour améliorer la réutilisabilité des classes.

Aperçu

Cet exemple de programme est basé sur une usine qui fabrique des cartes d'identification (cartes d'identité). Il y a quatre classes ici.

Les classes Product et Factory appartiennent à un package appelé Framework. Ces deux classes agissent comme un cadre pour l'instanciation.

La classe ID et la classe IDCardFactory effectuent le fleshing réel. Ceux-ci appartiennent à un package appelé ID Card.

Diagramme de classe global

`Framework/factory.py`


from abc import ABCMeta, abstractmethod


class Factory(metaclass=ABCMeta):

    @abstractmethod
    def _create_product(self, owner):
        pass

    @abstractmethod
    def _register_product(self, product):
        pass

    def create(self, owner):
        self.__p = self._create_product(owner)
        self._register_product(self.__p)
        return self.__p

Le modèle de méthode modèle est utilisé ici. Le modèle de méthode de modèle consiste à "déterminer un vaste cadre de traitement dans la superclasse et déterminer le traitement spécifique dans la sous-classe".

Cette classe définit un vaste cadre de traitement et les sous-classes sont responsables de l'implémentation des méthodes create_product et register_product pour lesquelles un traitement spécifique n'a pas été déterminé.

La méthode create utilise à la fois les méthodes create_product et register_product pour créer une instance du "produit". Le modèle de méthode d'usine utilise le modèle de méthode de modèle pour l'instanciation.

`Framework/product.py`


from abc import ABCMeta, abstractmethod

class Product(metaclass=ABCMeta):

    @abstractmethod
    def use(self):
        pass

Seule la déclaration de l'utilisation de la méthode abstraite.

`IDCard/idcard.py`


from Framework.product import Product


class IDCard(Product):

    def __init__(self, owner):
        self.__owner = owner
        print(self.__owner + 'Créer une carte pour')

    def use(self):
        print(self.__owner + 'Utilisez la carte')

    def get_owner(self):
        return self.__owner

Définissez comme une sous-classe de la classe Product, créez un constructeur et définissez la méthode use et la méthode get_owner.

`IDCard/idcard_factory.py`


from Framework.factory import Factory
from IDCard.idcard import IDCard


class IDCardFactory(Factory):

    def __init__(self):
        self.__registed = []

    def _create_product(self, owner):
        return IDCard(owner)

    def _register_product(self, product):
        self.__registed.append(product.get_owner())

Implémentation des méthodes create_product et register_product. La méthode create_product crée une instance de la classe IDCard. La méthode register_product ajoute le propriétaire IDCard obtenu par la méthode get_owner aux propriétaires de la liste.

`main.py`


from IDCard.idcard_factory import IDCardFactory


def main():
    factory = IDCardFactory()
    card1 = factory.create('Hiroshi Yuki')
    card2 = factory.create('Tomura')
    card3 = factory.create('Hanako Sato')

    card1.use()
    card2.use()
    card3.use()

if __name__ == '__main__':
    main()

Résultat de sortie

Créer une carte pour Hiroshi Yuki
Créer une carte Tomura
Créer une carte pour Hanako Sato
J'utiliserai la carte d'Hiroshi Yuki
J'utiliserai la carte de Tomura
J'utiliserai la carte de Hanako Sato

Résumé

Puisque seule l'interface est spécifiée et que la sous-classe est en charge de la classe à instancier, il était possible d'accéder à la méthode de l'extérieur sans se soucier de l'implémentation interne.

Design Pattern #Factory, méthode