J'ai étudié les modèles de conception (mémo personnel) Partie 6 (modèle de chaîne de responsabilité, modèle de façade, modèle de médiateur)

introduction

Cet article est un mémo d'étude personnel. J'écris un article motivé par l'obsession que ce que j'entre doit être une sortie. J'écris cet article sur Qiita avec l'espoir que quelqu'un qui le connaît pourra signaler les erreurs et donner des conseils.

Je vis une vie professionnelle en tant qu'ingénieur, mais je n'ai pas bien appris les modèles de conception, alors j'ai essayé d'étudier.

Ce qui est décrit ici https://github.com/ck-fm0211/notes_desigh_pattern Je télécharge sur.

Journal passé

J'ai étudié les modèles de conception (mémo personnel) Partie 1 J'ai étudié les modèles de conception (mémo personnel) Partie 2 J'ai étudié les modèles de conception (mémo personnel) Partie 3 J'ai étudié les modèles de conception (mémo personnel) Partie 4 J'ai étudié les modèles de conception (mémo personnel) Partie 5

Modèle de chaîne de responsabilité

――Le modèle de Chaîne de Respoisibilité est un modèle qui vous fait imaginer un état dans lequel ceux qui ont la «responsabilité» sont connectés en forme de «chaîne». --Exemple:

En fait utiliser

Matière

―― Pensez à la décision à l'école

―― La chaîne selon laquelle "la personne responsable décide de ce qu'elle peut juger à sa discrétion et laisse le jugement à la personne suivante en charge si elle ne peut pas juger par elle-même"

# -*- coding:utf-8 -*-
from abc import ABCMeta, abstractmethod


class Responsible(metaclass=ABCMeta):

    def __init__(self, responsible_person: str):
        self._responsible_person = responsible_person
        self._next_level: Responsible = None

    @abstractmethod
    def set_next(self, next_level):
        self._next_level = next_level
        return self._next_level

    @abstractmethod
    def be_able_to_judge(self, question: Question) -> bool:
        pass

    @staticmethod
    @abstractmethod
    def judge(question: Question):
        pass

    @abstractmethod
    def put_question(self, question: Question):
        if self.be_able_to_judge(question):
            self.judge(question)
        elif self._next_level is not None:
            self._next_level.put_question(question)
        else:
            print("Personne ne pouvait juger. Essayez-le.")


class Question:
    """
Une instance String qui stocke le contenu de la question sous forme de champ,
Il a une instance Level qui représente la difficulté de la question.
    """

    def __init__(self, question: str, level: Level):
        self._question = question
        self._level = level


class Level:
    """
Une valeur de type int qui représente le niveau de difficulté sous forme de champ,
Moins que de comparer sa propre difficulté avec la difficulté de l'argument Level object(Level level)Avoir une méthode
    """

    def __init__(self, level: int):
        self._level: int = level

    def less_than(self, level: Level):
        pass


class RookieTeachee(Responsible):

    def __init__(self, responsible_person):
        super().__init__(responsible_person)
        self._level = Level(2)

    def be_able_to_judge(self, question: Question):
        if question._level.less_than(self._level):
            return True

        return False

    @staticmethod
    def judge(question: Question):
        #・ ・ ・

―― En divisant chaque «responsable» en classes, le rôle de chaque responsable peut être limité. «En clarifiant le rôle du responsable et en divisant le responsable en classes, il devient possible de réorganiser avec plus de souplesse la« chaîne »qu'est le flux du jugement. ―― D'un autre côté, il est possible que la vitesse de traitement ralentisse car elle suit la chaîne à chaque fois. ――Il est nécessaire de juger en fonction de la situation si un programme axé sur la vitesse est nécessaire ou si la flexibilité est requise.

Résumé des modèles de chaîne de responsabilité

ChainofResponsibility.png

Motif de façade

--Le modèle de façade est un modèle qui permet d'utiliser simplement la procédure d'utilisation de plusieurs classes existantes en combinaison en créant une classe qui sert de "fenêtre".

En fait utiliser

Matière

«Je suis allé à la bibliothèque pour emprunter un livre, mais je ne sais pas où il se trouve. «J'ai une liste de livres et un livre de prêt, mais je ne sais pas comment les utiliser.

# -*- coding:utf-8 -*-


class BookList:
    """Liste des collections"""

    @staticmethod
    def search_book(book_name):
        location = None
        #Rechercher par nom de livre
        #Renvoie l'emplacement, le cas échéant, nul dans le cas contraire
        return location


class LendingList:
    """Livre de prêt"""

    @staticmethod
    def check(book_name):
        #Consultez le livre de prêt
        #Renvoie vrai si loué, faux sinon
        return True


class Visitor:
    @staticmethod
    def main(args):
        #Où est le livre que vous souhaitez emprunter?
        #Quand et où utilisez-vous quelle méthode?
        pass

--Demander au secrétaire ――C'est la "fenêtre"

class Visitor:
    @staticmethod
    def main(args):
        #Demandez au commis au comptoir pour l'emplacement
        shisho = Librarian()
        location = shisho.search_book("Livre illustré d'insectes")
        if location == "Prêt":
            print("Est-ce en prêt! !!")
        elif location == "Le livre n'est pas en possession":
            print("N'est-ce pas! !! !!")
        else:
            print("Je vous remercie")


class Librarian:
    @staticmethod
    def search_book(book_name):
        #Trouver un livre
        location = BookList.search_book(book_name)
        #Lorsque l'emplacement du livre n'est pas Aucun (en possession)
        if location is not None:
            #Vérifiez s'il est prêté
            if LendingList.check(book_name):
                #Lors de la location
                return "Prêt"
            else:
                #Lorsqu'il n'est pas prêté
                return location
        else:
            #Lorsqu'il n'est pas en possession
            return "Le livre n'est pas en possession"

Résumé du modèle de façade

Facade.png

Motif médiateur

En fait utiliser

Matière

--Application correspondante

# -*- coding:utf-8 -*-


class Concierge:

    def __init__(self):
        self._user_dict = {}

    def add_user(self, user: User):
        self._user_dict[user.get_name()] = user

    @staticmethod
    def consultation(colleagueInLove: User, secretLover: User):
        possibility = 0
        #Dérivation de la possibilité en tenant compte de diverses situations
        return possibility


class User:
    def __init__(self):
        self._name = None

    def get_name(self):
        return self._name


class John(User):

    def __init__(self):
        super().__init__()
        self._name = "John"
        self._secret_lover = None
        self._tension = None
        self._mediator = Concierge()

    def get_name(self):
        return self._name

    def set_secret_lover(self, user: User):
        self._secret_lover = user

    def needs_advice(self):
        self._tension = self._mediator.consultation(self, self._secret_lover)

Résumé des modèles Mediator

Mediator.png

Recommended Posts

J'ai étudié les modèles de conception (mémo personnel) Partie 6 (modèle de chaîne de responsabilité, modèle de façade, modèle de médiateur)
J'ai étudié les modèles de conception (mémo personnel) Partie 3 (modèle de prototype, modèle de constructeur)
J'ai étudié les modèles de conception (mémo personnel) Partie 5 (modèle composite, modèle décorateur, modèle visiteur)
J'ai étudié les modèles de conception (mémo personnel) Partie 4 (modèle AbstractFactory, modèle de pont, modèle de stratégie)
J'ai étudié les modèles de conception (mémo personnel), partie 8 (modèle proxy, modèle de commande, modèle d'interprétation)
J'ai étudié les modèles de conception (mémo personnel) Partie 7 (modèle d'observateur, modèle de souvenir, modèle d'état, modèle de poids mouche)
[Gang of Four] Apprentissage des modèles de conception - Chaîne de responsabilité
Apprenez le modèle de conception «Chaîne de responsabilité» en Python
Modèle de chaîne de responsabilité en Java
[Gang of Four] Apprentissage des modèles de conception - Médiateur
[Gang of Four] Apprentissage des modèles de conception - Façade
Modèle de conception #Facade