当前位置: 澳门新濠3559 > 编程 > 正文

一、单例模式,使其只能创建某以特定类类型的

时间:2019-11-29 05:50来源:编程
单例模式是一种创建型模式,它会限制应用程序,使其只能创建某以特定类类型的一个单一的实例。 至此,我们简单了解了相关的 魔术函数 的作用。 单例模式的实现 1.我们可以在类中

  单例模式是一种创建型模式,它会限制应用程序,使其只能创建某以特定类类型的一个单一的实例。

至此,我们简单了解了相关的魔术函数的作用。

图片 1

单例模式的实现

  1.我们可以在类中使用一个静态属性,来保证对于一个特定的类来说只存在一个单一的实例。

class Payment{
    static private $_instance = NULL;

}

  

  2.接下来,我们需要在类中创建一个静态方法,在类的实例不存在的时候,此方法将会创建一个这个类的实例,并且返回这个实例。

static function getInstance(){
    if(self::$_instance == NULL){
        self::$_instance = new Payment();
    }
    return self::$_instance;
}

  通常情况下,单例模式中的这个方法的名字命名为getInstance(),在这个方法中,会有一个条件语句用于检查$_inistance属性是否是一个NULL值。如果是,将会使用new关键字实例化自身,并赋值给这个属性,否则直接返回这个属性。

  

  3.现在这个类可以按照这个方法使用:

$pay = Payment::getInstance();

 

  可以看到,结果是:

6.设计模式六大原则(6):开闭原则

使用场景举例

  单例模式是在一些限制必须使用单一实例的场景中。例如,一个公司有且只有一个财务中心,公司的所有资金流入流出、财务制度等都由这个财务中心来管理。

  

  

图片 2

主要目的:创建对象

  学习设计模式最难的事情就是理解什么样的设计模式适用于什么样的场景。

(2)元类编程重写__call__方法

图片 3

单例模式的改进

  如果一个用户试图使用 new 或 clone 去创建这个类的新对象,那么就会得到多个实例,这样就破坏了单例模式的限制。

  防止这种情况发生的一个技巧就是创建一个私有的构造函数:

private function __construct(){}
private function __clone(){}

  此时,用户尝试使用new去实例化这个类,程序就会产生一个错误。

 

通常应用于场景为:日志记录、数据库操作等,程序运行时只能生成一个实例,避免对同一资源产生冲突的访问请求。

1.1设计模式

下面讨论元类type构造类以及实例的过程:

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

Student的类,ClassStudent是对这个类的引用。当采用()调用,即实现Meta的实例的可调用的实例化过程。

4.设计模式六大原则(4):接口隔离原则

 

·我们可以将类比作制造商,__new__方法就是前期的原材料购买环节,__init__方法就是在有原材料的基础上,加工,初始化商品环节

  

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

这个过程是,首先__new__创建类的实例,作为__init__的输入,完成构造函数的作用。当然这个过程的结果是获得了一个实例并且是叫做:

需要通过修饰器@staticmethod来进行修饰,静态方法不需要多定义参数

当然对于python3来说,添加了新的声明单例的方法:

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

class ClassStudent(object):
    _age = 20
    pass

instance1 = ClassStudent()
instance2 = ClassStudent()
print id(instance1),id(instance2)
print instance1._age,instance2._age

1.创建型模式

元类是一个类的类,可以通过创建元类,重新定义类的行为。当我们用类A创建一个类的时候,python通过A = type( name , bases , dict )创建它,其中name是类的名称,base是基类,dict是属性变量。

简单工厂的优点和缺点

  至此,可以看到,通过元类编程实现单例模式,需要改的是__call__函数,因为其构造函数是为了构造类的,而不是在生成实例的过程中,通过函数调用的方式生成实例会调用__call__,因此在这个位置操作。

1.1.1类方法

 当然,对于单例类的使用,可以在类中通过__metaclass__属性来设置,取代用type类直接生成的方法。

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

class Singleton(object):
    def __new__(self):
        if not hasattr(self,'instance'):
            self.instance = super(Singleton,self).__new__(self)
        return self.instance


a = Singleton()
b = Singleton()


print id(a),id(a)

即一个类只负责一项职责

对于上述单例模式,关注的是生成单一的实例,而通常程序员需要的是让实例共享相同的状态,因此,有时候需要关注状态和行为,而不是同一性。这种概念即为Monostate(单态)模式。python实现这个模式的过程较为轻松:

图片 4

class Meta(type):
    _instance = {}
    def __init__(self, name, bases, attrs):
        print "init"
        super(Meta, self).__init__(name, bases, attrs)
    def __new__(meta,name, bases, attrs):
        print "new"
        return super(Meta,meta).__new__(meta,name, bases, attrs)
    def __call__(self):
        print "call"

        if self not in self._instance:
            self._instance[self] = super(Meta,self).__call__()
        return self._instance[self]


class ClassStudent(object):
    __metaclass__ = Meta
    pass

instance1 = ClassStudent()
instance2 = ClassStudent()
print id(instance1),id(instance2)

5.设计模式六大原则(5):迪米特法则

  该方法主要思路就是在覆盖实例化函数__new__(),在其中添加判断,检查对象是否存在。hasattr是python的特殊方法,用来查看对象是否具有某个属性。

3.设计模式六大原则(3):依赖倒置原则

当然,如果想要继承这个Singleton,子类中一定不要忘了重写__new__方法,否则会覆盖掉父类中已经修改的方法。

图片 5

二、如何设计单例模式

图片 6

单例模式是应用开发过程中最简单同时也是最著名的一种创建型设计模式。单例模式提供了一个类只有一个特定类型的对象的机制。

图片 7

class Test(metaclass = MyMeta):
    pass

图片 8

通过元类实现单例模式的方法为:

图片 9

(1)重写构造函数__new__方法

一个对象应该对其他对象保持最少的了解。尽量降低类与类之间的耦合。

 

总结

一、单例模式

运行结果

三、Monostate模式

1.设计模式六大原则(1):单一职责原则

  可以看到,虽然不是一个实例,但是状态相同。

一个软件实体如类、模块和函数应该对扩展开放,对修改关闭。

class Singleton(object):
    def __new__(self):
        if not hasattr(self,'instance'):
            self.instance = super(Singleton,self).__new__(self)
        return self.instance

class test(Singleton):
    def __new__(self):
        super(Singleton,self).__new__(self)
a = test()
b = test()


print id(a),id(a)

1.1.1静态方法

  当用户定义一个类class的时候,Python解释器就会在当前类中查找"__metaclass__"属性,如果找到,就通过该属性对应的代码创建类;如果没有找到,就继续以相同的规则查找父类。如果在任何父类中都找不到"__metaclass__",就会用内置的type来创建类对象。

3.行为型模式

class Meta(type):
    _instance = {}
    def __init__(self, name, bases, attrs):
        print "init"
        super(Meta, self).__init__(name, bases, attrs)
    def __new__(meta,name, bases, attrs):
        print "new"
        return super(Meta,meta).__new__(meta,name, bases, attrs)
    def __call__(self):
        print "call"

        if self not in self._instance:
            self._instance[self] = super(Meta,self).__call__()
        return self._instance[self]


s = ["Student", (object, ), {"name": "Joe", "age": 25}   ]    
ClassStudent = Meta(*s)
instance1 = ClassStudent()
instance2 = ClassStudent()
print id(instance1),id(instance2)

1.1.1分类

class Meta(type):
    def __init__(self, name, bases, attrs):
        print "init"
        super(Meta, self).__init__(name, bases, attrs)
    def __new__(meta,name, bases, attrs):
        print "new"
        return super(Meta,meta).__new__(meta,name, bases, attrs)
    def __call__(self):
        print "call"
        return super(Meta,self).__call__()


s = ["Student", (object, ), {"name": "Joe", "age": 25}   ]    
ClassStudent = Meta(*s)
instance = ClassStudent()

2、静态方法:不传参,实例和类对象都能访问

  

客户端不应该依赖它不需要的接口;一个类对另一个类的依赖应该建立在最小的接口上。

总结:

图片 10

1.1静态方法和类方法

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

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

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

主要目的:对象的行为,对象能做什么

1.1工厂设计模式

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

1、类方法,实例和类对象都能访问

1.1__new__的使用

所有引用基类的地方必须能透明地使用其子类的对象

是类对象所拥有的方法,需要用修饰器@classmethod(注解、元数据)来标识其为类方法,对于类方法,第一个参数必须是类对象,一般以cls作为第一个参数(当然可以用其他名称的变量作为其第一个参数,但是大部分人都习惯以'cls'作为第一个参数的名字,就最好用'cls'了),能够通过实例对象和类对象去访问。

类方法还有一个用途就是可以对类属性进行修改:

1.1.1设计模式六大原则

运行结果

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

高层模块不应该依赖低层模块,二者都应该依赖其抽象;抽象不应该依赖细节;细节应该依赖抽象。

从类方法和实例方法以及静态方法的定义形式就可以看出来,类方法的第一个参数是类对象cls,那么通过cls引用的必定是类对象的属性和方法;而实例方法的第一个参数是实例对象self,那么通过self引用的可能是类属性、也有可能是实例属性(这个需要具体分析),不过在存在相同名称的类属性和实例属性的情况下,实例属性优先级更高。静态方法中不需要额外定义参数,因此在静态方法中引用类属性的话,必须通过类对象来引用

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

总结

图片 11

设计一个卖车的4S店,该怎样做呢?

优点:在简单工厂中

cls:类对象

2.结构型模式

2.设计模式六大原则(2):里氏替换原则

编辑:编程 本文来源:一、单例模式,使其只能创建某以特定类类型的

关键词: