day18（面向对象基础，设计模式）

多继承补充

继承具有传递性，可以借助 类名.__mro__观察继承关系

设计模式

设计模式（Design pattern）代表了最佳的实践，通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。

设计模式六大原则：

1.设计模式六大原则（1）：单一职责原则：即一个类只负责一项职责。

2.设计模式六大原则（2）：里氏替换原则：所有引用基类的地方必须能透明地使用其子类的对象。

3.设计模式六大原则（3）：依赖倒置原则：高层模块不应该依赖低层模块，二者都应该依赖其抽象；抽象不应该依赖细节；细节应该依赖抽象。高内聚，低耦合。

4.设计模式六大原则（4）：接口隔离原则：客户端不应该依赖它不需要的接口；一个类对另一个类的依赖应该建立在最小的接口上。

5.设计模式六大原则（5）：迪米特法则：一个对象应该对其他对象保持最少的了解。尽量降低类与类之间的耦合。

6.设计模式六大原则（6）：开闭原则：一个软件实体如类、模块和函数应该对扩展开放，对修改关闭。

分类：

1.创建型模式：

主要目的：创建对象

共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。

2.结构型模式：

主要目的：对象的组成和对象的关系

共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

3.行为型模式：

主要目的：对象的行为，对象能做什么

共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

工厂设计模式

简单工厂模式：

在创建对象比较简单的时候，我们直接在主方法中做了，但是很多时候，创建对象需要一些初始化的操作，或者业务逻辑的处理。也就是说，有时候创建一个对象会做比较复杂的操作，这个时候，如果所有对象的创建操作都放在主方法中，就不合适了，怎么解决呢？使用简单工厂模式。

先来看看它的组成：

1.工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑，用来创建产品

2.抽象产品角色：它一般是具体产品继承的父类或者实现的接口。

3.具体产品角色：工厂类所创建的对象就是此角色的实例。

简单工厂的优点和缺点：

对象创建比较复杂的时候，可以考虑使用简单工厂。

1.优点：

在简单工厂中主函数或者客户端不再负责对象的创建，而是把这个责任交给工厂类，主函数或者客户端在使用对象的时候只从工厂中调用就行了，从而明确了各个类的职责，符合单一职责原则）。

2.缺点：

由于这个工厂类负责所有对象的创建，那么当子类增多时，我们就需要去修改工厂类的代码，这样呢，就违反了一个原则：开闭原则。

例如：以汽车4s店为例

class Haval:

    def run(self):

        pass

    def stop(self):

        pass

class H9(Haval):

    def run(self):

         print('H9...run')

     def stop(self):

        print('H9...stop')

    def crossCountry(self):

        print('H9...越野车')

class H6(Haval):

    def run(self):

        print('H6...run')

    def stop(self):

         print('H6...stop')

    def city(self):

        print('H6...城市SUV')

class Factory:

    @classmethod

    def createCar(cls,name):

        car = None

        if name=='H9':

            car = H9()

        elif name=='H6':

            car = H6()

        return car

def main():

    carType = input('请输入要购买的型号:')

    car = Factory.createCar(carType)

    if car==None:

        print('没有这样的车')

     else:

        if type(car)==H9:

            car.crossCountry()

       elif type(car)==H6:

            car.city()

            car.run()

            car.stop()

main()

~~~~~~~~~~~~~~~~~~~~~                                        请输入要购买的型号:H1                                              没有这样的车                                                                 ~~~~~~~~~~~~~~~~~~~~~                                         请输入要购买的型号:H6                                               H6...城市SUV                                                     H6...run                                                                 H6...stop 

工厂方法模式：

使用简单工厂模式当子类增多时，我们就需要去修改工厂类的代码，这样呢，就违反了一个原则：开闭原则。可以使用工厂方法模式。

工厂方法模式组成：

1.抽象工厂角色： 这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。

2.具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。

3.抽象产品角色：它是具体产品继承的父类或者是实现的接口。

4.具体产品角色：具体工厂角色所创建的对象就是此角色的实例。

工厂方法模式的优点和缺点

1.优点：

解决了简单工厂模式的违反开闭原则

2.缺点：

如果需要增加一个具体产品类角色，需要添加这个类和对应的工厂类。代码量大。

例如：修改上边实例

class Haval:

    def run(self):

        pass

    def stop(self):

        pass

class H9(Haval):

    def run(self):

        print('H9...run')

    def stop(self):

        print('H9...stop')

    def crossCountry(self):

        print('H9...越野车')

class H6(Haval):

     def run(self):

        print('H6...run')

    def stop(self):

        print('H6...stop')

    def city(self):

        print('H6...城市SUV')

class H1(Haval):

    def run(self):

        print('H1...run')

    def stop(self):

        print('H1...stop')

    def little(self):

        print('H1...小型城市SUV')

class Factory:

    @classmethod

    def createCar(cls):

        pass

class H9Factory(Factory):

    @classmethod

    def createCar(cls):

        return H9()

class H6Factory(Factory):

    @classmethod

    def createCar(cls):

        return H6()

class H1Factory(Factory):

    @classmethod

    def createCar(cls):

        return H1()

car_factory={

    'H9':H9Factory,

    'H6':H6Factory,

    'H1':H1Factory

    }

def main():

    carType = input('请输入要购买的型号:')

    if carType not in car_factory:

        print('没有这样的车')

    else:

        fac = car_factory.get(carType)

        car = fac.createCar()

        car.run()

        car.stop()

main()

~~~~~~~~~~~~~~~~~~~~~~~~~                                结果同上，但是不会违反开闭原则

__new__的使用

__new__至少要有一个参数cls，代表要实例化的类，此参数在实例化时由Python解释器自动提供。

__new__必须要有返回值，返回实例化出来的实例，这点在自己实现__new__时要特别注意，可以return父类__new__出来的实例，或者直接是object的__new__出来的实例。

__init__有一个参数self，就是这个__new__返回的实例，__init__在__new__的基础上可以完成一些其它初始化的动作，__init__不需要返回值。

单例设计模式

确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例，这个类称为单例类，单例模式是一种对象创建型模式。

举个常见的单例模式例子，我们日常使用的电脑上都有一个回收站，在整个操作系统中，回收站只能有一个实例，整个系统都使用这个唯一的实例，而且回收站自行提供自己的实例。因此回收站是单例模式的应用。

class Factory:

    __instance = None

    def __new__(cls,*arg,**kwargs):

        if cls.__instance==None:

            cls.__instance = object.__new__(cls)

        return cls.__instance

f1 = Factory()

f2 = Factory()

print(f1)

print(f2)

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

<__main__.Factory object at 0x000001AAA760B2B0> <__main__.Factory object at 0x000001AAA760B2B0>

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

如上，两个对象地址一样，是同一对象。