Introduction à la version python du modèle d'usine simple

Cet article présente principalement en détail la version python du modèle d'usine simple, qui a une certaine valeur de référence. Les amis intéressés peuvent se référer à

Qu'est-ce que le modèle d'usine simple

.

Le modèle d'usine a une description très vivante. La classe qui crée l'objet est comme une usine, et les objets qui doivent être créés sont des produits. Les produits sont traités dans l'usine et les personnes qui les utilisent ne le font pas. il faut se soucier du produit. Du point de vue du développement logiciel, cela réduit efficacement le couplage entre les modules.
La fonction d'une usine simple est d'instancier des objets sans exiger que le client sache à quelle sous-classe spécifique l'objet appartient. Les classes instanciées par une fabrique simple ont la même interface ou classe de base. Lorsque la sous-classe est relativement fixe et n'a pas besoin d'être étendue, une fabrique simple peut être utilisée. Par exemple, l'usine de production de base de données est une application d'usine simple
L'avantage de l'utilisation d'usine simple est qu'elle permet aux utilisateurs d'obtenir des instances de classe correspondantes en fonction de paramètres, évitant ainsi l'instanciation directe des classes et réduisant le couplage ; Les types instanciables sont Il a été déterminé lors de la compilation que si un nouveau type était ajouté, la fabrique devait être modifiée, ce qui n'est pas conforme au principe de l'OCP (Open-Closed Principe). Une fabrique simple doit connaître tous les types à générer et ne convient pas lorsqu'il y a trop de sous-classes ou trop de niveaux de sous-classes.

Implémentation simple d'un modèle d'usine

Considérons un exemple du « Modèle de conception Dahua » ci-dessous :
Titre : Utiliser n'importe quel langage orienté objet pour implémenter A programme de console de calculatrice. Il faut saisir deux nombres et symboles d’opération pour obtenir le résultat.

Analyse des questions :

Le programme doit être : (1) maintenable (2) réutilisable (3) extensible (4) flexible ;
Maintenable : cela signifie que si le code est modifié à un endroit, il ne peut pas provoquer de réaction en chaîne et ne peut pas affecter d'autres endroits.
Réutilisable : minimisez le code répétitif.
Extensible : si vous souhaitez étendre de nouvelles fonctions et de nouvelles activités, il vous suffit d'ajouter de nouvelles classes, sans affecter les classes et la logique existantes. Applications plug-in.
Points clés de l'orientation objet :
Les trois caractéristiques majeures de l'orientation objet : l'encapsulation, l'héritage et le polymorphisme.
Réduisez le couplage de programmes grâce à l'encapsulation, l'héritage et le polymorphisme.
La logique métier et la logique d'interface sont séparées.

Diagramme de structure de classe :

Implémentation du code :

1. Déterminez les parties de l’entreprise qui sont sujettes au changement. Dans cette application, il est nécessaire de calculer le résultat de l'opération à partir de deux nombres. Le type d'opération à effectuer est donc une partie susceptible de changer. Par exemple, nous souhaitons uniquement implémenter les opérations d'addition, de soustraction, de multiplication et de division maintenant, et plus tard nous souhaitons ajouter des opérations de racine ou de reste. Alors, comment faire face aux changements induits par cette demande ? Lors de la conception d'un programme, vous devez tenir compte de la maintenabilité, de l'évolutivité, de la réutilisabilité du code, de la flexibilité, etc. du programme.

2. Par exemple, cette unité arithmétique ne comporte que quatre opérations : addition, soustraction, multiplication et division. Tout d'abord, créez une classe d'opération. Cette classe est la classe parent de diverses classes d'opérations spécifiques (addition, soustraction, multiplication et division). Elle accepte principalement les valeurs saisies par les utilisateurs. La classe est la suivante :

class Operation(): 
  def __init__(self,NumberA=0,NumberB=0): 
    self.NumberA = NumberA 
    self.NumberB = NumberB 
 
  def GetResult(self): 
    pass

3 Ensuite, il y a les classes d'opération spécifiques : Add, Sub, Mul, p. Ils héritent tous de la classe Operation et remplacent la méthode getResult(). De cette manière, le polymorphisme peut être utilisé pour réduire le couplage de différentes logiques métier, et les modifications apportées à une classe d'opérations n'affecteront pas les autres classes d'opérations. Le code de la classe spécifique est le suivant :

class AddOp(Operation): 
  def GetResult(self): 
    return self.NumberB + self.NumberA 
 
class MinusOp(Operation): 
  def GetResult(self): 
    return self.NumberA - self.NumberB 
 
class MultiOp(Operation): 
  def GetResult(self): 
    return self.NumberA * self.NumberB 
 
class pideOp(Operation): 
  def GetResult(self): 
    try: 
      return 1.0*self.NumberA / self.NumberB 
    except ZeropisionError: 
      raise

4. Alors, comment puis-je faire savoir à la calculatrice quelle opération je souhaite utiliser ? En d’autres termes, quelle classe d’opérations spécifique doit être instanciée, Ajouter ? Sous? Mul? p? À ce stade, vous devriez envisager d’utiliser une classe distincte pour effectuer le processus de création d’instances spécifiques. Cette classe est la classe d’usine. Comme suit :

class OperationFatory(): 
  def ChooseOperation(self,op): 
    if op == '+': 
      return AddOp() 
    if op == '-': 
      return MinusOp() 
    if op == '*': 
      return MultiOp() 
    if op == '/': 
      return pideOp()

5 De cette façon, l'utilisateur n'a qu'à saisir l'opérateur et la classe d'usine peut créer l'instance appropriée, via. polymorphisme, c'est-à-dire retour à Le résultat de l'opération est réalisé à la manière de la classe parent. Le code client est le suivant :

if __name__ == '__main__': 
  ch = '' 
  while not ch=='q':  
    NumberA = eval(raw_input('Please input number1: ')) 
    op = str(raw_input('Please input the operation: ')) 
    NumberB = eval(raw_input('Please input number2: ')) 
    OPFactory = OperationFatory() 
    OPType = OPFactory.ChooseOperation(op) 
    OPType.NumberA = NumberA 
    OPType.NumberB = NumberB 
    print 'The result is:',OPType.GetResult() 
    print '\n#-- input q to exit any key to continue' 
    try: 
      ch = str(raw_input()) 
    except: 
      ch = ''

Le code de la version complète est le suivant :

# -*-coding:UTF-8-*-  
from abc import ABCMeta,abstractmethod 
 
class Operation(): 
  def __init__(self,NumberA=0,NumberB=0): 
    self.NumberA = NumberA 
    self.NumberB = NumberB 
 
  def GetResult(self): 
    pass 
 
class AddOp(Operation): 
  def GetResult(self): 
    return self.NumberB + self.NumberA 
 
class MinusOp(Operation): 
  def GetResult(self): 
    return self.NumberA - self.NumberB 
 
class MultiOp(Operation): 
  def GetResult(self): 
    return self.NumberA * self.NumberB 
 
class pideOp(Operation): 
  def GetResult(self): 
    try: 
      return 1.0*self.NumberA / self.NumberB 
    except ZeropisionError: 
      raise 
 
class OperationFatory(): 
  def ChooseOperation(self,op): 
    if op == '+': 
      return AddOp() 
    if op == '-': 
      return MinusOp() 
    if op == '*': 
      return MultiOp() 
    if op == '/': 
      return pideOp() 
 
if __name__ == '__main__': 
  ch = '' 
  while not ch=='q':  
    NumberA = eval(raw_input('Please input number1: ')) 
    op = str(raw_input('Please input the operation: ')) 
    NumberB = eval(raw_input('Please input number2: ')) 
    OPFactory = OperationFatory() 
    OPType = OPFactory.ChooseOperation(op) 
    OPType.NumberA = NumberA 
    OPType.NumberB = NumberB 
    print 'The result is:',OPType.GetResult() 
    print '\n#-- input q to exit any key to continue' 
    try: 
      ch = str(raw_input()) 
    except: 
      ch = ''

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!