简单工厂模式----工厂方法的结合使用

　　　单一职责原则

　　　　定义：不要存在多于一个导致类变更的原因。通俗的说，即一个类只负责一项职责。 

　　　里氏替换原则

　　　　定义：所有引用基类的地方必须能透明地使用其子类的对象。

　　　依赖倒置原则

　　　　定义：高层模块不应该依赖低层模块，二者都应该依赖其抽象；抽象不应该依赖细节；细节应该依赖抽象。

　　　接口隔离原则

　　　　定义:客户端不应该依赖它不需要的接口；一个类对另一个类的依赖应该建立在最小的接口上。 

　　　迪米特法则

　　　　定义：一个对象应该对其他对象保持最少的了解。

　　　开闭原则

　　　　定义：一个软件实体如类、模块和函数应该对扩展开放，对修改关闭。

　　　　简单工厂模式呢,个人觉得他就是封装了改变,其他的设计模式都没有体现出来;

　　就比如现在我们要做一个简单的支持加减乘除的软件,我们来看第一版软件

　　

        /// <summary>
        ///一个简单的操作类
        /// </summary>
        /// <param name="s"> 操作符</param>
        /// <param name="d1">被操作数</param>
        /// <param name="d2">操作数</param>
        /// <returns></returns>
       static double count(string s,double d1,double d2)
        {
            double count = 0;
            switch (s)
            {
                case "+": count = d1 + d2; break;
                case "-": count=d1-d2;　　 break;
                case "*": count = d1 * d2; break;
                case "/": count = d1 / d2; break;
            }
            return count;
        }

　　这样我们就可以实现一个简单的计算的功能了,可是如果,我们需要添加一个求平方的功能呢?

　　　　那我们就需要在count方法中添加对应的case和后面对应的方法,想想这样子的不好的地方

　　　　　　不符合,对修改关闭,对拓展开放这个原则.也就是不便于拓展

　　　　　　既然他们都有一个计算的方法,那我们就可以提取出一个父类/接口就可以了

　　　　　　　　但是在这里声明一个接口很明显不是一个好的选择,因为这样会多做一步,所以在这里我们选择 父类的方法来实现

　　

        /// <summary>
        ///一个简单的操作类
        /// </summary>
        /// <param name="s"> 操作符</param>
        /// <param name="d1">被操作数</param>
        /// <param name="d2">操作数</param>
        /// <returns></returns>
        static double count(string s, double d1, double d2)
        {
            oo io = null;
            switch (s)
            {
                case "+": io=new Add(d1,d2); break;
                case "-": io = new subtract(d1, d2); break;
            }
            return io.count();
        }

        abstract class oo//抽象基类
        {
            public virtual double d1 { get; set; }
            public virtual double d2 { get; set; }
            public abstract double count();
            public oo(double d1,double d2)
            {
                this.d1 = d1;
                this.d2 = d2;
            }
            
        }
        class Add:oo//加法类
        {
            public Add(double d1, double d2) : base(d1, d2) { }
            public override double count()
            {
                return this.d1 + this.d2;
            }
        }
        class subtract : oo//减法类
        {
            public subtract(double d1, double d2) : base(d1, d2) { }
            public override double count()
            {
                return this.d1 - this.d2;
            }
        }

　　　　

 　　但是向上面那样写,会发现我们有回到了问题的原点,解决的办法就是使用工厂方法

　　　　那么什么是工厂方法呢? 既然是工厂,那么就一定有流水线,那么流水线是干嘛的呢?流水线当然是用来生产产品的,

　　　　　　当然具体生产什么产品,得看是什么流水线了,接下来对我们的方法进行改造

　　　　

        interface IOp
        {
            oo Opeator(double d1,double d2);//方法一个具体的操作对象
        }
        class AddFactory : IOp
        {

            public oo Opeator(double d1,double d2)
            {
                return new Add(d1, d2);
            }
        }
        class SubtractFactory : IOp
        {
            public oo Opeator(double d1, double d2)
            {
                return new subtract(d1, d2);
            }
        }

　　使用的时候就可以直接创建对应的工厂来返回相应的对象