1.意图

定义一个创建对象的接口，让子类决定实例化那一个类，使接口类型能够延迟到子类。

结构图

现在我们考虑一个下班回家做饭的过程。假定我们要设计煮饭的类支持煮饭的类型有稀饭和软饭两种方式，我们先不谈设计模式

public class cooking

{

　　public void CookingSort()

　　{

　　　　Console.Writeline("稀饭");

　　}

　　public void CookingHard()

　　{

　　　　Console.Writeline("软饭");

　　}

　　public void DoType(string Type)

　　{

　　　　case "soft"

　　　　　　CookingSort();

　　　　break;

　　　　case "hard"

　　　　　　CookingHard();

　　　　break;

　　　　default:

　　　　break;

　　}

}

 

这种方式显然不适合面向对象语言程序设计要求，如果我们要增加一种类型的那么我们就得改cooking类这就使得cooking变的不稳定；

分析以上的业务关系和事情结果和过程发现两种煮饭的方式完全不同所有不应该有联系，那么我们重这里分离出两个对象来。

public class CookingSoft

{

　　public void cooking_soft()

　　{

　　　　Console.WriteLine("煮饭");

　　}

}

public class COOKINGHARD

{

　　public void cooking_hard()

　　{

　　　　Console.writeLine("硬饭");

　　}

}

 

对该设计进行进一步抽象

结构图如下

public abstract class Cooking

{

　　public abstract void cook();

}

 

public class CookingSoft:Cooking

{

　　public voerrid void cook()

　　{

　　　　Console.writeline("稀饭");

　　}

}

 

public class CookingHard:Cooking

{

　　public voerrid void cook()

　　{

　　　　Console.writeline("硬饭");

　　}

}

现在我们在需要增加一种美味的大米饭需要做的事情是什么呢，只需在写一个class然后继承cooking类实现里面的方法不需要去改变原来已经写好的类

这样的设计很好的满足啦单一原则

那么我们如何去调用这段程序呢

我们经常会这样去写

CookingHard ch = new CookingHard();

ch.cook();

当我们需要做另外一种饭的时候就得改变上面这段代码这样的工作量是可想而知的

此时就需要对应用和实例类型的解耦

这就引入工厂模式

public class softFactor

{

　　public CookingSoft Creat()

　　{

　　　　return new CookingSoft();

　　}

}

public class hadFactor

{

　　public CookingHard Creat()

　　{

　　　　return new CookingHard ();

　　}

}

这两个工厂和具体的产品之间是平行的结构，并一一对应，并在它们的基础上抽象出一个公用的接口，结构图如下：

代码如下

public abstract class cookFactor

{

　　　　public abstract Cooking Create();

}

 

public class softFactor:cookFactor

{

　　　　public overrid  Cooking Create()

　　　　{

　　　　　　return new CookingSoft();

　　　　}

}

public class App

 {

 　　public static void Main(string[] args)

 　　{

　　　　　cookFactor factory = new softFactor();

 　　　　Log log = factory.Create();

 　　　　log.Create();

　　}

}

自此完成啦整个工厂模式的构建和代码分析过程