设计模式学习之简单工厂

最近学习设计模式，这里学到简单工厂模式，现把一个简单计算器的代码写下来！

第一步，做一个页面，这里只是做一个最简单的页面，重点学习设计模式，所以页面就很简单啦，在这个简单计算器里面，我还加上了Jquery.ajax，把简单工厂和ajax一起学了！

我们先写好一个运算类，这个类有两个属性，可以当做变量来看，这两个属性就是，就是我要计算的两个运算数，然后再写一个运算方法，这个方法是virtual的，一个虚方法，只返回一个double类型的值，因为我过会要在子类中重写这个方法，这个运算类其实不会做什么，我所做的，都会在子类中去计算：

运算类如下：

 1  /// <summary>
 2     /// 运算类
 3     /// </summary>
 4    public  class Operation
 5     {
 6         private double numbera;//第一个运算数
 7 
 8         public double Numbera 
 9         {
10             get { return numbera; }
11             set { numbera = value; }
12         }
13         private double Numberb;//第二个运算数
14 
15         public double Numberb1 
16         {
17             get { return Numberb; }
18             set { Numberb = value; }
19         }
20         public virtual double GetResult() //运算方法，空，在子类中会重写这个方法
21         {
22             double  result = 0;
23             return result;
24         }
25 
26     }

写好的运算类后，我们现在开始写加，减，成，除，这4个子类了，这几个类中我们去做各种计算，每个类都继承Operation运算类，这样每个类就都是两个运算数和一个运算方法了
第一个加法类如下：

/// <summary>
    /// 加法运算类
    /// </summary>
    class jiafayunsan:Operation 
    {
        public override double GetResult() //重写父类中的运算方法
        {
            double result = 0;
            result = base.Numbera + base.Numberb1; //用父类中的这个参数相加
            return result;
        }
    }

第二个减法类如下：

/// <summary>
    /// 减法类
    /// </summary>
    class Operationsub:Operation 
    {
        public override double GetResult()//重写父类中的运算方法
        {
            double result = 0;
            result = base.Numbera - base.Numberb1;//用父类中的这个参数相减
            return result;
        }
    }

第三个成法类如下：

/// <summary>
    /// 成法类
    /// </summary>
    class OperationMul:Operation 
    {
        public override double GetResult()//重写父类中的运算方法
        {
            double retult = 0;
            retult = base.Numbera * base.Numberb1;//用父类中的这个参数相成
            return retult;
        }
    }

第4个除法类如下：

/// <summary>
    /// 除法类
    /// </summary>
    class OperationDiv:Operation 
    {
        public override double GetResult()//重写父类中的运算方法
        {
            double result = 0;
            if (base.Numbera > 0)
            {
                result = base.Numbera / Numberb1;//用父类中的这个参数相除
            }
            return result;
        }
    }

现在这4个类都建好了，他们都继承自Operation运算类，但是现在怎么去用呢？那最重要的事情就要开始了，我们然后就要建一个简单工厂运算类，在这个类中我们去实列化过程，这就是工厂：
其实在这个工厂类里面，就是我们整个程序最容易变的地方，以后要是还要加更多的，我只要再加一个子类，在这个工厂类里面再一个判断，就行了，这样保证了，不论怎么变，我都不用去改计算的代码了！

工厂类如下：

 1  /// <summary>
 2     /// 工厂运算类
 3     /// </summary>
 4    public  class JianDanGongchang
 5     {
 6        public static Operation createoperate(string operate)
 7        {
 8            Operation oper = null;
 9 
10            switch (operate)
11            { 
12                case "+":
13                    oper = new jiafayunsan();//如果是“+”就调用加法类;
14                    break;
15                case "-":
16                    oper = new Operationsub();//如果是“-”就调用减法类;
17                    break;
18                case "*":
19                    oper = new OperationMul();//如果是“*”就调用成法类;
20                    break;
21                case "/":
22                    oper = new OperationDiv();//如果是“/”就调用除法类;
23                    break;
24            }
25            return oper;  
26        }
27     }

后台类写完了，然后我们就开始在前台调了，现在写好页面，新建一个aspx的页面，用JQUERY.POST异步的方式完成计算器，如下

<head runat="server">
    <title></title>
    <script src="Scripts/jquery-1.4.1-vsdoc.js" type="text/javascript"></script>
    <script type="text/javascript">
        $(function () {

            $("#buttons").click(function () {

                var number1 = document.getElementById("number1").value;//第一个运算数
                var number2 = document.getElementById("number2").value;//第二个运算数
                var yunsanfu = document.getElementById("Select1").value;//运算符

                //用Jquery.post方法提交
                $.post("Handler1.ashx", { numbera: number1, numberb: number2, yunsanfus: yunsanfu }, function (date) {
                    document.getElementById("count").value = date;


                })
            })

        })
    </script>
</head>
<body>
   <form id="form1" runat="server">
    <div>
        <input id="number1" type="text" name="name" value="" />
        <select id="Select1">
            <option value="+">+</option>
             <option value="-">-</option>
              <option value="*">*</option>
               <option value="/">/</option>
        </select>
        <input id="number2" type="text" name="name" value="" />
        <input id="buttons" type="button" vale="=" />
        <input id="count" type="text" name="name"  />
    </div>
   </form>
</body>
</html>

　页面写好了，JS的方法也写好了，然后再建一个ashx页面，在里面来调用简单运算工厂类，完成各种计算，代码如下：

 1  public class Handler1 : IHttpHandler
 2     {
 3 
 4         public void ProcessRequest(HttpContext context)
 5         {
 6             context.Response.ContentType = "text/plain";
 7 
 8             
 9             string numbera = context.Request.Form["numbera"];//第一个数字
10 
11             string numberb = context.Request.Form["numberb"];//第二个数字
12             string numberc = context.Request.Form["yunsanfus"]; //运算符
13 
14             Operation oper;
15             oper = JianDanGongchang.createoperate(numberc);//调用简单运算工厂类，传一个运算符，工厂类会帮你自己计算：
16 
17             oper.Numbera = Convert .ToDouble(numbera); //把一个参数传进来
18             oper.Numberb1 = Convert .ToDouble(numberb);//把第二个参数传进来
19 
20             double result = oper.GetResult(); //调用运算方法
21 
22             context.Response.Write(result); //返回运算回来的结果，回传给WebForm1.aspx页面。
23         }
24         
25         public bool IsReusable
26         {
27             get
28             {
29                 return false;
30             }
31         }
32     }

就这样，一个Jquery ajax加简单工厂的计算器就做完了，这里最重要的是学习简单工厂的设计模式！