Présentation professionnelle :
Séparez "l'abstraction" de la "mise en œuvre" afin qu'elles puissent varier indépendamment. Elle est mise en œuvre en remplaçant la relation d'héritage par la relation de composition, réduisant ainsi le degré de couplage des deux dimensions variables d'abstraction et de mise en œuvre.
Introduction populaire :
La définition du motif pont semble claire, mais en fait elle est vague, car le motif pont est l'un des motifs les plus complexes parmi des dizaines de patrons de conception ! Donc, tout d'abord, la pensée ne doit pas être chaotique.
Commencez à expliquer :
L'« abstraction » dans la définition ci-dessus ne fait plus référence au concept abstrait de la classe abstraite précédente, et la « mise en œuvre » n'est plus la mise en œuvre que nous avions comprise auparavant. Le "résumé" ici fait référence à des affaires abstraites. Par exemple, la chose ultime est une berline BMW i8, alors "berline" est une chose abstraite, et "BMW i8" est sa caractéristique, qui peut être utilisée comme implémentation ); pour un autre exemple, si vous voulez un carré blanc, alors le carré est une chose abstraite, et le blanc est sa caractéristique, c'est-à-dire la mise en œuvre.
L'abstraction fait référence à une chose abstraite, et la mise en œuvre fait référence à un comportement ou à des caractéristiques spécifiques, qui sont à deux dimensions, et peuvent avoir de nombreuses variantes, telles que des trains et des camions en plus des voitures, et BMW en plus de BMW i8 X6 ou même Mercedes-Benz S600.
Rôles inclus dans le mode pont :
abstraction : une classe abstraite qui contient des attributs multidimensionnels et appelle directement le rôle réalisé, qui est le rôle du sommet.
Rôle abstrait étendu (RefinedAbstraction) : une classe concrète qui implémente la partie <abstract> de l'interface <abstract role>.
Implementor : une classe abstraite qui définit l'interface du rôle implémenté, qui peut être appelée en étendant le rôle abstrait.
ConcreteImplementor : une classe concrète qui contient une implémentation concrète d'un rôle réalisé.
Scénario d'application :
L'objet (classe) à utiliser est composé de deux ou plusieurs attributs de dimensions différentes, et ces attributs de dimensions différentes peuvent être combinés pour produire des résultats différents, alors le mode pont peut être utile !
code:
Le code suivant résout l'exemple ci-dessus
# 桥接模式
import abc, six
# step-1: 定义<实现化>抽象类
@six.add_metaclass(abc.ABCMeta)
class Implementor:
@abc.abstractmethod
def get_brand(self): pass
# step-2: 定义具体<实现化>类
class ConcreteImplementor(Implementor):
def get_brand(self):
return 'BMW i8'
# step-3: 定义一个顶层的抽象角色，Car
@six.add_metaclass(abc.ABCMeta)
class AbstractCar:
_implementor: Implementor = None
def __init__(self, implementor: Implementor):
self._implementor = implementor
# 抽象角色直接调用<实现化>角色的方法
def get_brand(self):
return self._implementor.get_brand()
@abc.abstractmethod
def get_abstraction_item(self): pass
# step-4: 定义扩展<抽象>类: Refined Abstraction
class RefinedAbstractionHomeCar(AbstractCar):
def __init__(self, implementor: Implementor):
super(RefinedAbstractionHomeCar, self).__init__(implementor)
def get_brand(self):
# <实现化>信息直接调用父类的接口
return super().get_brand()
def get_abstraction_item(self):
"""主要返回<抽象化>事物"""
return 'home car' # 暂代指轿车
# step-4.1: 定义扩展<抽象>类: Refined Abstraction
class RefinedAbstractionTruck(AbstractCar):
def __init__(self, implementor: Implementor):
super().__init__(implementor)
def get_brand(self):
# <实现化>信息直接调用父类的接口
return super().get_brand()
def get_abstraction_item(self):
"""主要返回<抽象化>事物"""
return 'Truck' # 卡车
if __name__ == '__main__':
implementor = ConcreteImplementor()
refinedHomeCar = RefinedAbstractionHomeCar(implementor)
'''
扩展抽象类的意义在于：通过组合不同的<抽象化>属性，如轿车、卡车，和<实现化>属性，如BMW i8等
组合出具有不同属性（方法）的结果类，供使用
'''
print(refinedHomeCar.get_brand())
print(refinedHomeCar.get_abstraction_item())
refinedTruck = RefinedAbstractionTruck(implementor)
print(refinedTruck.get_brand())
print(refinedTruck.get_abstraction_item())
soulève des problèmes :
Pour moi, je ne sais pas comment traduire ce raffinement.Beaucoup de matériaux utilisent des rôles abstraits étendus, mais j'ai l'impression que les mots ne sont pas expressifs, ce qui affectera la compréhension.
L'autre est l'inconvénient de ce mode, qui est le haut degré d'abstraction, qui oblige le concepteur à abstraire fortement le scénario d'application lors de la conception, et à séparer les parties <abstraction> et <implémentation>.L'introduction de ce mode conduira à complexité du système. D'emblée, à utiliser avec prudence ! Il est recommandé de simplifier l'utilisation de ce mode dans des scénarios réels, il suffit de séparer les attributs des différentes dimensions, puis de définir différentes classes, et enfin d'utiliser la méthode de combinaison pour obtenir la classe souhaitée.
enfin
Lors de l'apprentissage de ce modèle, j'ai lu la plupart des matériaux domestiques et m'a essentiellement expliqué comment réaliser des carrés et des cercles de différentes couleurs. . . Ensuite, le mode pont a commencé. Après avoir lu le code, je ne sais pas pourquoi la forme devrait être écrite dans l'abstraction et la forme devrait être utilisée comme implémentation. J'étais vraiment confus. Bien que de nombreux matériaux ne soient pas le même exemple, ils l'ont fait pas expliquer pourquoi. Ce faisant, ce qui est exactement ponté.
Par conséquent, j'ai choisi Wikipédia. Si vous êtes nouveau dans le mode pont et que vous souhaitez connaître des informations officielles de première main, je vous recommande le mode pont de Wikipédia .
Remarques : Pour l'utilisation de base des bibliothèques abc et six, reportez-vous à l'introduction en bas de l'article Simple Factory Pattern & Python Example, : )
Bienvenue à laisser un message ~
Article de référence :
https://zh.wikipedia.org/wiki/%E6%A9%8B%E6%8E%A5%E6%A8%A1%E5%BC%8F