一、设计模式与面向对象

1.1 设计模式

  软件设计阶段针对反复出现的问题提出的统一解决方案。每类问题的解决方案都被系统的命名为XX设计模式。

1.2 面向对象

  按照一件事的组成元素分别制作进行组装。这些元素分为属性与接口。

1.2.1 三大特性

  封装：将对象封装为类，将对象数据操作封装为函数。封装分为类内/类外，私有/公有

  继承：父类与子类，表示对象与对象之间的关系

  多态：子类重写父类函数，C++中声明为virutal。python本身是多态语言，只管实现，不用关注细节。

  接口：抽象类，规定继承抽象类的实现行为。接口掌握着所有子类方法的规则，开发中直接阅读接口（抽象类）即可明白其余类方法，方便开发。

from abc import ABCMeta, abstractmethod

# abstract class
class Payment(metaclass=ABCMeta):
    # is overrider in
    @abstractmethod
    def pay(self, money):  # 接口：规定了A_Pay、B_Pay必须实现这个方法。多态的体现之一就是接口在不同子类中的多种实现，这种性质为多态性。
        pass

class A_Pay(Payment): # 封装：将对象A的行为及属性封装为类
    # overriders
    def pay(self, money):
        print("A 支付 %d" % money)

class B_Pay(Payment): # 继承Payment这个接口（抽象类）
     # overriders
    def pay(self, money):
        print("B 支付 %d" % money)

p = A_Pay()
n = B_Pay()
p.pay(100)
n.pay(100)

1.2.2 设计原则

  开放封闭原则：软件实体应对修改关闭，对扩展开放。

  里氏替换原则：子类与父类的同名方法在形参、返回值、逻辑必须一致。

  依赖倒置原则：上层不应该依赖下层，两者都应依赖抽象（接口），即面向接口编程。

  接口隔离原则：使用多个专门的接口，避免使用单一的总接口，即避免依赖那些不需要的接口。适用于类。

  单一职责原则：一个类只负责一项职责。

1.3 面向过程

  按照制作一件事物的顺序进行开发。

二、 设计模式分类

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

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

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

三、简单工厂模式

3.1 内容

  不直接向客户端暴露对象创建的实现细节，而是通过一个工厂类来负责创建产品类的实例。简化上层调用的统一接口。

3.3 代码实现

from abc import ABCMeta, abstractmethod

# abstract class
class Payment(metaclass=ABCMeta):
    @abstractmethod  # 有抽象方法的类为抽象类
    def pay(self, money):
        pass


class AliPay(Payment):
    def pay(self, money):
        print("支付宝 支付 %d" % money)


class WeChatPay(Payment):
    def pay(self, money):
        print("微信 支付 %d" % money)

# 工厂类
class PayFactory:
    # 工厂函数
    def creat_payment(self,method):
        if method == 'AliPay':
            return AliPay()
        elif method == 'WeChatPay':
            return WeChatPay()
        else:
            raise TypeError("No such payment named %s" % method)


pf = PayFactory() # 实例化工厂
p = pf.creat_payment('AliPay') #制造支付方式
p.pay(100)

3.4 优缺点

  优点：客户端调用的接口唯一。

  缺点：有新的产品加入时需要修改工厂类，违反开放封闭原则。

3.5 工厂方法模式

  一个工厂只生产一种产品。

from abc import ABCMeta, abstractmethod


# abstract class
class Payment(metaclass=ABCMeta):
    @abstractmethod  # 有抽象方法的类为抽象类
    def pay(self, money):
        pass


class AliPay(Payment):
    def pay(self, money):
        print("支付宝 支付 %d" % money)


class WeChatPay(Payment):
    def pay(self, money):
        print("微信 支付 %d" % money)


# 工厂接口抽象基类
class PayBasicInterFaceFactory(metaclass=ABCMeta):
    @abstractmethod
    def creat_payment(self):
        raise NotImplementedError


# 工厂类
class AliPayFactory(PayBasicInterFaceFactory):
    # 工厂函数
    def creat_payment(self):
        return AliPay()


# 工厂类
class WeChatPayFactory(PayBasicInterFaceFactory):
    # 工厂函数
    def creat_payment(self):
        return WeChatPay()


ali_pf = AliPayFactory()
p = ali_pf.creat_payment()
p.pay(100)

we_pf = WeChatPayFactory()
p = we_pf.creat_payment()
p.pay(100)

五、抽象工厂模式

建造者模式

单例模式

适配器模式

桥模式

组合模式

外观模式

代理模式

责任链模式