设计模式

时间：2019-09-09 01:26:43 阅读：88 评论：0 收藏：0 [点我收藏+]

设计模式

　　解决不断重复问题的方案，而这个方案之后就可以一次又一次的不断重复的使用

设计模式分类

　　创建型模式：对对象创建会消耗系统的很多的资源，单独对对象的创建进行研究　　　　　　　　

　简单工厂模式（Simple Factory）
　工厂方法模式（Factory Method）
　抽象工厂模式（Abstract Factory）
　创建者模式（Builder）
　原型模式（Prototype）
　单例模式（Singleton）

　　结构型模式：对对象的结构、继承、依赖关系设计，这些会影响到后续程序的维护性、代码的健壮性、耦合性等

外观模式（Facade）
适配器模式（Adapter）
代理模式（Proxy）
装饰模式（Decorator）
桥模式（Bridge）
组合模式（Composite）
享元模式（Flyweight）

　　行为性模式：对对象的行为设计的好的话，对象的行为就会更清晰，它们之间的协作效率就会提高　　

模板方法模式（Template Method）
观察者模式（Observer）
状态模式（State）
策略模式（Strategy）
职责链模式（Chain of Responsibility）
命令模式（Command）
访问者模式（Visitor）
调停者模式（Mediator）
备忘录模式（Memento）
迭代器模式（Iterator）
解释器模式（Interpreter）

原则

　　开闭原则：只能加代码,但是不能修改

　　里氏替换原则：引用父类的地方必须能透明地使用其子类的对象

　　依赖倒置原则：针对接口编程,而不是针对实现编程

　　接口隔离原则：使用多个专门的接口，不使用总的单一接口

　　　　　　　　　多继承存在一个问题：钻石继承问题 A类是B.C类，D类也继承B.C类 A类就不知道从哪里继承来的

　　迪米特原则：简单的说就是降低耦合

　　单一职责：一个类只负责一个职责

接口说明

　　当我们继承，继承父类时候，必须实现某个方法

　　当我们使用from abc import ABCMeta, abstractmethod虚类也是实现某个抽象方法

简单工厂模式

　　使用场景：　　

　　　　当类不知道它所必须创建的对象类的时候

　　　　当一个类希望由它的子类来指定它所创建的对象的时候

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 
 4 from abc import ABCMeta, abstractmethod
 5 
 6 
 7 class Payment(metaclass=ABCMeta):
 8     """抽象产品角色"""
 9 
10     @abstractmethod
11     def pay(self, money):
12         raise NotImplementedError
13 
14 
15 class AliPay(Payment):
16     """具体产品角色"""
17 
18     def pay(self, money):
19         print("支付宝支付%s元" % money)
20 
21 
22 class ApplePay(Payment):
23     """具体产品角色"""
24 
25     def pay(self, money):
26         print("苹果支付%s" % money)
27 
28 
29 class PaymentFactory:
30     """工厂角色"""
31 
32     def create_payment(self, method):
33         if method == "ApplePay":
34             return ApplePay()
35         elif method == "AliPay":
36             return AliPay()
37         else:
38             raise NameError(method)
39 
40 
41 pf = PaymentFactory()
42 p = pf.create_payment("ApplePay")
43 p.pay(100)

总结：使用简单工厂模式时候，首先要定义一个抽象产品类，其次要实现具体的产品类，最后实现工厂类　

　　优点：隐藏了对象创建的实现细节，客服端不需要修改代码

　　缺点：违反了单一职责原则，将创建逻辑几种到工厂类里

　　　　　当添加新产品时候，需要修改工厂代码，违反开闭原则

工厂方法设计模式

　　定义一个工厂接口，然后具体到某一个工厂

　　使用场景：

　　　　需要生产多种大量复杂对象的时候，需要降低耦合度的，系统需要经常扩展的情况下

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 
 4 from abc import ABCMeta, abstractmethod
 5 
 6 
 7 class Payment(metaclass=ABCMeta):
 8     """抽象产品角色"""
 9 
10     @abstractmethod
11     def pay(self, money):
12         raise NotImplementedError
13 
14 
15 class AliPay(Payment):
16     """具体产品角色"""
17 
18     def __init__(self, use_huabei=False):
19         self.use_huabei = use_huabei
20 
21     def pay(self, money):
22         if self.use_huabei:
23             print("花呗支付%s元" % money)
24         else:
25             print("支付宝支付%s元" % money)
26 
27 
28 class ApplePay(Payment):
29     """具体产品角色"""
30 
31     def pay(self, money):
32         print("苹果支付%s" % money)
33 
34 
35 class PaymentFactory(metaclass=ABCMeta):
36     """抽象工厂角色"""
37 
38     @abstractmethod
39     def create_payment(self):
40         pass
41 
42 
43 class AliPayFactory(PaymentFactory):
44     """具体工厂角色"""
45 
46     def create_payment(self):
47         return AliPay()
48 
49 
50 class ApplePayFactory(PaymentFactory):
51     def create_payment(self):
52         return ApplePay()
53 
54 
55 class HuaBeiFactory(PaymentFactory):
56     def create_payment(self):
57         return AliPay(use_huabei=True)
58 
59 
60 af = AliPayFactory()
61 ali = af.create_payment()
62 ali.pay(120)
63 
64 af1 = HuaBeiFactory()
65 ali1 = af1.create_payment()
66 ali1.pay(120)

总结：要使用工厂方法设计模式时候，要实现抽象产品类，具体产品类，抽象工厂类，具体工厂类

　　　　优点：不需要修改工厂类代码，隐藏对象的实现细节

　　　　缺点：每增加一个具体产品，都需要加一个相应的具体工厂类

抽象工厂模式

　　使用场景：

　　　　系统要独立于产品的创建于组合（着重组合）

　　　　强调一系列相关的产品对象的设计以便进行联合使用　　　

  1 #!/usr/bin/env python
  2 # -*- coding:utf-8 -*-
  3 
  4 from abc import abstractmethod, ABCMeta
  5 
  6 
  7 # -------抽象产品---------
  8 class PhoneShell(metaclass=ABCMeta):
  9     @abstractmethod
 10     def show_shell(self):
 11         pass
 12 
 13 
 14 class CPU(metaclass=ABCMeta):
 15     @abstractmethod
 16     def show_cpu(self):
 17         pass
 18 
 19 
 20 class OS(metaclass=ABCMeta):
 21     @abstractmethod
 22     def show_os(self):
 23         pass
 24 
 25 
 26 # ------------------抽象工厂-------------------
 27 class PhoneFactory(metaclass=ABCMeta):
 28     @abstractmethod
 29     def make_shell(self):
 30         pass
 31 
 32     @abstractmethod
 33     def make_cpu(self):
 34         pass
 35 
 36     @abstractmethod
 37     def make_os(self):
 38         pass
 39 
 40 
 41 # ----------------具体产品--------------
 42 class SmallShell(PhoneShell):
 43     def show_shell(self):
 44         print("普通的小手机壳")
 45 
 46 
 47 class BigShell(PhoneShell):
 48     def show_shell(self):
 49         print("普通的大手机壳")
 50 
 51 
 52 class AppleShell(PhoneShell):
 53     def show_shell(self):
 54         print("苹果手机壳")
 55 
 56 
 57 class AppleCPU(CPU):
 58     def show_cpu(self):
 59         print("苹果cpu")
 60 
 61 
 62 class SnapDragonCPU(CPU):
 63     def show_cpu(self):
 64         print("骁龙cpu")
 65 
 66 
 67 class IOS(OS):
 68     def show_os(self):
 69         print("ios系统")
 70 
 71 
 72 class Android(OS):
 73     def show_os(self):
 74         print("安卓系统")
 75 
 76 
 77 # -----------------具体工厂-------------
 78 class MiFactory(PhoneFactory):
 79     def make_cpu(self):
 80         return SnapDragonCPU()
 81 
 82     def make_os(self):
 83         return Android()
 84 
 85     def make_shell(self):
 86         return BigShell()
 87 
 88 
 89 class AppleFactory(PhoneFactory):
 90     def make_cpu(self):
 91         return AppleCPU()
 92 
 93     def make_os(self):
 94         return IOS()
 95 
 96     def make_shell(self):
 97         return AppleShell()
 98 
 99 
100 # ----------------客服端----------------
101 class Phone:
102     def __init__(self, cpu, os, shell):
103         self.cpu = cpu
104         self.os = os
105         self.shell = shell
106 
107     def show_info(self):
108         print("手机信息是：")
109         self.cpu.show_cpu()
110         self.os.show_os()
111         self.shell.show_shell()
112 
113 
114 def make_phone(factory):
115     cpu = factory.make_cpu()
116     os = factory.make_os()
117     shell = factory.make_shell()
118     return Phone(cpu, os, shell)
119 
120 
121 p1 = make_phone(AppleFactory())
122 p1.show_info()
123 
124 """
125 手机信息是：
126 苹果cpu
127 ios系统
128 苹果手机壳
129 """

总结：要使用抽象工厂模式的时候，要实现抽象产品，抽象工厂，具体产品，具体工厂，客服端

　　　　优点：将客服端与类的具体实现相分离

　　　　　　　每个工厂创建了一个完整的产品系列

　　　　　　　有利于产品的一致性（产品之间的约束关系）　

　　　　缺点：难以支持新种类的（抽象）产品　

持续更新中........　　　　

设计模式

原文：https://www.cnblogs.com/Alexephor/p/11414988.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年09月23日 (328)
2021年09月24日 (313)
2021年09月17日 (191)
2021年09月15日 (369)
2021年09月16日 (411)
2021年09月13日 (439)
2021年09月11日 (398)
2021年09月12日 (393)
2021年09月10日 (160)
2021年09月08日 (222)