sjms-2 建立型模式

时间  2019-11-09
标签 sjms 建立 模式 繁體版
原文   原文链接

设计模式分类

建立型模式（5种）：工厂方法模式、抽象工厂模式、建立者模式、原型模式、单例模式
结构型模式（7种）：适配器模式、桥模式、组合模式、装饰模式、外观模式、享元模式、代理模式
行为型模式（11种）：解释器模式、责任链模式、命令模式、迭代器模式、中介者模式、备忘录模式、观察者模式、状态模式、策略模式、访问者模式、模板方法模式python

建立型模式

简单工厂模式

内容：不直接向客户端暴露对象建立的实现细节，而是经过一个工厂类来负责建立产品类的实例。
角色：
工厂角色（Creator）
抽象产品角色（Product）
具体产品角色（Concrete Product）shell

 

from abc import ABCMeta, abstractmethod


class Payment(metaclass=ABCMeta):
    # abstract class
    @abstractmethod
    def pay(self, money):
        pass

class Alipay(Payment):
    def __init__(self, use_huabei=False):
        self.use_huaei = use_huabei

    def pay(self, money):
        if self.use_huaei:
            print("花呗支付%d元." % money)
        else:
            print("支付宝余额支付%d元." % money)


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


class PaymentFactory:
    def create_payment(self, method):
        if method == 'alipay':
            return Alipay()
        elif method == 'wechat':
            return WechatPay()
        elif method == 'huabei':
            return Alipay(use_huabei=True)
        else:
            raise TypeError("No such payment named %s" % method)


# client
pf = PaymentFactory()
p = pf.create_payment('huabei')
p.pay(100)


隐藏了内部实现。把好几种支付方式的建立细节封装到工厂里面

优势：
隐藏了对象建立的实现细节
客户端不须要修改代码
缺点：
违反了单一职责原则，将建立逻辑几种到一个工厂类里
当添加新产品时，须要修改工厂类代码，违反了开闭原则数据库

 

添加新的支付方式，须要去修改工厂函数。设计模式

工厂方法模式

内容：定义一个用于建立对象的接口（工厂接口），让子类决定实例化哪个产品类。
角色：
抽象工厂角色（Creator）
具体工厂角色（Concrete Creator）
抽象产品角色（Product）        
具体产品角色（Concrete Product）   微信

from abc import ABCMeta, abstractmethod


class Payment(metaclass=ABCMeta):
    # abstract class
    @abstractmethod
    def pay(self, money):
        pass


class Alipay(Payment):
    def __init__(self, use_huabei=False):
        self.use_huaei = use_huabei

    def pay(self, money):
        if self.use_huaei:
            print("花呗支付%d元." % money)
        else:
            print("支付宝余额支付%d元." % money)


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


class BankPay(Payment):
    def pay(self, money):
        print("银行卡支付%d元." % money)

# ===

class PaymentFactory(metaclass=ABCMeta):  # 相似做用桥梁
    @abstractmethod
    def create_payment(self):
        pass


class AlipayFactory(PaymentFactory):
    def create_payment(self):
        return Alipay()


class WechatPayFactory(PaymentFactory):
    def create_payment(self):
        return WechatPay()


class HuabeiFactory(PaymentFactory):
    def create_payment(self):
        return Alipay(use_huabei=True)


class BankPayFactory(PaymentFactory):
    def create_payment(self):
        return BankPay()


# client

pf = HuabeiFactory()
p = pf.create_payment()
p.pay(100)

　

 

优势：函数

每一个具体产品都对应一个具体工厂类，不须要修改工厂类代码微信支付

隐藏了对象建立的实现细节ui

缺点：操作系统

每增长一个具体产品类，就必须增长一个相应的具体工厂类（去调用产品）设计

　

抽象工厂模式

内容：定义一个工厂类接口，让工厂子类来建立一系列相关或相互依赖的对象。
例：生产一部手机，须要手机壳、CPU、操做系统三类对象进行组装，其中每类对象都有不一样的种类。对每一个具体工厂，分别生产一部手机所须要的三个对象。
相比工厂方法模式，抽象工厂模式中的每一个具体工厂都生产一套产品。

 

角色：
抽象工厂角色（Creator）
具体工厂角色（Concrete Creator）
抽象产品角色（Product）
具体产品角色（Concrete Product）
客户端（Client）

from abc import abstractmethod, ABCMeta

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

class PhoneShell(metaclass=ABCMeta):
    @abstractmethod
    def show_shell(self):
        pass

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

class OS(metaclass=ABCMeta):
    @abstractmethod
    def show_os(self):
        pass

# ------抽象工厂------

class PhoneFactory(metaclass=ABCMeta):
    @abstractmethod
    def make_shell(self):
        pass

    @abstractmethod
    def make_cpu(self):
        pass

    @abstractmethod
    def make_os(self):
        pass

# ------具体产品------

class SmallShell(PhoneShell):
    def show_shell(self):
        print("普通手机小手机壳")

class BigShell(PhoneShell):
    def show_shell(self):
        print("普通手机大手机壳")

class AppleShell(PhoneShell):
    def show_shell(self):
        print("苹果手机壳")

class SnapDragonCPU(CPU):
    def show_cpu(self):
        print("骁龙CPU")

class MediaTekCPU(CPU):
    def show_cpu(self):
        print("联发科CPU")

class AppleCPU(CPU):
    def show_cpu(self):
        print("苹果CPU")

class Android(OS):
    def show_os(self):
        print("Android系统")

class IOS(OS):
    def show_os(self):
        print("iOS系统")

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

class MiFactory(PhoneFactory):
    def make_cpu(self):
        return SnapDragonCPU()

    def make_os(self):
        return Android()

    def make_shell(self):
        return BigShell()

class HuaweiFactory(PhoneFactory):
    def make_cpu(self):
        return MediaTekCPU()

    def make_os(self):
        return Android()

    def make_shell(self):
        return SmallShell()

class IPhoneFactory(PhoneFactory):     # 每一个工厂生产一套限制，防止不一样厂的瞎调用
    def make_cpu(self):
        return AppleCPU()

    def make_os(self):
        return IOS()

    def make_shell(self):
        return AppleShell()


# ------客户端------

class Phone:
    def __init__(self, cpu, os, shell):
        self.cpu = cpu
        self.os = os
        self.shell = shell

    def show_info(self):
        print("手机信息:")
        self.cpu.show_cpu()
        self.os.show_os()
        self.shell.show_shell()

def make_phone(factory):
    cpu = factory.make_cpu()
    os = factory.make_os()
    shell = factory.make_shell()
    return Phone(cpu, os, shell)


p1 = make_phone(IPhoneFactory())
p1.show_info()

　　

优势：
将客户端与类的具体实现相分离
每一个工厂建立了一个完整的产品系列，使得易于交换产品系列
有利于产品的一致性（即产品之间的约束关系）
缺点：
难以支持新种类的（抽象）产品

 

如要增长手机产品配件，再也不是3个一套，而是更多，就须要大改 。用的较少

 

建造者模式 

内容：将一个复杂对象的构建与它的表示分离，使得一样的构建过程能够建立不一样的表示。
角色：
抽象建造者（Builder）
具体建造者（Concrete Builder）
指挥者（Director）
产品（Product）

 

from abc import ABCMeta, abstractmethod

class Player:
    def __init__(self, face=None, body=None, arm=None, leg=None):
        self.face = face
        self.body = body
        self.arm = arm
        self.leg = leg

    def __str__(self):
        return "%s, %s, %s, %s" % (self.face, self.body, self.arm, self.leg)


class PlayerBuilder(metaclass=ABCMeta):
    @abstractmethod
    def build_face(self):
        pass

    @abstractmethod
    def build_body(self):
        pass

    @abstractmethod
    def build_arm(self):
        pass

    @abstractmethod
    def build_leg(self):
        pass


class SexyGirlBuilder(PlayerBuilder):
    def __init__(self):
        self.player = Player()

    def build_face(self):
        self.player.face = "漂亮脸蛋"

    def build_body(self):
        self.player.body = "苗条"

    def build_arm(self):
        self.player.arm = "漂亮胳膊"

    def build_leg(self):
        self.player.leg = "大长腿"


class MonsterBuilder(PlayerBuilder):
    def __init__(self):
        self.player = Player()

    def build_face(self):
        self.player.face = "怪兽脸"

    def build_body(self):
        self.player.body = "怪兽身材"

    def build_arm(self):
        self.player.arm = "长毛的胳膊"

    def build_leg(self):
        self.player.leg = "长毛的腿"


class PlayerDirector: # 控制组装顺序
    def build_player(self, builder):
        builder.build_body()
        builder.build_face()
        builder.build_arm()
        builder.build_leg()
        return builder.player


# client

builder = MonsterBuilder()
director = PlayerDirector()
p = director.build_player(builder)
print(p)

　　

建造者模式与抽象工厂模式类似，也用来建立复杂对象。主要区别是建造者模式着重一步步构造一个复杂对象，而抽象工厂模式着重于多个系列的产品对象。
优势：
隐藏了一个产品的内部结构和装配过程
将构造代码与表示代码分开
能够对构造过程进行更精细的控制

单例模式

内容：保证一个类只有一个实例，并提供一个访问它的全局访问点。
角色：
单例（Singleton）
优势：
对惟一实例的受控访问
单例至关于全局变量，但防止了命名空间被污染

class Singleton:
    def __new__(cls, *args, **kwargs):
        _instance = None  # 假定没有实列
        if not hasattr(cls, "_instance"): # 若是没有就建立，有就返回实列
            cls._instance = super(Singleton, cls).__new__(cls)
        return cls._instance


class MyClass(Singleton):
    def __init__(self, a):
        self.a = a


a = MyClass(10)
b = MyClass(20)

print(a.a)
print(b.a)
print(id(a), id(b))

"""
20
20
1319845376968 1319845376968      
"""

# 日志对象
# 数据库连接池

　　

建立型模式小结抽象工厂模式和建造者模式相比于简单工厂模式和工厂方法模式而言更灵活也更复杂。一般状况下、设计以简单工厂模式或工厂方法模式开始，当你发现设计须要更大的灵活性时，则像更复杂的设计模式演化。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程