设计模式-结构型模式，适配器模式（4）

适配器模式（Adapter Pattern）是作为两个不兼容的接口之间的桥梁。这种类型的设计模式属于结构型模式，它结合了两个独立接口的功能。

这种模式涉及到一个单一的类，该类负责加入独立的或不兼容的接口功能。举个真实的例子，读卡器是作为内存卡和笔记本之间的适配器。您将内存卡插入读卡器，再将读卡器插入笔记本，这样就可以通过笔记本来读取内存卡。

#!/usr/bin/env python
# encoding: utf-8

class Target(object):
    def request(self):
        print \'Target request\'

class Adaptee(object):
    def specialRequest(self):
        print \'Adaptee specialRequest\'

class Adpater(object):
    def __init__(self, adpatee):
        self.adpatee = adpatee

    def request(self):
        self.adpatee.specialRequest()

if __name__ == \'__main__\':
    objects = []
    a = Target()
    b = Adaptee()

    objects.append(a)
    objects.append(Adpater(b))  #适配接口

    for obj in objects:
        obj.request()       #调用相同接口

适配器模式，是在类写好之后，不想修改原类的代码的方法，

比如狗类有个wangwang()的方法，猫类有个miaomiao()的方法，羊类有个miemie()的方法，现在要让他们都叫一下，要调用每个类的不同方法。

写个适配器类，可以使猫通过适配器类调用wangwang()的方法，但实际的动作是执行了猫类的miaomiao()方法里面的代码。同理羊通过适配器类调用wangwang()的方法，但实际的动作是执行了羊类的miemie()方法里面的代码。

也可以让适配器写一个speak的方法，把适配器的speak()方法重定向到狗猫羊各自的叫法。

# coding=utf-8


class Dog():
    def __init__(self, name):
        self.name = name

    def wangwang(self):
        print \'my name is\' + self.name +  \'。。。汪汪汪。。。\'

    def dog_run(self):
        print \'dog is running\'


class Cat():
    def __init__(self, name):
        self.name = name

    def miaomiao(self):
        print \'my name is\' + self.name + \'。。。喵喵喵。。。\'

    def cat_run(self):
        print \'cat is running\'



class Sheep():
    def __init__(self, name):
        self.name = name

    def miemie(self):
        print \'my name is\' + self.name + \'。。。咩咩。。。\'

    def sheet_run(self):
        print \'sheet is running\'



class Adapter():
    def __init__(self,animal,adapted_methods):
        \'\'\'
        :type adapted_methods: dict
        \'\'\'
        self.__dict__.update(adapted_methods)



def main():
    animals = [Dog(\'旺财\')]
    cat = Cat(\'大脸猫\')
    sheep = Sheep(\'喜洋洋\')

    animals.append(Adapter(cat, {\'wangwang\': cat.miaomiao,\'dog_run\':cat.cat_run}))
    animals.append(Adapter(sheep, {\'wangwang\': sheep.miemie, \'dog_run\': sheep.sheet_run}))

    for a in animals:
        a.wangwang()
        a.dog_run()
        print \'\'


def main2():
    animals = []
    dog = Dog(\'旺财\')
    cat = Cat(\'大脸猫\')
    sheep = Sheep(\'喜洋洋\')
    animals.append(Adapter(cat, {\'speak\': dog.wangwang, \'run\': dog.dog_run}))
    animals.append(Adapter(cat, {\'speak\': cat.miaomiao,\'run\':cat.cat_run}))
    animals.append(Adapter(sheep, {\'speak\': sheep.miemie, \'run\': sheep.sheet_run}))

    for a in animals:
        a.speak()
        a.run()
        print \'\'

if __name__ == "__main__":
    main()
    print \'* \' * 20
    main2()

main1即使标准的适配器模式，猫和羊通过适配器的wangwang（）和dog_run()方法来实际执行各自的叫法和走法。

main2把狗和猫和羊统一通过适配器转换，调用speak()和run()方法来实际执行各自的叫法和走法。

所以为啥要适配器，就是不想改狗猫羊的原有的代码。

如果是一开始，还没开始写猫和狗和羊类就设计的话，那就在猫狗羊里面叫speak方法和run方法。如下。

这样就无需适配器来转换了，也就变成了外观模式了。

class Dog():
    def __init__(self, name):
        self.name = name

    def speak(self):
        print \'my name is\' + self.name +  \'。。。汪汪汪。。。\'

    def run(self):
        print \'dog is running\'


class Cat():
    def __init__(self, name):
        self.name = name

    def speak(self):
        print \'my name is\' + self.name + \'。。。喵喵喵。。。\'

    def run(self):
        print \'cat is running\'



class Sheep():
    def __init__(self, name):
        self.name = name

    def speak(self):
        print \'my name is\' + self.name + \'。。。咩咩。。。\'

    def run(self):
        print \'sheet is running\'

但有的东西先发明就改不了，就像安卓手机的充电线，有的是typec有的是非typec，想要用非typec的充电线给现在的新手机充电，如果不重新换一条数据线，那必须去淘宝买一个转换头了。