首页 > 其他 > 详细

设计模式------简单工厂模式

时间:2014-05-04 09:05:53      阅读:421      评论:0      收藏:0      [点我收藏+]

      简单工厂模式专门定义一个类来负责创建其他类的实例,被创建的实例通常都具有共同的父类。它又称为静态工厂方法模式,属于类的创建型模式。简单工厂模式的实质是由一个工厂类根据传入的参数,动态决定应该创建哪一个产品类(这些产品类继承自一个父类或接口)的实例。

1、角色及职责:

●工厂(Creator)角色

是简单工厂模式的核心,它负责实现创建所有实例的内部逻辑。工厂类可以被外界直接调用,创建所需的产品对象。

●抽象产品(Product)角色

是简单工厂模式所创建的所有对象的父类,它负责描述所有实例所共有的公共接口。

●具体产品(ConcreteProduct)角色

是简单工厂模式的创建目标,所有创建的对象都是充当这个角色的某个具体类的实例。

2、特点:

●优点

工厂类是整个模式的关键,包含了必要的逻辑判断,根据外界给定的信息决定究竟应该创建哪个具体类的对象,不必考虑这些对象是如何创建和组织的。明确了各自的职责和权利,有利于整个软件体系结构的优化。

●缺点

(1)由于工厂类集中了所有实例的创建逻辑,违反了高内聚责任分配原则,将全部创建逻辑集中到了一个工厂类中。

(2)它所能创建的类只能是事先考虑到的,如果需要添加新的类,则就需要改变工厂类了。

(3)当系统中的具体产品类不断增多时候,可能会出现要求工厂类根据不同条件创建不同实例的需求.这种对条件的判断和对具体产品类型的判断交错在一起,很难避免模块功能的蔓延,对系统的维护和扩展非常不利。

3、使用场景:

●工厂类负责创建的对象比较少;

●客户只知道传入工厂类的参数,对于如何创建对象(逻辑)不关心。

4、实例

工厂角色——简单运算工厂类:

 public class OperationFactory
    {
        public static Operation createOperate(string operate)
        {
            Operation oper = null;
            switch (operate )
            {
                case "+":
                    oper = new OperationAdd();
                    break;
                case "-":
                    oper = new OperationSub();
                    break;
                case "*":
                    oper = new OperationMul();
                    break;
                case "/":
                    oper = new OperationDiv();
                    break;
            }
            return oper;
        }
    }
抽象产品角色——运算类:

public class Operation
    {
        private double _numberA = 0;
        private double _numberB = 0;

        public double NumberA
        {
            get { return _numberA; }
            set { _numberA = value; }
        }
        public double NumberB
        {
            get { return _numberB; }
            set { _numberB = value; }
        }

        //虚方法
        public virtual double GetResult()
        {
            double result = 0;
            return result;
        }
    }
具体产品角色——各个运算方法:

//分别定义各个运算,重写虚方法
     //加法
    class OperationAdd : Operation
    {
        public override double GetResult()
        {
            double result = 0;
            result = NumberA + NumberB;
            return result;
        }
    }
    //减法
        class OperationSub : Operation
    {
       ...
    }
    //乘法
    class OperationMul : Operation
    {
       ...
    }
    //除法,注意:判断除数是否为零
    class OperationDiv : Operation
    {
       ...
    }
客户端:

 static void Main(string[] args)
        {
            try
            {
                Console.Write("请输入数字A:");
                string strNumberA = Console.ReadLine();
                Console.Write("请选择运算符号(+、-、*、/、):");
                string strOperate = Console.ReadLine();
                Console.Write("请输入数字B:");
                string strNumberB = Console.ReadLine();

                string strResult = "";
                //根据用户选择的运算符,在工厂中实例化具体对象
                Operation oper;
                oper = OperationFactory.createOperate(strOperate);
                //类型转换
                oper.NumberA = Convert.ToDouble(strNumberA);
                oper.NumberB = Convert.ToDouble(strNumberB);
                //计算出结果,转换成字符串并输出
                strResult = oper.GetResult().ToString();
                Console.WriteLine("结果是:" + strResult);
                Console.ReadLine();
            }
            catch(Exception ex)
            {
                Console.WriteLine("您的输入有错:" + ex .Message );
            }
        }
5、理解

    简单工厂模式实际上是对面向对象继承中常用的Override技术的一次简单的应用。写一个基类ClassBase,并定义一个虚函数vf,再写几个子类继承这个基类ChildClass:ClassBase,并实现自己的函数vf。工厂类只是负责根据输入参数的不同来生成不同的子类,并将生成的子类作为基类返回。客户端只需要调用工厂类创建一个基类的实例,然后调用这个实例的函数vf来实现自己的功能。


设计模式------简单工厂模式,布布扣,bubuko.com

设计模式------简单工厂模式

原文:http://blog.csdn.net/cyl_happygirl/article/details/24932487

(0)
(0)
   
举报
评论 一句话评论(0
关于我们 - 联系我们 - 留言反馈 - 联系我们:wmxa8@hotmail.com
© 2014 bubuko.com 版权所有
打开技术之扣,分享程序人生!