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

设计模式四要素：

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

设计模式六大原则：

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

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

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

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

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

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

设计械分类：

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

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

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

from abc import ABCMeta, abstractmethod

class Payment(metaclass=ABCMeta):#继承抽象类约束
    @abstractmethod
    def pay(self,money):
        pass


class Alipay(Payment):
    def __init__(self,yeb=False):
        self.yeb=yeb
    def pay(self,money):
        if self.yeb:
            print('余额宝支付%s元'%money)
        else:
            print('支付宝支付%s元'%money)

class ApplePay(Payment):
    def pay(self,money):
        print('苹果支付%s元'%money)
class WeChatpay(Payment):
    def payx(self,money):
        print('微信支付%s元'%money)


class PaymentFactory:
    def create_payment(self,method):
        if method =='alipay':
            return Alipay()
        elif method =='yeb':
            return Alipay(True)#多参数
        elif method =='applepay':
            return ApplePay()
        else:
            raise NameError(method)

f = PaymentFactory()#创建对象实例
p=f.create_payment('alipay')#传参就可以实现不同的功能
s=f.create_payment('applepay')#传参就可以实现不同的功能
ss=f.create_payment('yeb')#传参就可以实现不同的功能
p.pay(100)
s.pay(200)
ss.pay(300)

单例模式-----

class Singleton(object):
    def __new__(cls, *args, **kwargs):
        if not hasattr(cls,"_instance"):#如果没有实例时,
            cls._instance=super(Singleton,cls).__new__(cls)#实例化一个对象
        return cls._instance  #返回已有的实例

class MyClass(Singleton):
    def __init__(self,name=None):
        if name:
            self.name=name

a =MyClass('a')
b =MyClass()
print(b.name)

from abc import ABCMeta, abstractmethod

#---------------------抽象产品类---------------

class CPU(metaclass=ABCMeta):#CPU
    @abstractmethod
    def show_cpu(self):
        pass

class Memory(metaclass=ABCMeta):#内存
    @abstractmethod
    def show_memory(self):
        pass

class Board(metaclass=ABCMeta):#主板
    @abstractmethod
    def show_board(self):
        pass

class Disk(metaclass=ABCMeta):#硬盘
    @abstractmethod
    def show_disk(self):
        pass

#---------------------具体产品类---------------
class Cpu_i3(CPU):
    def show_cpu(self):
        print('i3-cpu')

class Cpu_i5(CPU):
    def show_cpu(self):
        print('i5-cpu')

class Cpu_Amd(CPU):
    def show_cpu(self):
        print('Amd-cpu')

class Memory_san(Memory):
    def show_memory(self):
        print('san-memory')

class Memory_hd(Memory):
    def show_memory(self):
        print('hd-memory')

class Disk_kid(Disk):
    def show_disk(self):
        print('kid-disk')
class Disk_to(Disk):
    def show_disk(self):
        print('to-disk')

class Board_h(Board):
    def show_board(self):
        print('h-board')
class Board_b(Board):
    def show_board(self):
        print('b-board')

#---------------------抽象工厂类---------------
class Compt(metaclass=ABCMeta):#主机
    @abstractmethod
    def make_cpu(self):
        pass
    @abstractmethod
    def make_memory(self):
        pass
    @abstractmethod
    def make_board(self):
        pass
    @abstractmethod
    def make_disk(self):
        pass

#---------------------具体工厂类---------------

class Compt_i3(Compt):
    def make_cpu(self):
        return Cpu_i3()

    def make_board(self):
        return Board_b()

    def make_memory(self):
        return Memory_hd()

    def make_disk(self):
        return Disk_kid()

class Compt_i5(Compt):
    def make_cpu(self):
        return Cpu_i5()

    def make_board(self):
        return Board_h

    def make_memory(self):
        return Memory_hd()

    def make_disk(self):
        return Disk_kid()

#------客户端---手机配置类-----

class Computer:
    def __init__(self,cpu,memory,board,disk):##组合模式
        self.cpu=cpu
        self.memory=memory
        self.board=board
        self.disk=disk
    def show_info(self):
        print('主机配置:')
        self.cpu.show_cpu()
        self.board.show_board()
        self.memory.show_memory()
        self.disk.show_disk()
#-----------生产手机函数------------
def make_Computer(factory):
    cpu=factory.make_cpu()
    memory=factory.make_memory()
    board=factory.make_board()
    disk=factory.make_disk()
    return Computer(cpu,memory,board,disk)
a=make_Computer(Compt_i3())
a.show_info()

from abc import ABCMeta, abstractmethod

class Payment(metaclass=ABCMeta):#继承抽象类约束 接口
    @abstractmethod
    def pay(self,money):
        pass

class Alipay(Payment): #产品类
    def __init__(self,yeb=False):
        self.yeb=yeb
    def pay(self,money):
        if self.yeb:
            print('余额宝支付%s元'%money)
        else:
            print('支付宝支付%s元'%money)

class ApplePay(Payment):
    def pay(self,money):
        print('苹果支付%s元'%money)
class WeChatpay(Payment):
    def pay(self,money):
        print('微信支付%s元'%money)


class PaymentFactory(metaclass=ABCMeta):#抽象工厂  接口
    @abstractmethod
    def create_payment(self):
        pass

class AlipayFactory(PaymentFactory):#具体产品工厂
    def create_payment(self):
        return Alipay()
class AlipayyebFactory(PaymentFactory):#具体产品工厂
    def create_payment(self):
        return Alipay(True)

AA=AlipayFactory()
AB=AlipayyebFactory()
a=AA.create_payment()
b=AB.create_payment()
a.pay(100)
b.pay(300)