天天看点
返回

设计模式1—创建型模式

目录

1. 简单工厂模式（Simple Factory）

2.工厂方法模式（Factory Method）​

3.抽象工厂模式（Abstract Factory）​

4.创建者模式（Builder）

5.原型模式（Prototype）

6.单例模式（Singleton）

1. 简单工厂模式（Simple Factory）

意图：

定义一个用于创建对象的接口，让子类决定实例化哪一个类。

创建的产品不多，只要一个工厂类就可以完成，这种模式叫“简单工厂模式”，它不属于 GoF 的 23 种经典设计模式，它的缺点是增加新产品时会违背“开闭原则

适用性：

当一个类不知道它所必须创建的对象的类的时候。

当一个类希望由它的子类来指定它所创建的对象的时候。

当类将创建对象的职责委托给多个子类中的某一个。

'''1.simple factory model'''
# 父类
class Shape(object):
    def __init__(self):
        pass
# Shape的子类
class Circle(Shape):
    def __init__(self):
        print('圆')
    def __character__(self):
        print('0000')
# Shape的子类
class Rectangle(Shape):
    def __init__(self):
        return '三角'
    def __character__(self):
        print('0001')
#工厂模式：暴露给用户调用，用户可通过该类来选择Shape的子类进行实例化        
class ShapeFactory(object):
  # 条件判断
    def create(self,shape):
        if shape=='Circle':
            return Circle()
        elif shape=='Rectangle':
            return Rectangle()
        else:
            return None
  # 集合键值对
    def create2(self,shape):
         geometric={'circle':Circle,'rectangle':Rectangle}
         try:
             return geometric[shape]()
         except KeyError:
             return str(shape)

def simple_factory_model():
    fac=ShapeFactory()
    obj=fac.create('Circle')
    obj.__character__()
    obj2=fac.create2('circle')
    obj.__character__()

if __name__=='__main__':
    simple_factory_model()
设计模式1—创建型模式

2.工厂方法模式（Factory Method）

Factory Method 是一个类的实例化延迟到其子类。

定义一个创建产品对象的工厂接口，将产品对象的实际创建工作推迟到具体子工厂类当中。这满足创建型模式中所要求的“创建与使用相分离”的特点。

class Shape2(object):
    def getShape(self):
        return self.shape_name
class Circle2(Shape2):
    def __init__(self):
        self.shape_name='Circle'
    def action(self):
        print('draw circle')
class Rectangle2(Shape2):
    def __init__(self):
        self.shape_name='Retangle'
    def action(self):
        print('draw rectangle')

class ShapeFactory2(object):
    def create(self):
#        ???
        raise NotImplementedError
class CircleFactory2(ShapeFactory2):
    def create(self):
        return Circle2()
class RectangleFactory2(ShapeFactory2):
    def create(self):
        return Rectangle2()


def factory_method_model():
    c=CircleFactory2()
    cobj=c.create()
    cobj.getShape()
    cobj.action()
    r=RectangleFactory2()
    robj=c.create()
    robj.getShape()
    robj.action()

if __name__=='__main__':
    factory_method_model()

设计模式1—创建型模式

3.抽象工厂模式（Abstract Factory）

工厂方法模式中考虑的是一类产品的生产，如畜牧场只养动物、电视机厂只生产电视机、计算机软件学院只培养计算机软件专业的学生等。

同种类称为同等级，也就是说：工厂方法模式只考虑生产同等级的产品，但是在现实生活中许多工厂是综合型的工厂，能生产多等级（种类） 的产品，如农场里既养动物又种植物，电器厂既生产电视机又生产洗衣机或空调，大学既有软件专业又有生物专业等。

抽象工厂模式将考虑多等级产品的生产，将同一个具体工厂所生产的位于不同等级的一组产品称为一个产品族

'''2.factory model'''
#ComputerEngineer()>Factory()>Mainboard() and Cpu()
class AbstractFactory(object):
    computer_name=''
    def createCpu(self):
        pass
    def createMainboard(self):
        pass
class IntelFactory(AbstractFactory):
    computer_name='Intel I7 computer'
    def createCpu(self):
        return IntelCpu('intel Cpu')
    def createMainboard(self):
        return IntelMainboard('intel Mainboard')
class AmdFactory(AbstractFactory):
    computer_name='Amd 4 computer'
    def createCpu(self):
        return AmdCpu('amd cpu')
    def createMainboard(self):
        return AmdMainboard('amd Mainboard')
    
class AbstractCpu(object):
    series_name=''
    istructios=''
class IntelCpu(AbstractCpu):
    def __init__(self,series):
        self.series_name=series
class AmdCpu(AbstractCpu):
    def __init__(self,series):
        self.series_name=series
        
class AbstractMainboard(object):
    series_name=''
class IntelMainboard(AbstractMainboard):
    def __init__(self,series):
        self.series_name=series
class AmdMainboard(AbstractMainboard):
    def __init__(self,series):
        self.series_name=series
        
class ComputerEngineer(object):
    def makeComputer(self,factory):
        self.prepareHardwares(factory)
        
    def prepareHardwares(self,factory):
        self.cpu=factory.createCpu()
        self.mainboard=factory.createMainboard()
        info='''--------computer:%s
        cpu:%s
        mainboard:%s'''%(factory.computer_name,self.cpu.series_name,self.mainboard.series_name)
        print(info)


def factory_model():
    engineer=ComputerEngineer()
    intel_factory=IntelFactory()
    engineer.makeComputer(intel_factory)
    amd_factory=AmdFactory()
    engineer.makeComputer(amd_factory)

if __name__=='__main__':
    factory_model()

设计模式1—创建型模式

4.创建者模式（Builder）

意图：

将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

适用性：

当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时。

当构造过程必须允许被构造的对象有不同的表示时。

基本思想：

某类产品的构建由很多复杂组件组成；

这些组件中的某些细节不同，构建出的产品表象会略有不同；

通过一个指挥者按照产品的创建步骤来一步步执行产品的创建；

相关模式：

思路和模板方法模式很像，模板方法是封装算法流程，对某些细节，提供接口由子类修改，

建造者模式更为高层一点，将所有细节都交由子类实现。

'''4.builder model'''
class PersonBuilder():
    def BuildHead(self):
        pass
    def BuildBody(self):
        pass
    def BuildArm(self):
        pass
    def BuildLeg(self):
        pass
class FatBuilder(PersonBuilder):
    type='Fat'
    def BuildHead(self):
        print('构建%sHead'%self.type)
    def BuildBody(self):
        print('构建%sBody'%self.type)
    def BuildArm(self):
        print('构建%sArm'%self.type)
    def BuildLeg(self):
        print('构建%sLeg'%self.type)
class ThinBuilder(PersonBuilder):
    type='Thin'
    def BuildHead(self):
        print('构建%sHead'%self.type)
    def BuildBody(self):
        print('构建%sBody'%self.type)
    def BuildArm(self):
        print('构建%sArm'%self.type)
    def BuildLeg(self):
        print('构建%sLeg'%self.type)   
class Director():
    pb=None
    def __init__(self,pb):
        self.pb=pb
    def CreatePerson(self):
        self.pb.BuildHead()
        self.pb.BuildBody()
        self.pb.BuildArm()
        self.pb.BuildLeg()


def builder_model():
    pb=ThinBuilder()
    director=Director(pb)
    director.CreatePerson()    
    
    pb2=FatBuilder()
#    director.pb=pb2
#    director.CreatePerson()   
    director2=Director(pb2)
    director2.CreatePerson()

设计模式1—创建型模式

5.原型模式（Prototype）

意图：

用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型相同或相似的新对象。

适用性：

在这里，原型实例指定了要创建的对象的种类。用这种方式创建对象非常高效，根本无须知道对象创建的细节

建立相应数目的原型并克隆它们可能比每次用合适的状态手工实例化该类更方便一些

基本思想：

1.抽象原型类：规定了具体原型对象必须实现的接口。

2.具体原型类：实现抽象原型类的 clone() 方法，它是可被复制的对象。

3.访问类：使用具体原型类中的 clone() 方法来复制新的对象。

'''5.prototype model'''        
class Prototype:
    def __init__(self):
        self.objects={}
  # 注册一个对象    
    def register_object(self,name,obj):
        self.objects[name]=obj
  # 注销一个对象   
    def unregister_object(self,name):
        del self.objects[name]
  # 克隆一个注册对象 更新内部参数字典
    def clone(self,name,**attr):
        obj=copy.deepcopy(self.objects.get(name))
        obj.__dict__.update(attr)
        return obj

class A:
    def __str__(self):
        return 'i am hero A'

def prototype_model():
    a=A()
  # 1.用原型实例指定创建对象的种类
    prototype=Prototype()
  # 2.并且通过拷贝这些原型创建新的对象
    prototype.register_object('a',a)
    b=prototype.clone('a',a=1,b=2,c=3)
    
    print(a)
    print(b.__dict__)
    print(b.a,b.b,b.c)

if __name__=='__main__':
    prototype_model()

设计模式1—创建型模式

6.单例模式（Singleton）

意图：

保证一个类仅有一个实例，并提供一个访问它的全局访问点。

适用性：

当类只能有一个实例而且客户可以从一个众所周知的访问点访问它时。

当这个唯一实例应该是通过子类化可扩展的，并且客户应该无需更改代码就能使用一个扩展的实例时。

基本思想：

1.单例类只有一个实例对象；

2.该单例对象必须由单例类自行创建；

3.单例类对外提供一个访问该单例的全局访问点；

'''6.single model'''  
class Single(object):
#   cls是
    def __new__(cls,*args,**kwargs):
        if not hasattr(cls,'instance'):
            orig=super(Single,cls)
            cls.instance=orig.__new__(cls)
        return cls.instance

class Workspace(Single):
    def __init__(self,name):
        self.name=name

class Work(Single):
    def __init__(self,name):
        self.name=name


def single_model():
    a=Workspace('192.168.0.46')
    print(a.name)
    b=Workspace('192.168.0.48')
    print(a.name)
    print(b.name)
    b.name='root'
    print(a.name)
    print(b.name)

if __name__=='__main__':
    single_model()
设计模式1—创建型模式
设计模式 创建型设计模式
上一篇: javascript正则表达式分组捕获理解
下一篇: 2008年北大信科研究生复试 机考真题（一）--大数据十进制转换

继续阅读