设计模式03、建造者模式 适配者模式 桥模式

01、建造者模式

--定义：将一个复杂对象的构建和它的表示分离，使得同样的构建过程可以创建不同的表示
--角色：
	--抽象建造者(Builder)
	--具体建造者(Concrete Builder)
	--指挥者(Director)
	--产品(Product)
--场景：建造者模式和抽象工厂模式都是为了复杂对象。主要区别在于建造者模式用于一步一步建造一个复杂对象，抽象工厂模式在于一步一步建造一系列复杂对象

--优点：
	--隐藏了一个产品的内部结构和装配过程
	--将构造代码和表示代码分开
	--可以对构造过程进行更精细的控制

--代码：
from abc import *

# 抽象产品类
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 SexGirlBuilder(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 HandsomeMan(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

# 实例化
builder = SexGirlBuilder()
director = PlayerDirector()
p = director.build_player(builder)
print(p)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
漂亮脸蛋 火辣身材 纤细胳膊 丰满腿型

02、适配器模式

--电源有适配器，转换接口也是适配器

--适配器：将一个类的接口转换成客户希望的另一个接口。适配器模式使得原本由于接口不兼容而不能在一起工作的类可以一起工作
--两种实现方式：
	--类适配器：使用多继承
	--对象适配器：使用组合 [在一个类中放入另一个类的对象]
	
--适配的目的：复用代码 + 统一接口

--角色：
	--目标接口 Target
	--待适配的类 Adaptee
	--适配器 Adapter
	
--适用场景：
	--想使用一个已经存在的类，但他的接口不符合你的要求
	--[对象适配器]想使用一些已经存在的子类，但不可能对每一个子类匹配他们的接口。对象适配器可以适配它们的父类接口

--代码：
import abc

# 支付基类
class Payment(metaclass=abc.ABCMeta):
    @abc.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 Bankpay():
    def cost(self, password, money):
        print("银联支付%d元" % money)

# 第二个待适配接口：苹果支付
class Applepay():
    def cost(self, username, password, money):
        print("苹果支付%d元" % money)

# 类适配器模式：单个接口适配
class NewBankpay(Payment, Bankpay):
    def pay(self,money):
        self.cost(password=None, money=money)  # 参数不同如何适配

# 类适配器模式：多个接口适配
"""
# 组合：在一个类中放入另一个类的对象
class A:
    pass
    
class B:
    def __init__(self):
"""
class PaymentAdapter(Payment):
    def __init__(self, payment):
        self.payment = payment

    def pay(self, money):
        print(self.payment.cost.__code__.co_varnames)  # 获取__code__.co_varnames调用者的参数列表

        if self.payment.cost.__code__.co_argcount == 3: # 获取__code__.co_argcount调用者参数个数
            self.payment.cost(password=None, money=money) # 参数适配
        if self.payment.cost.__code__.co_argcount == 4:
            self.payment.cost(username=None, password=None, money=money)  # 参数适配

"""
# 未适配前
p = Bankpay()
p.pay(15)  """

# 一个类接口适配：类适配器 + 使用多继承
p1 = NewBankpay()
p1.pay(19)

# 多个类接口适配：对象适配器 + 使用组合 [在一个类中放入另一个类的对象]
p2 = PaymentAdapter(Applepay())
p2.pay(23)
p3 = PaymentAdapter(Bankpay())
p3.pay(83)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
银联支付19元
('self', 'username', 'password', 'money')
苹果支付23元
('self', 'password', 'money')
银联支付83元

03、桥模式

内容：将一个事物的两个维度分离，使其可以独立的变化
	--抽象：Abstraction  形状是抽象
	--细化抽象：RefinedAbstraction  各种形状
	--实现者：Implementor  颜色是实现，因为形状里面调用了颜色的方法，而具体的画图在颜色中定义
	--具体实现者：ConcreteImplementor  各种颜色里面进行实现
应用场景：
	--当事物有两个维度上的表现，两个维度都可能扩展时
优点：
	--抽象与实现分离
	--扩展性高

--代码：
from abc import ABCMeta, abstractmethod

class Shape(metaclass=ABCMeta):
    def __init__(self, color):
        self.color = color

    @abstractmethod
    def draw(self):
        pass

class Color(metaclass=ABCMeta):
    @abstractmethod
    def paint(self):
        pass

class Rectangle(Shape):
    name="长方形"
    def draw(self):
        # 长方形逻辑
        self.color.paint(self)

class Circle(Shape):
    name="圆形"
    def draw(self):
        # 圆形逻辑
        self.color.paint(self)

# 新增直线
class Line(Shape):
    name = "直线"
    def draw(self):
        # 直线逻辑
        self.color.paint(self)

class Red(Color):
    def paint(self, shape):
        print("红色的 %s" % shape.name)

class Green(Color):
    def paint(self, shape):
        print("绿色的 %s" % shape.name)

shape = Rectangle(Red())
shape.draw()

shape2 = Circle(Green())
shape2.draw()

shape3 = Line(Red())
shape3.draw()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
红色的 长方形
绿色的 圆形
红色的 直线