码迷,mamicode.com
首页 > 其他好文 > 详细

案例分析:设计模式与代码的结构特性

时间:2019-12-08 16:03:45      阅读:133      评论:0      收藏:0      [点我收藏+]

标签:案例分析   工厂方法   维护   另一个   计算   没有   集中式   idt   好的   

一、抽象工厂模式

在介绍抽象工厂模式,我们先简单回顾一下简单工厂模式与工厂方法模式。

1.工厂模式:针对一个系列的类,它们有很多的共同点,因此可以将他们称为一个系列的产品,也就是一个系列的类。因此使用一个工厂,用一个工厂创建函数去创建某个具体的类。

实现流程如下:

系列类—>工厂—>创建函数—>某个具体的类

2.工厂方法模式:针对一系列的类,使用一个抽象的工厂接口,之后为每个具体的类都编写一个工厂类,随后在每一个类中使用创建函数创建具体类。

实现流程如下:

系列类——>抽象工厂接口—>多个与系列对应的工厂类—>每个类的创建函数—>某一个具体的类

回顾这些我们可以看出,简单工厂模式是笼统的承包服务,不管有多少个类需要创建,全部都由一个工厂去完成;而工厂函数模式则是定制化服务,每一个工厂只能创建某一种特定的类,但是这些工厂统一遵循即抽象工厂接口的创建方法。

抽象工厂模式即是“分类之后的一对一服务”,我们有多个系列的类需要创建,让某一个工厂专门负责某一类对象的创建,另一个工厂负责另外一类的对象创建。简单来说,简单工厂模式是集中式生产;工厂方法模式是分散式生产;而抽象工厂模式则是对于同一系列的集中式生产,而对于不同系列的分散式生产(结合前两者的优点)。

 

二、抽象工厂模式的使用情景

当出现一系列的产品族,且这些类比较容易划分时,设计模式可以采用使用抽象工厂模式。原因如下:若使用简单工厂模式,那么一个工厂任务会过于繁重(要产生很多类),且各个类间区分度不高;而若使用工厂函数模式,每个类对应一个新的工厂,此时需要创建太多类了,代码冗杂,不利于维护;最好的办法就是现根据现有类的信息对其进行分组处理,然后每组由一个工厂类去完成,这样既体现了一对一的定制服务(分组)又体现了工厂的集中生产(每一个工厂生产一类)

 

三、抽象工厂模式的python案例

现在我们有很多的类需要定义,包括不同形状类(Circle、Rectangle、Ellipse、Triangle等),以及不同颜色类(Red、Blue、Black等)。

接下将会介绍python完整实现抽象工厂模式的过程: 

 

1、定义形状类这个系列

 

import math

 

#定义一个“形状”的接口,里面定义一个面积的接口方法,只有方法的定义,并没有实现体

class IShape(object): 

    def Area(self):

        pass

#定义4个图形类,都是实现Ishape接口,并且每一个图形都有一个可以计算面积的方法,相当于重写接口方法

class Circle(IShape):

    def Area(self,radius):

        return math.pow(radius,2)*math.pi

 

class Rectangle(IShape):

    def Area(self,length,width):

        return 2*length*width

 

class Triangle(IShape):

    def Area(self,baselong,height):

        return baselong*height/2

 

class Ellipse(IShape):

    def Area(self,long_a,short_b):

        return long_a*short_b*math.pi

2、定义颜色类这个系列

 

#定义一个“颜色”的接口,里面定义一个颜色名称的接口方法,只有方法的定义,并没有实现体

class IColor(object): 

    def color(self):

        pass

 

#定义3个颜色类,都是实现IColor接口,并且每一个图形都有一个可以获取颜色名称的方法,相当于重写接口方法

class Red(IColor):

    def color(self,name):

        print(f‘我的颜色是:{name}‘)

 

class Blue(IColor):

    def color(self,name):

        print(f‘我的颜色是:{name}‘)

 

class Black(IColor):

    def color(self,name):

        print(f‘我的颜色是:{name}‘)

3、定义抽象工厂以及与每一个系列对应的工厂

 

class IFactory:  #模拟接口

    def create_shape(self):  #定义接口的方法,只提供方法的声明,不提供方法的具体实现

        pass

    def create_color(self):

        pass

 

#创建形状这一个系列的工厂

class ShapeFactory(IFactory): #模拟类型实现某一个接口,实际上是类的继承

    def create_shape(self, name):  #重写接口中的方法

        if name ==‘Circle‘:

            return Circle()

        elif name == ‘Rectangle‘:

            return Rectangle()

        elif name == ‘Triangle‘:

            return Triangle()

        elif name == ‘Ellipse‘:

            return Ellipse()

        else:

            return None

 

#创建颜色这一个系列的工厂

class ColorFactory(IFactory): #模拟类型实现某一个接口,实际上是类的继承

    def create_color(self, name):  #重写接口中的方法

        if name ==‘Red‘:

            return Red()

        elif name ==‘Blue‘:

            return Blue()

        elif name ==‘Black‘:

            return Black()

        else:

            return None

注:这里的抽象工厂和“工厂方法模式里面的抽象工厂有点区别,因为这里有两个系列的类型需要产生,所以,抽象工厂里面需要有两个函数接口,一个产生”形状“,一个产生”颜色“,然后再在实现该接口的工厂中分别进行重写。

 

4、定义产生工厂类的类——抽象工厂模式的核心所在

 

#定义一个专门产生工厂的类

class FactoryProducer:

    def get_factory(self,name):

        if name==‘Shape‘:

            return ShapeFactory()

        elif name==‘Color‘:

            return ColorFactory()

        else:

            return None

注意:这一步是抽象工厂模式最为与众不同的,如果按照 “简单工厂模式 ”,只需要进行到第三步即可,因为然后我分别使用  ShapeFactory工厂类和ColorFactory类去分别产生每一个系列的类的实例即可,但是我们没有这么做。而是再定义一个新的“ 工厂产生类 ”去让我们决定到底是要产生哪个类的实例。

抽象工厂模式(Abstract Factory Pattern)是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。(这里的FactoryProducer就是超级工厂)。在抽象工厂模式中,接口是负责创建一个相关对象的工厂,不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

 

5、测试运行结果:

 

if __name__==‘__main__‘:

    factory_producer=FactoryProducer()

    shape_factory=factory_producer.get_factory(‘Shape‘)

    color_factory=factory_producer.get_factory(‘Color‘)

    #--------------------------------------------------------------

 

    circle=shape_factory.create_shape(‘Circle‘)

    circle_area=circle.Area(2)

    print(f‘这是一个圆,它的面积是:{circle_area}‘)

 

    rectangle=shape_factory.create_shape(‘Rectangle‘)

    rectangle_area=rectangle.Area(2,3)

    print(f‘这是一个长方形,它的面积是:{rectangle_area}‘)

 

    triangle=shape_factory.create_shape(‘Triangle‘)

    triangle_area=triangle.Area(2,3)

    print(f‘这是一个三角形,它的面积是:{triangle_area}‘)

 

    ellipse=shape_factory.create_shape(‘Ellipse‘)

    ellipse_area=ellipse.Area(3,2)

    print(f‘这是一个椭圆,它的面积是:{ellipse_area}‘)

 

    #---------------------------------------------------------------

    red=color_factory.create_color(‘Red‘)

    red.color(‘红色‘)

 

    blue=color_factory.create_color(‘Blue‘)

    blue.color(‘蓝色‘)

 

    black=color_factory.create_color(‘Black‘)

    black.color(‘黑色‘)

运行结果如下:

 

这是一个圆,它的面积是:12.566370614359172

这是一个长方形,它的面积是:12

这是一个三角形,它的面积是:3.0

这是一个椭圆,它的面积是:18.84955592153876

我的颜色是:红色

我的颜色是:蓝色

我的颜色是:黑色

 

四、抽象工厂设计模式的总结

1、优点:

对于出现多系列的类型,创建逻辑清楚,因为是分门别类进行创建的;结合了“简单工厂模式”和“工厂方法模式”的优点

2、缺点

一系列产品族扩展非常困难,要增加一个系列的某一产品,既要在抽象的 Creator 里加代码,又要在具体的里面加代码。比如,若还要在增加一系列的材质类型(包括Stone、Wood、Plastic等)。首先,需要再定义一个抽象材质接口,然后定义很多的类去实现这个接口;然后,需要在抽象工厂接口中添加一个create_material()方法,并且还需要实现一个MaterialFactory工厂类;最后,我还需要更改超级工厂FactoryProducer类,由此可见,牵一发而动全身,比较麻烦。

案例分析:设计模式与代码的结构特性

标签:案例分析   工厂方法   维护   另一个   计算   没有   集中式   idt   好的   

原文地址:https://www.cnblogs.com/PGHustcsz/p/12005750.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!