一步一步进入抽象工厂模式(Abstract Factory)

原创 2007年09月30日 15:48:00
一、我们在不考虑设计模式时,一般写程序是这样的
// 实体类:
  public class RockRoad
    {
        public  string RoadType()
        {
            return "this is a RockRoad";
        }
    }
  //应用表现部分
    class Program
    {
        static void Main(string[] args)
        {
            RockRoad rRoad = new RockRoad();
            Console.WriteLine(rRoad.RoadType());
        }
    }
­
注:在无需求变化(RockRoad不会变化)时,这种程序设计就可以满足要求。现在需求变化(把RockRoad改为WaterRoad)时,那么把RockRoad实体类改为WaterRoad实体类或者增加一个WaterRoad类,并且把应用表现部分的所有RockRoad对象改成WaterRoad对象,如果引用RockRoad对象非常多的时候,这种改变显然会带来很大的维护成本。因此就要求改变这种设计,引用设计模式的概念。
­
二、根据变化更改设计,引入抽象类
­
//抽象类(接口)
    public abstract class Road
    {
        public abstract string RoadType();
    }
­
// 实体类:继承抽象类,覆写抽象方法(具体实现)
    public class RockRoad:Road
    {
        public override string RoadType()
        {
            return "this is a RockRoad";
        }
    }
­
    public class WaterRoad:Road
    {
        public override string RoadType()
        {
            return "this is a WaterRoad!";
        }
    }
­
//客户程序(我们的目的就是要使这个部分变成稳定,使其不会根据实体类和应用表现部门的变化而变化,他是“根”)
    public class GetRoad
    {
        public string NewRoad(Road road)
        {
            return road.RoadType();
        }
    }
­
//应用表现部分(依赖于客户程序这个“根”)
    class Program
    {
        static void Main(string[] args)
        {
            WaterRoad wRoad = new WaterRoad();//在这里,可以根据客户需求,实例化具体调用的类,如也可以换成RockRoad rRoad = new RockRoad();
            GetRoad getRoad = new GetRoad();      
            Console.WriteLine( getRoad.NewRoad(wRoad));
        }
    }
­
注:这样似乎满足了要求,但是在客户程序GetRoad类的NewRoad方法中如果不仅仅使用一个Road对象,而是根据需要可能需要N个Road对象,这样变化又要求程序进行变化,由此我们引入工厂模式(Factory Method)和原形模式(ProtoType),先来说说工厂模式
­
三、需求要求引入工厂模式,所谓工厂就是制造产品的地方,上面的问题就在于没办法得到多个产品(Road)。来看看工厂模式是如何生产多个产品(Road)的
­
//抽象类(接口)     public abstract class Road
    {
        public abstract string RoadType();
    }
­
// 实体类:继承抽象类,覆写抽象方法(具体实现)
    public class RockRoad:Road
    {
        public override string RoadType()
        {
            return "this is a RockRoad";
        }
    }
­
    public class WaterRoad:Road
    {
        public override string RoadType()
        {
            return "this is a WaterRoad!";
        }
    }
­
//我们先来构建一个生产RockRoad的工厂
    public class RockRoadFactory
    {
        public Road CreateRockRoad()
        {
            return new RockRoad();
        }
    }
­
//客户程序(我们的目的就是要使这个部分变成稳定,使其不会根据实体类和应用表现部门的变化而变化,他是“根”)
    public class GetRoad
    {
        public string NewRoad(RockRoadFactory RockRoadfactory)
        {
            Road road1=RockRoadfactory.CreateRockRoad();//制造第一个RockRoad
            Road road2=RockRoadfactory.CreateRockRoad();//制造第一个RockRoad
            Road road3=RockRoadfactory.CreateRockRoad();//制造第一个RockRoad
            .......................................................................// 可以根据需求制造N多个RockRoad
            return road1.RoadType()+road2.RoadType()+road3.RoadType();
        }
    }
­
//应用表现部分(依赖于客户程序这个“根”)
    class Program
    {
        static void Main(string[] args)
        {
­
            RockRoadFactory rFactory= new RockRoadFactory();//指定生产Road的工厂
            GetRoad getRoad = new GetRoad();      
            Console.WriteLine( getRoad.NewRoad(rFactory));
        }
    }
­
注:这里引入工厂模型后,解决了产生多个Road的问题,但是你是否留意到这个工厂是固定的,只能生产RockRoad,假如我要得到WaterRoad呢,这样要么把RockRoadFactory工厂类改成WaterRoadFactory工厂类或者去增加一个WaterRoadFactory工厂类,然后在去更改客户程序GetRoad类。这不又回到最开始的问题了吗?想想最开始我们是怎么解决这个问题的呢?对了引入抽象类,在这里也就是引入抽象工厂。
­
四、引入抽象工厂
//抽象类(接口)     public abstract class Road
    {
        public abstract string RoadType();
    }
­
// 实体类:继承抽象类,覆写抽象方法(具体实现)
    public class RockRoad:Road
    {
        public override string RoadType()
        {
            return "this is a RockRoad";
        }
    }
­
    public class WaterRoad:Road
    {
        public override string RoadType()
        {
            return "this is a WaterRoad!";
        }
    }
­
//我们在这里来构建抽象工厂类
    public abstract class AbstactFactory
    {
        public abstract Road CreateRoad();
    }
­
//构建一个生产RockRoad的工厂,实现抽象方法CreateRoad()
    public class RockRoadFactory:AbstactFactory
    {
        public override Road CreateRoad()
        {
            return new RockRoad();
        }
    }
//构建一个生产WaterRoad的工厂,实现抽象方法CreateRoad()
    public class WaterRoadFactory:AbstactFactory
    {
        public override Road CreateRoad()
        {
            return new WaterRoad();
        }
    }
­
//客户程序(我们的目的就是要使这个部分变成稳定,使其不会根据实体类和应用表现部门的变化而变化,他是“根”)
    public class GetRoad
    {
        public string NewRoad(AbstactFactory factory)
        {
            Road road1=factory.CreateRoad();//制造第一个Road
            Road road2=factory.CreateRoad();//制造第一个Road
            Road road3=factory.CreateRoad();//制造第一个Road
            .......................................................................// 可以根据需求制造N多个Road
            return road1.RoadType()+road2.RoadType()+road3.RoadType();
        }
    }
­
//应用表现部分(依赖于客户程序这个“根”)
    class Program
    {
        static void Main(string[] args)
        {
­
            RockRoadFactory rFactory= new RockRoadFactory();//指定生产Road的工厂
            GetRoad getRoad = new GetRoad();      
            Console.WriteLine( getRoad.NewRoad(rFactory));
        }
    }
­
注:这样基本问题都得到了解决,但需求要求再变化一种Road(如OilRoad)的时候,只需要新增一个OilRoad类去继续于Road,再新增一个OilRoadFactory工厂类继承于AbstactFactory,然后在应用表现部分去实例化OilRoadFactory就可以了,其他任何地方都不需改动,实现了变修改为扩展的原则
 

【java设计模式】之 抽象工厂(Abstract Factory)模式

1. 女娲的失误         上一节学习了工厂模式,女娲运用了该模式成功创建了三个人种,可是问题来了,她发现没有性别……这失误也忒大了点吧……竟然没有性别,那岂不是……无奈,只好抹掉重来了,于是所...
  • eson_15
  • eson_15
  • 2016年04月26日 23:49
  • 11301

设计模式——抽象工厂模式(Abstract Factory)

要想正确的理解设计模式,首先必须明确它是为了解决什么问题而提出来的。 抽象设计模式概念:         针对抽象工厂这个设计模式,我查找了不少资料,感觉只有涉及产品级别和产品族的才是理解了抽象工厂设...
  • u012909091
  • u012909091
  • 2014年08月02日 16:52
  • 3507

深入浅出设计模式 ------ Abstract Factory(抽象工厂)

本文可以和笔者的深入浅出设计模式 ------ Factory Method(工厂方法)参照着看, 可以区分这三个工厂模式的不同。...
  • wenniuwuren
  • wenniuwuren
  • 2015年01月29日 02:25
  • 1668

Python实现设计模式--02.工厂模式(Factory Pattern)

《设计模式》涉及到创建类的几种模式,共同的也是最根本的原则就是:不要new 对象!!!既然如此,告诉我你最先想到的是如何得到对象呢?没错,“你不让我new,那你给我个get对象的工具吧,别的我不管”。...
  • boy_vansun
  • boy_vansun
  • 2017年07月26日 00:36
  • 124

浅谈Java设计模式——单实例、简单工厂、抽象工厂、观察者

最近的项目里面涉及到一些Java设计模式,在此简单谈一下自己的看法,以下实例一部分参考同行,大部分自己设计。1.单例模式 如果一个类始终只能创建一个实例,则这个类成为单例类,这种设计模式...
  • Princeliu999
  • Princeliu999
  • 2017年08月06日 11:46
  • 359

iOS 21种设计模式之抽象工厂(Abstract Factory)

原创Blog,转载请注明出处 http://blog.csdn.net/hello_hwc?viewmode=list 我的stackoverflow感谢感谢《Pro Objective-C ...
  • Hello_Hwc
  • Hello_Hwc
  • 2015年12月07日 10:13
  • 2073

Android设计模式之一个例子让你彻底明白工厂模式(Factory Pattern)

提出疑问这几天研究工厂模式的时候,看到网上的一些文章中举的例子我就很疑惑,我相信这也是许多人的疑惑:工厂模式的功能就是创建实例,我们创建实例直接new不就完了吗,干嘛还得再封装一层工厂类,然后用工厂类...
  • nugongahou110
  • nugongahou110
  • 2015年12月29日 13:36
  • 6088

抽象工厂模式(Abstract Factory)

抽象工厂模式是对象的创建模式,他是工厂方法模式的进一步推广。 假设一个子系统需要一些产品对象,而这些产品又属于一个以上的产品等级结构。那么为了将消费这些产品对象的责任和创建这些产品对象的责任分割开来,...
  • liu904139492
  • liu904139492
  • 2015年03月09日 20:53
  • 487

Abstract Factory(抽象工厂模式)

Abstract Factory模式的意图是:提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类。 具体到我们迷宫的例子就是: 如果传递一个对象给CreateMaze作参数来创建房间、...
  • jk823394954
  • jk823394954
  • 2016年03月19日 21:41
  • 217

抽象工厂模式(Abstract Factory)

一、模式动机 在工厂方法模式中具体工厂负责生产具体的产品,每一个具体工厂对应一种具体产品,工厂方法也具有唯一性,一般情况下,一个具体工厂中只有一个工厂方法或者一组重载的工厂方法。但是有时候我们需要...
  • qq_20480611
  • qq_20480611
  • 2016年06月24日 19:34
  • 231
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:一步一步进入抽象工厂模式(Abstract Factory)
举报原因:
原因补充:

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