设计模式(二)

a. 面向对象

面向对象的三大特性
	- 封装
		1. 把数据和函数包装在类里
		2. 类的边界限制了一些外界的访问
	- 继承
	- 多态

接口
	- 一种特殊的类,声明了若干方法,要求继承该接口的类必须实现这些方法。
	- 接口就是一种抽象的基类(父类),限制继承它的类必须实现接口中定义的某些方法。
	- 作用: 限制继承接口的类的方法的名称及调用方式;隐藏了类的内部实现。

b. 设计模式

设计模式的六大原则

	- 开闭原则:
		- 开发封闭原则 一个软件实体如类,模块和函数应该对扩展开放,对修改关闭。即软件实体应尽量在不修改原有代码的情况下进行扩展。
	- 里氏(Liskov)替换原则:
		- 所有引用基类(父类)的地方必须透明地使用其子类的对象。
	- 依赖倒置原则:
		- 高层模块不应该依赖底层模块,二者都应该依赖其抽象; 抽象不应该依赖细节; 细节应该依赖抽象。换言之,要针对接口编程,而不是针对实现编程。
	- 接口隔离原则:
		- 使用多个专门的接口,而不使用单一的总接口,即客户端不应该依赖那些它不需要的接口。
	- 迪米特法则:
		- 一个软件实体应当尽可能少迪与其他实体发生相互作用。
	- 单一职责原则:
		- 不要存在多于一个导致类变更的原因。通俗的说,即一个类只负责一项职责。

设计模式分类

	- 创建型模式:
		- 工厂方法模式
		- 抽象工厂模式
		- 创建者模式
		- 单例模式
	- 结构型模式
		- 适配器模式
		- 桥模式
		- 组合模式
		- 装饰模式
		- 外观模式
		- 享元模式
		- 代理模式
	- 行为型模式
		- 解释器模式
		- 责任链模式
		- 命令模式
		- 迭代器模式
		- 中介者模式
		- 备忘录模式
		- 观察者模式
		- 状态模式
		- 策略模式
		- 访问者模式
		- 模版方法模式

创建型模式

a. 单例模式

单例模式
	- 保证一个类只有一个实例,并提供一个访问它的全局访问点
	- 使用场景
		- 当类只能有一个实例而且客户可以从一个总所周知的访问点访问它时
	- 优点
		- 对唯一实例的受控访问
		- 单例想当一全局变量,但防止了命名空间被污染

第一种：模块导入，不管导入多少次，只执行一次
    #mysingleton.py
    class My_Singleton(object):
        def foo(self):
            pass
    my_singleton = My_singleton()
            
    #******.py
    from mysingleton import my_singleton
    my_singleton.foo()




第二种：使用__new__
        
    class Singleton(object):
        _instance = None
        def __new__(cls,*args,**kw):
            if not cls._instance:
                cls._instance = super(Singleton,cls).__new__(cls,*args,**kw) 
            return cls._instance

    class MyClass(Singleton):
        a = 1
    one = MyClass()



第三种：使用装饰器
    from functools inport wraps
        def singleton(cls):
            instances = {}
            @wraps(cls)
            def getinstance(*args,**kw):
                if cls not in instances:
                    instances[cls] = cls(*args,**kw)
                return instances[cls]
    @singleton
    Class MyClass(object)：
        a = 1



第四种：使用metclass    
    Class Singleton(type):
        _instances = {}
        def __call__(cls,*args,**kwargs):
            if cls not in cls._instances:
                cls._instances[cls] = super(Singleton,cls).__call__(*args,**kwargs)
            return cls._instances[cls]
    class MyClass(metaclass=Singleton):   #python3
        a = 1
    class MyClass(object):  #python2
        __metaclass__ = Singleton
        a = 1

b. 简单工厂模式

# coding : utf-8
# create by ztypl on 2017/5/24

from abc import abstractmethod, ABCMeta

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

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

    def pay(self, money):
        if self.enable_yuebao:
            print("余额宝支付%s元" % money)
        else:
            print("支付宝支付%s元" % money)


class ApplePay(Payment):
    def pay(self, money):
        print("苹果支付%s元" % money)


class PaymentFactory:
    def create_payment(self, method):
        if method == "alipay":
            return Alipay()
        elif method == "applepay":
            return ApplePay()
        elif method == "yuebao":
            return Alipay(enable_yuebao=True)
        else:
            raise NameError(method)

f = PaymentFactory()
p = f.create_payment("alipay")
p.pay(100)

c. 工厂方法模式

# coding : utf-8
# create by ztypl on 2017/5/25

from abc import abstractmethod, ABCMeta


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


class Alipay(Payment):
    def pay(self, money):
        print("支付宝支付%s元" % money)


class ApplePay(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 ApplePayFactory(PaymentFactory):
    def create_payment(self):
        return ApplePay()




# 用户输入
# 支付宝，120

af = AlipayFactory()
ali = af.create_payment()
ali.pay(120)

d. 抽象工厂模式

# coding : utf-8
# create by ztypl on 2017/5/25

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(HuaweiFactory())
p1.show_info()

e. 建造者模式