设计模式--学习中---持续更新。。。。

设计模式四要素：

　　　模式名称、问题、解决方案、效果

设计模式六大原则：

　　1、开闭原则：一个软件实体如类、模块和函数应该对扩展开放，对修改关闭，即软件实体应尽量在不修改原来代码的情况下进行扩展

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

   3、依赖倒置原则：高层模块不应该依赖低层模块，二者都应该依赖其抽象，抽象不应该依赖细节，细节应该依赖抽象，换言之要针对接口编程，而不是针对实现编程

   4、接口隔离原则： 使用多个专门的接口，而不是使用单一个总接口，即客户端不应该依赖那些它不需要的接口

   5、迪米特原则： 一个软件实体应当尽可能少地与其他实体发生相互作用

   6、单一原则：不要存在多于一个导致类变更的原因，通俗的说，即一个类只负责一项职能

设计械分类：

　　创建型： 工厂方法模式   抽象工厂模式  创建者模式   原型模式  单例模式

   结构型：  适配器模式  桥模式  组合模式 装饰模式 外观模式  享元模式 代理模式

   行为型：  解释器模式  责任链模式 命令模式  迭代器模式 中介者模式工 备忘录模式  观察者模式（发布、订阅）  状态模式  策略模式 访问者模式  模板方法模式  

 

 

 

 

 1 from abc import ABCMeta, abstractmethod
 2 
 3 class Payment(metaclass=ABCMeta):#继承抽象类约束
 4     @abstractmethod
 5     def pay(self,money):
 6         pass
 7 
 8 
 9 class Alipay(Payment):
10     def __init__(self,yeb=False):
11         self.yeb=yeb
12     def pay(self,money):
13         if self.yeb:
14             print('余额宝支付%s元'%money)
15         else:
16             print('支付宝支付%s元'%money)
17 
18 class ApplePay(Payment):
19     def pay(self,money):
20         print('苹果支付%s元'%money)
21 class WeChatpay(Payment):
22     def payx(self,money):
23         print('微信支付%s元'%money)
24 
25 
26 class PaymentFactory:
27     def create_payment(self,method):
28         if method =='alipay':
29             return Alipay()
30         elif method =='yeb':
31             return Alipay(True)#多参数
32         elif method =='applepay':
33             return ApplePay()
34         else:
35             raise NameError(method)
36 
37 f = PaymentFactory()#创建对象实例
38 p=f.create_payment('alipay')#传参就可以实现不同的功能
39 s=f.create_payment('applepay')#传参就可以实现不同的功能
40 ss=f.create_payment('yeb')#传参就可以实现不同的功能
41 p.pay(100)
42 s.pay(200)
43 ss.pay(300)

简单工厂模式

 

 

 

单例模式-----

 1 class Singleton(object):
 2     def __new__(cls, *args, **kwargs):
 3         if not hasattr(cls,"_instance"):#如果没有实例时,
 4             cls._instance=super(Singleton,cls).__new__(cls)#实例化一个对象
 5         return cls._instance  #返回已有的实例
 6 
 7 class MyClass(Singleton):
 8     def __init__(self,name=None):
 9         if name:
10             self.name=name
11 
12 a =MyClass('a')
13 b =MyClass()
14 print(b.name)

 

 

  1 from abc import ABCMeta, abstractmethod
  2 
  3 #---------------------抽象产品类---------------
  4 
  5 class CPU(metaclass=ABCMeta):#CPU
  6     @abstractmethod
  7     def show_cpu(self):
  8         pass
  9 
 10 class Memory(metaclass=ABCMeta):#内存
 11     @abstractmethod
 12     def show_memory(self):
 13         pass
 14 
 15 class Board(metaclass=ABCMeta):#主板
 16     @abstractmethod
 17     def show_board(self):
 18         pass
 19 
 20 class Disk(metaclass=ABCMeta):#硬盘
 21     @abstractmethod
 22     def show_disk(self):
 23         pass
 24 
 25 #---------------------具体产品类---------------
 26 class Cpu_i3(CPU):
 27     def show_cpu(self):
 28         print('i3-cpu')
 29 
 30 class Cpu_i5(CPU):
 31     def show_cpu(self):
 32         print('i5-cpu')
 33 
 34 class Cpu_Amd(CPU):
 35     def show_cpu(self):
 36         print('Amd-cpu')
 37 
 38 class Memory_san(Memory):
 39     def show_memory(self):
 40         print('san-memory')
 41 
 42 class Memory_hd(Memory):
 43     def show_memory(self):
 44         print('hd-memory')
 45 
 46 class Disk_kid(Disk):
 47     def show_disk(self):
 48         print('kid-disk')
 49 class Disk_to(Disk):
 50     def show_disk(self):
 51         print('to-disk')
 52 
 53 class Board_h(Board):
 54     def show_board(self):
 55         print('h-board')
 56 class Board_b(Board):
 57     def show_board(self):
 58         print('b-board')
 59 
 60 #---------------------抽象工厂类---------------
 61 class Compt(metaclass=ABCMeta):#主机
 62     @abstractmethod
 63     def make_cpu(self):
 64         pass
 65     @abstractmethod
 66     def make_memory(self):
 67         pass
 68     @abstractmethod
 69     def make_board(self):
 70         pass
 71     @abstractmethod
 72     def make_disk(self):
 73         pass
 74 
 75 #---------------------具体工厂类---------------
 76 
 77 class Compt_i3(Compt):
 78     def make_cpu(self):
 79         return Cpu_i3()
 80 
 81     def make_board(self):
 82         return Board_b()
 83 
 84     def make_memory(self):
 85         return Memory_hd()
 86 
 87     def make_disk(self):
 88         return Disk_kid()
 89 
 90 class Compt_i5(Compt):
 91     def make_cpu(self):
 92         return Cpu_i5()
 93 
 94     def make_board(self):
 95         return Board_h
 96 
 97     def make_memory(self):
 98         return Memory_hd()
 99 
100     def make_disk(self):
101         return Disk_kid()
102 
103 #------客户端---手机配置类-----
104 
105 class Computer:
106     def __init__(self,cpu,memory,board,disk):##组合模式
107         self.cpu=cpu
108         self.memory=memory
109         self.board=board
110         self.disk=disk
111     def show_info(self):
112         print('主机配置:')
113         self.cpu.show_cpu()
114         self.board.show_board()
115         self.memory.show_memory()
116         self.disk.show_disk()
117 #-----------生产手机函数------------
118 def make_Computer(factory):
119     cpu=factory.make_cpu()
120     memory=factory.make_memory()
121     board=factory.make_board()
122     disk=factory.make_disk()
123     return Computer(cpu,memory,board,disk)
124 a=make_Computer(Compt_i3())
125 a.show_info()

抽象工厂模式

 

 

 1 from abc import ABCMeta, abstractmethod
 2 
 3 class Payment(metaclass=ABCMeta):#继承抽象类约束 接口
 4     @abstractmethod
 5     def pay(self,money):
 6         pass
 7 
 8 class Alipay(Payment): #产品类
 9     def __init__(self,yeb=False):
10         self.yeb=yeb
11     def pay(self,money):
12         if self.yeb:
13             print('余额宝支付%s元'%money)
14         else:
15             print('支付宝支付%s元'%money)
16 
17 class ApplePay(Payment):
18     def pay(self,money):
19         print('苹果支付%s元'%money)
20 class WeChatpay(Payment):
21     def pay(self,money):
22         print('微信支付%s元'%money)
23 
24 
25 class PaymentFactory(metaclass=ABCMeta):#抽象工厂  接口
26     @abstractmethod
27     def create_payment(self):
28         pass
29 
30 class AlipayFactory(PaymentFactory):#具体产品工厂
31     def create_payment(self):
32         return Alipay()
33 class AlipayyebFactory(PaymentFactory):#具体产品工厂
34     def create_payment(self):
35         return Alipay(True)
36 
37 AA=AlipayFactory()
38 AB=AlipayyebFactory()
39 a=AA.create_payment()
40 b=AB.create_payment()
41 a.pay(100)
42 b.pay(300)

工厂方法模式

 

转载于:https://www.cnblogs.com/uge3/p/8581317.html