设计模式——三工厂

原创 2015年11月21日 11:05:07

    设计模式中的三工厂指简单工厂模式、工厂方法模式、抽象工厂模式。

       

    我们来逐步比较这三个模式的区别:

    简单工厂模式核心代码:

<span style="font-size:18px;">//简单运算工厂类</span>
<span style="font-size:18px;">Public class OperationFactoty
         {
         Public static Operation createOperate(stirng operate)
                   {
                            Operation oper = null;
                            Switch(operate)           //通过Switch实例化出合适的对象
                                     {
                                               Case “+”
                                                        Oper = new OperationAdd();
                                                        Break;
                                               Case”-”
                                                        Oper=new OperationSub();
                                                        Break;
                                               Case”*”
                                                        Oper= new OperationSub();
                                                        Break;
                                               Case”\”
                                                        Oper= new OperationDiv();
                                               Break;
                                      }
         Return oper;
                    }
        }                
 
客户端代码:
  Opeaton oper;
  Oper = OperationFactory.createOperate(“+”);   //输入"+",实例化出加法对象
  Oper.NumberA=1;
  Oper.NumberB=2;
  Double result = oper.Getresult();
</span>

       

       优点:工厂类中包含了必要的逻辑判断,根据客户端的选择条件动态的实例化相关的类,对客户端来说,去除了与具体产品的依赖。

       缺点:如果要增加新的功能,需要在运算工厂类里加case,违背了开放—封闭原则。

 

       由此可见,我们只要在客户端输入相应的符号,我们的工厂就能实例化出合适的对象,如:我们的代码实例化出加法对象。

 

       在简单工厂模式的基础上我们再来看工厂方法模式,其核心代码如下:

<span style="font-size:18px;">//构建工厂接口</span>
<span style="font-size:18px;">Interface IFactory
    {
         Operation CreateOperation();
     }
 </span>
<span style="font-size:18px;">//构建具体工厂去实现这个接口
Class Addfactoty : IFactoty
    {
         Public Operation CreateOperation()
       {
         Return new OperationAdd();
        }
     }
 
Class SubFactoty : IFactoty
    {
         Public Operation CreateOperation()
         {
             Return new OperationSub();
          }
    }
 
Class MulFactoty : Ifactoty
   {
         Public Operation CreateOperation()
          {
                   Return new OperationMul();
           }
    }
 
Class DivFactoty : IFactory
   {
         Public Operation createOperation();
         {
                 Return new OperationDiv();
         }
    }
 
客户端代码:
   IFactoty operFactoty = new AddFactoty();   //实例化出加法工厂
   Operation oper= operFactoty.CreateOperation();
   Oper.NumberA =1;
   Oper.NumberB=2;
   Double result = oper.GetResult();
</span>

      工厂方法模式是对简单工厂模式违背开放——封闭原则的改进。

      工厂方法模式把工厂类抽象出一个接口,所有的要生产具体类的工厂去实现这个接口。

      优点:一个简单模式的工厂类,变成 了一个工厂抽象接口和多个具体生成对象的工厂,我们要增加功能时不需要再更改原有的工厂类,只需增加此功能的运算类和相应的工厂类。

 

      在工厂方法模式的基础上我们再来看抽象工厂模式

<span style="font-size:18px;">//IDepartment接口,用于客户端访问,解除与具体数据库访问的耦合</span>
<span style="font-size:18px;">Interface IDepartment
   {
        Void Insert (Department department);
        Department GetDepartment (int id);
   }</span>
<span style="font-size:18px;">
</span>
<span style="font-size:18px;">//SqlserverDepartment类,用于访问SQL Server的Department
Class SqlserverDepartment: IDepartment
   {
         Public void Insert(Department department)
           {
                   Console.WriteLine(“在SQL Server中给Department表增加一条记录”);
           }
       Public Department Getdepartment(int id)
          {
                  Console.WriteLine(“在SQL Server中根据ID得到Department表一条记录”);
                  Return null;
           }
   }</span>
<span style="font-size:18px;">
</span>
<span style="font-size:18px;"></span><pre name="code" class="csharp"><span style="font-size:18px;">//AccessDepartment</span><span style="font-size: 18px; font-family: Arial, Helvetica, sans-serif;">类,用于访问Access的Department</span>
<pre name="code" class="csharp">Class AccessDepartment:IDepartment 
   { 
       Public void Insert(Department department) 
       { 
           Console.WriteLine(“在Access中给Department表增加一条记录”); 
       }
      Public Department GetDepartment(int id) 
         { 
            Console.WriteLine(“在Access中根据ID得到Department表一条记录”);
             Return null;
         }
   }




<span style="font-size:18px;">
</span>
<span style="font-size:18px;">//IFactoty接口,定义一个创建访问Department表对象的抽象工厂接口
Interface IFactoty
    {
         IUser CreateUser();
         IDepartment CreateDepartment();
     }

</span>
<span style="font-size:18px;"></span><pre name="code" class="csharp"><span style="font-size: 18px;">//SqlServerFactory类,实现IFactoty接口,实例化出SqlserverUser和SqlserverDepartment</span>

<span style="font-size:18px;">Class SqlServerFactory: IFactoty
   {
         Public IUser CreateUser()
             {
                   Return new SqlserverUser();
             }
         Public IDepartment CreateDepartment()
             {
                  Return new SqlserverDepartment();
              }
   }</span>
<span style="font-size:18px;">
</span>
<span style="font-size:18px;">//AccessFactoty类,实现IFactoty接口,实例化出AccessUser和AccessDepartment
Class AccessFactoty: IFactoty
   {
         Public IUser CreateUser()
            {
                   Return new AccessUser()
             }
         Public IDepartment CreateDepartment()
            {
                   Return new AccessDepartment ();
            }
    }
客户端代码
Static void
Main(string [] args)
  {
         User user = new User();
         Department dept = new Department();</span>
<span style="font-size:18px;"><span style="white-space:pre">	</span> //IFactory factoty =new SqlServerFactory();,确定实例化出哪个对象给factory
         IFactoty factory = new AccessFactoty();
</span><h1><span style="font-size:18px;">         IUser iu = factory.CreateUser();</span></h1><span style="font-size:18px;">         iu.Insert(user);
         iu.GetUser(1);
         IDepartment id=factory.CreateDepartment();
         id.Insert(dept);
         id.GetDepartment(1);
         console.read();   
   }      
</span>

       由以上代码我们可以看出当有一个工厂类,和工厂操作类的时候,我们要用工厂方法模式。


       那么什么情况下用抽象工厂模式呢?

       现在我们代码中所写的是给User类又增加一个Department类的结果,所以我们可以得出结论:当涉及到多个产品系列问题时,如代码中SQL Server与Access是两个不同分类,而这两个分类都涉及到User类和Department类,这时我们就可以使用抽象工厂类。

 

       简单工厂模式、工厂方法模式、抽象工厂模式之间是有递进关系的,能解决的问题由简到繁,逻辑上也相对复杂一点,把这三个放到一起去看,联系很紧密,差别也很明显。



版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

【大话设计模式】——工厂三姐妹

最近在看设计模式,故事好玩是好玩,可是代码也很多啊,有时候看图不太理解,为了让自己有兴趣并且坚持下去,在第一遍宏观的看了一遍之后,把23种设计模式进行了一下分类,然后再找类似的模式一起学习,通过对比学...

工厂三姐妹——创建型设计模式之二

一、简单工厂 简单工厂是面向对象编程的起步设计模式,用到面向对象设计的三大特性:封装,继承,多态来进行设计是必须的。 封装:使业务逻辑和界面逻辑分离,做到代码复用,而不是复制。 继承:将在同一类...

java设计模式——创建型之工厂三兄弟(1)

Simple Factory Pattern(简单工厂模式)

【设计模式】一石三鸟——三个工厂

整个过程下来,我们使用工厂方法达到了代码的可复用性,提高了效率;使用抽象工厂达到了软件的可拓展性;使用简单工厂改进抽象工厂,达到了解耦的目的;使用反射技术,去除了简单工厂带来的switch或if,更进...

设计模式讲解与代码实践(三)——工厂方法

本文讲解了工厂方法(Factory Method)设计模式的使用目的、基本形态及各参与者,并结合示例代码,讲解了该设计模式在具体业务场景下的使用。

【设计模式】——工厂三姐妹

对于工厂三姐妹,她们之间是各有各的优点,各有各的用途,但都是属于创建型模式。通过看《大话设计模式》和百度搜索,对其有了些基本的了解,就来分别介绍三姐妹的详细情况:     一、简单工厂模式    ...

【设计模式】——工厂三姐妹

工厂三姐妹,指的就是简单工厂模式,工厂方法模式,和抽象工厂模式。他们三个都属于创建型模型,主要用于描述如何创建对象。这三个姐妹之间有相似的地方,也有很多不同的地方,下面让我们来具体看看他们的介绍和区别...

再次回顾设计模式——工厂三姐妹

设计模式可谓再熟悉不过了,工厂三姐妹是设计模式中最常见的,也是面试中最常问的,但是就在昨天联想面试的时候面试官问我工厂方法和抽象工厂的区别,我心里特别明白两者之间的关系,但是就是用语言组织不起来,说了...

设计模式详解——工厂模式(三)

本篇文章介绍一种设计模式——工厂模式。工厂模式是用来封装对象的创建,减少应用程序和具体类之间的依赖,促进松耦合。根据工厂模式的应用特性,一共分为三种子模式:简单工厂模式,工厂方法模式和抽象工厂模式。本...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)