La méthode Builder est une Modèle de brouillon de création L’objectif est de «séparer la construction d’un objet complexe de sa représentation afin que le même processus de construction puisse produire des représentations différentes». Vous pouvez l’utiliser pour créer des objets complexes étape par étape. Ici, nous pouvons facilement créer différents types et représentations de l’objet en utilisant le même code de construction.

Il a été essentiellement développé pour rendre flexibles les solutions à divers problèmes de création d’objets dans la programmation orientée objet.

Diagramme UML du modèle de conception du générateur

Modèle de conception Python, méthode du générateur

Méthode du constructeur

Problème sans utiliser la méthode du constructeur:

Imaginez que vous vouliez rejoindre l’un des groupes d’élite de GeeksforGeeks. Vous vous y rendrez donc et vous poserez des questions sur la structure des frais, les temps disponibles et les lots pour le cours que vous souhaitez suivre. Après avoir examiné le système, vous serez informé des cours, de leur structure tarifaire, des horaires disponibles et des lots. C’est ça! (Non! Nous n’avons pas encore fini car nous sommes de bons développeurs).

Notre objectif principal est de rendre le système flexible, fiable, organisé et lubrifiant. Les développeurs inexpérimentés créent une classe distincte et unique pour chaque cours GeeksforGeeks. Ensuite, ils créent une instanciation d’objet distincte pour chaque classe, bien que cela ne soit pas nécessaire à chaque fois. Le principal problème survient lorsque GeeksforGeeks commence de nouveaux cours et que les développeurs doivent également ajouter de nouvelles classes car leur code n’est pas très flexible.

Méthode du générateur de problèmes

Méthode du générateur de problèmes

Noter: Le code suivant est écrit sans utiliser la méthode du générateur.

class DSA():

 

    

 

    def Fee(self):

        self.fee = 8000

 

    def available_batches(self):

        self.batches = 5

 

    def __str__(self):

        return "DSA"

 

class SDE():

 

    

 

    def Fee(self):

        self.fee = 10000

 

    def available_batches(self):

        self.batches = 4

 

    def __str__(self):

        return "SDE"

 

class STL():

 

    

 

    def Fee(self):

        self.fee = 5000

 

    def available_batches(self):

        self.batches = 7

 

    def __str__(self):

        return "STL"

 

 

if __name__ == "__main__":

 

    sde = SDE()  

    dsa = DSA()  

    stl = STL()  

 

    print(f'Name of Course: {sde} and its Fee: {sde.fee}')

    print(f'Name of Course: {stl} and its Fee: {stl.fee}')

    print(f'Name of Course: {dsa} and its Fee: {dsa.fee}')

Solution par méthode constructeur:

Notre produit final devrait être un cours de GeeksforGeeks. Cela peut être SDE, STL ou DSA. Nous devons passer par de nombreuses étapes avant de choisir un cours particulier, par ex. B. Détails des cours, programme d’études, barème des frais, horaires et lots. Ici, nous pouvons utiliser la même procédure pour sélectionner différents cours disponibles sur GeeksforGeeks. C’est l’avantage d’utiliser Modèle de constructeur.

Solution Builder, méthode

Solution Builder, méthode

class Course:

 

    def __init__(self):

        self.Fee()

        self.available_batches()

 

    def Fee(self):

        raise NotImplementedError

 

    def available_batches(self):

        raise NotImplementedError

 

    def __repr__(self):

        return 'Fee : {0.fee} | Batches Available : {0.batches}'.format(self)

 

class DSA(Course):

 

    

 

    def Fee(self):

        self.fee = 8000

 

    def available_batches(self):

        self.batches = 5

 

    def __str__(self):

        return "DSA"

 

class SDE(Course):

 

    

 

    def Fee(self):

        self.fee = 10000

 

    def available_batches(self):

        self.batches = 4

 

    def __str__(self):

        return "SDE"

 

class STL(Course):

 

    

 

    def Fee(self):

        self.fee = 5000

 

    def available_batches(self):

        self.batches = 7

 

    def __str__(self):

        return "STL"

 

class ComplexCourse:

 

    def __repr__(self):

        return 'Fee : {0.fee} | available_batches: {0.batches}'.format(self)

 

class Complexcourse(ComplexCourse):

 

    def Fee(self):

        self.fee = 7000

 

    def available_batches(self):

        self.batches = 6

 

def construct_course(cls):

 

    course = cls()

    course.Fee()

    course.available_batches()

 

    return course   

 

if __name__ == "__main__":

 

    dsa = DSA() 

    sde = SDE() 

    stl = STL() 

 

    complex_course = construct_course(Complexcourse)

    print(complex_course)

Diagramme de classe général pour la méthode du maître du générateur:

Diagramme de classe général pour la méthode du générateur

Diagramme de classe général pour la méthode du générateur

Avantages de l’utilisation de la méthode Builder:

  1. Réutilisabilité: Lors de la création des différentes représentations des produits, nous pouvons utiliser le même code de conception pour d’autres représentations.
  2. Principe de responsabilité individuelle: Nous pouvons séparer à la fois la logique métier et le code de construction complexe.
  3. Construction de l’objet: Ici, nous construisons notre objet étape par étape, déplaçons les étapes de construction ou exécutons les étapes de manière récursive.

Inconvénients de l’utilisation de la méthode Builder:

  1. La complexité du code augmente: La complexité de notre code augmente à mesure que le modèle de générateur nécessite la création de plusieurs nouvelles classes.
  2. Polyvalence: La classe de constructeur doit être modifiable
  3. Initialisation: Il n’y a aucune garantie que les données membres de la classe seront initialisées.

Applicabilité:

  1. Construisez des objets complexes: La méthode du constructeur vous permet de créer les produits étape par étape. On peut même reporter certaines étapes sans endommager le produit final. Pour créer une arborescence d’objets, il est pratique d’appeler les étapes de manière récursive. Cela empêche le code client d’obtenir les données incomplètes car un objet inachevé ne peut pas être rendu disponible.
  2. Différent selon les représentations: Le modèle de générateur est applicable lorsque la création de différentes représentations du produit implique des étapes similaires qui ne diffèrent que par les détails. L’interface du constructeur de base est utilisée pour définir toutes les étapes de construction au fur et à mesure que ces étapes sont mises en œuvre par les constructeurs de béton.

Continuer la lecture: Méthode de conception Builder en C ++

Attention geek! Renforcez vos fondations avec ça Fondation de programmation Python Cours et apprenez les bases.

Préparez d’abord vos entretiens. Développez vos concepts de structure de données avec le Python DS Cours. Et pour commencer votre parcours d’apprentissage automatique, rejoignez le Apprentissage automatique – Cours de base



Source link

Recent Posts