代码无错就是优？----简单工厂模式

   
  不识庐山真面目 
只缘身在此山中   
山重水复疑无路，柳暗花明又一村

简短
的两句诗 大概就可以概括我此刻学习的心情了吧！ 

开始大话设计模式这本书的第一章，时间并不长，但对于自己的写代码能力，真是得到了很深的认识，原来代码不是写出来了就行的，对于代码的要求我还差很多-------大话第一章 
简单工厂模式，用小例子一步一步由浅入深的告诉我代码中的一些学问，而这些就是我所欠缺的。 

比如开篇的例子，写一个简单的计算机程序
附加代码如下：
classProgram
{
static void Main(string[] args)
{
Console.Write("请输入数字A:"); //命名不规范
string A = Console.ReadLine();
Console.Write("请输入运算符号（+、-、*、/）");
string B = Console.ReadLine();
Console.Write("请输入数字C：");
string C = Console.ReadLine();
string D = "";
if (B =="+") //程序繁琐，这样写意味着每个条件都要判断一下，才能执行，
D =Convert.ToString(Convert.ToDouble (A) + Convert.ToDouble(C));
if (B == "-")
D =Convert.ToString(Convert.ToDouble(A) - Convert.ToDouble(C));
if (B == "*")
D =Convert.ToString(Convert.ToDouble(A) * Convert.ToDouble(C));
if (B == "/")
D =Convert.ToString(Convert.ToDouble(A) / Convert.ToDouble(C)); //如果除数为0就会报错，那该怎么办
Console.WriteLine("结果是：" + D);
}
}


  注：
  如果是我去写
我会这么写，但是这其中就有好多不规范的地方 
例如命名不规范，程序繁琐，等等！  这都是初学者的毛病吧！ 
代码写好了，但是没有考虑到他的扩展性 灵活性，复用性等等，这样的代码还真挺可怕！ 
此刻我也明白了耦合的含义，一个好的程序就是要低耦合，这样才容易维护和扩展吧！ 

 

第一章由浅入深的写，看到最后才理解了点什么是简单工厂模式，以及这样的好处！下面我就来一一的记录一下！

 
简单工厂模式   

简单工厂模式又称为静态工厂方法模式属于类的创建型模式
而它的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类的实例。
也就是生产你要创建的实体对象 。简单工厂模式实际上不属于23个GOF模式,但他可以作为工厂方法模式的一个引导.
我个人对此的理解：我觉的这就像是生活中的我们想定做某件衣服，于是我们去商店描述了我们的需求，然后商店把我们的需求交给工厂 
进而做出我们需要的衣服，这里面的商店就相当于我们的Clothes
类，我们的需求就是方法类，商家创建这样一个需求方法
，交给工厂，工厂就继承商家提供的方法类去做就可以。 也许你会认为就一件衣服有那么麻烦吗
又商家又工厂的，假如说定衣服的多了，中间就会出现各种各样的问题，例如衣服大小啦，颜色啦，等等，这种情况下简单工厂模式就出来了，我们可以很方便的去处理哪方面出现了问题，各司其职。这也就符合了低耦合的原则了吧  

在简单工厂模式中的一些概念  

 

工厂--------角色
简单工厂模式的核心，它负责实现创建所有实例的内部逻辑。工厂类可以被外界直接调用，创建所需的产品对象。
抽象产品----------角色
简单工厂模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。
具体产品---------角色
是简单工厂模式的创建目标，所有创建的对象都是充当这个角色的某个具体类的实例。
利用简单工厂模式的优点

工厂类是整个模式的关键.包含了必要的逻辑判断,根据外界给定的信息,决定究竟应该创建哪个具体类的对象.通过使用工厂类,外界可以从直接创建具体产品对象的尴尬局面摆脱出来,仅仅需要负责“消费”对象就可以了。而不必管这些对象究竟如何创建及如何组织的．明确了各自的职责和权利，有利于整个软件体系结构的优化。

                        缺点

由于工厂类集中了所有实例的创建逻辑，违反了高内聚责任分配原则，将全部创建逻辑集中到了一个工厂类中；它所能创建的类只能是事先考虑到的，如果需要添加新的类，则就需要改变工厂类了。
当系统中的具体产品类不断增多时候，可能会出现要求工厂类根据不同条件创建不同实例的需求．这种对条件的判断和对具体产品类型的判断交错在一起，很难避免模块功能的蔓延，对系统的维护和扩展非常不利；
这些缺点在工厂方法模式中得到了一定的克服。
使用范围   

工厂类负责创建的对象比较少；
客户只知道传入工厂类的参数，对于如何创建对象（逻辑）不关心；
由于简单工厂很容易违反高内聚责任分配原则，因此一般只在很简单的情况下应用。
专门定义一个类来负责创建其他类的实例,被创建的实例通常都具有共同的父类.
 
static void main(string[] args) //主函数中简单的调用
{
Operation oper;
oper =OperationFactory.createOperate("+");
oper.NumberA = 1;
oper.NumberB = 2;
double result = oper.GetResult();
Console.WriteLine(oper.GetResult());
}
}

public classOperation //主类中 获取数字A.B 和 结果
{
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;
}
}
classOperationAdd : Operation //加法
{
public override double GetResult()
{
double result = 0;
result= NumberA+NumberB ;
return result ;

}
}
classOperationSub : Operation //减法
{
public override double GetResult()
{
double result = 0;
result = NumberA - NumberB;
return result;
}

}
classOperationMul : Operation //乘法
{
public override double GetResult()
{
double result = 0;
result = NumberA * NumberB;
return result;
}
}
class OperationDiv:Operation //除法 继承了主运算类
{
public override double GetResult()
{
double result = 0;
if(NumberB == 0) // 写一个主类 也就是运算的数字和方法，然后再写每个方法的时候去继承重新写这些方法就可以了
thrownew Exception("除数不能为0");
result = NumberA / NumberB;
return result;
}

}

public classOperationFactory ///创建了一个工厂，用户已输入符号，工厂就会判断怎么计算了
{
public static OperationcreateOperate(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;
}
}
}


   上面的代码例子就是一个简单的工程模式
例子  ，在我们没有用简单工厂模式之前，如果说我要增加算法，那么我就需要修改添加一个此运算方法的类和相应的方法。如果我们要修改其中的计算功能，那么我们就要修改好多相关的选项，而此模式下，耦合性降低了，各司其职，想要添加算法
，添加一个类，和工厂中的一个分支即可，想要修改，也是相对对立的，这样的代码才能利于维护的扩展，和开篇的那个代码比起来就更加完善了。

这就是简单工厂模式的好处吧！ 
随着大话模式的继续学习，后续还会总结另外23和设计模式
交流学习！