设计引导---不要再盲目的new了！你要学着针对接口编程！（具体方法，Factory，Abstract Factory）

>>> 創業先鋒眾人拾柴火焰高 >>>

簡體傳統

　应园友提议，本篇博将帮助大家解决“针对接口编程”这一疑惑。而我所讲的例子将从上一篇设计引导---一个鸭子游戏引发的设计（多态，继承，抽象，接口，策略者模式）的案例中，延伸下来，让大家更容易阅读。

　　上篇中有提到鸭子游戏。现在，假设那个鸭子游戏火了，火遍全球~~~公司大佬们因为这个游戏赚的盆满钵满，像愤怒的小鸟一样：

　　现在公司下一步计划！打造一个以游戏中鸭子个体为模型的玩具工厂！o(∩_∩)o

就像愤怒的小鸟毛绒玩具一样~用这个比喻，大家应该会很简单的想象模拟场景。

　　下面来进入正题！渐进式描述，让大家有个进阶的梯度(￣︶￣)↗ 。

　　（oh fuck 下面这些内容是我第二次写！第一次写的没保存，IE死掉了！内牛满面。。。。）

　　看看玩具订单：

 1        public DuckToy OrderToy()
 2        {
 3            DuckToy ducktoy = new DuckToy();
 4 
 5            ducktoy.Prepare();//准备
 6            ducktoy.Create();//开始制作
 7            ducktoy.Package();//包装
 8            ducktoy.freight();//运送
 9 
10            return ducktoy;
11        }

这个方法很简单，你仅仅只要关注new DuckToy()，针对一种鸭子玩具的生产！你还需要更多的鸭子模型！仅仅一种玩具，不足以打开市场！

下面改进一下：

 1        public DuckToy OrderToy(string type)
 2        {
 3            DuckToy ducktoy;
 4 
 5             if (type.Equals("MallarDuck"))
 6            {
 7                ducktoy = new MallarDuck();//绿头鸭
 8            }
 9            else if (type.Equals("RedHaedDuck"))
10            {
11                ducktoy = new RedHaedDuck();//红头鸭
12            }
13            else if (type.Equals("DecoyDuck"))
14            {
15                ducktoy = new DecoyDuck();//诱饵鸭
16            }
17 
18            //还有更多的鸭子模型哦~    
19           //...
20 
21            ducktoy.Prepare();//准备
22            
23            ducktoy.Package();//包装
24            ducktoy.freight();//运送
25 
26            return ducktoy;
27        }

看到我最后实例化的注释就知道，这根本不行，这种方式不是我们想要的。维护极度烦人。

把创建对象提取出来也许会不错，可以把这个新对象称作“工厂”呢:

 1    public class SimpleToyFactory
 2     {
 3        public DuckToy CreateToy(string type)
 4        {
 5            DuckToy ducktoy = null;
 6            if (type.Equals("MallarDuck"))
 7            {
 8                ducktoy = new MallarDuck();//绿头鸭
 9            }
10            else if (type.Equals("RedHaedDuck"))
11            {
12                ducktoy = new RedHaedDuck();//红头鸭
13            }
14            else if (type.Equals("DecoyDuck"))
15            {
16                ducktoy = new DecoyDuck();//诱饵鸭
17            }
18 
19            return ducktoy;
20        }
21     }

就把代码搬了一个地方，原来的问题还是没有解决，繁琐的问题依然存在。但这个移动也不能说完全没好处，目前这个类只有一个OrderToy方法是它的客户，以后还可以有很多的功能类，来用到这个“工厂”，比如获取价钱或者描述，或者玩具列表....这个提取出来正是因为我们要把它从客户的代码中删除。

　　这个类也可以用静态方法来定义，常称为静态工厂，方便是方便，就是不能再继承来改变方法的行为了。

　　好了，现在“工厂”方法做出来了，要重写一下DuckToysStore了，OrderToy这个是DuckToysStore的，看你看完整的代码，你能理解的：

 1  public class DuckToyStore
 2     {
 3        SimpleToyFactory factory;
 4        public DuckToyStore(SimpleToyFactory factory)
 5        {
 6            this.factory = factory;
 7        }
 8 
 9        public DuckToy OrderToy(string type)
10        {
11            DuckToy ducktoy;
12 
13            ducktoy = factory.CreateToy(type);
14          
15            ducktoy.Prepare();//准备
16            
17            ducktoy.Package();//包装
18            ducktoy.freight();//运送
19 
20            return ducktoy;
21        }
22     }

当然，这只是OrderToy部分代码，这看起来舒服多了~代码中已经看不到new了，这从某种程度上来说，我们完成了一部分接口编程的知识了！

这个“工厂“已经做完了，就提取了一下代码，我们可以把这个方法当作一种编程习惯，对，它不是工厂模式，它仅仅是一种较好的习惯。

　　正因为有这个的存在，许多开发人员都会误认为这就是工厂模式了。在下面我会介绍工厂模式并给予区别！

看个图来轻松一下，理下刚才的关系：

通过简单工厂的介绍，还没有完哦，工厂继续：

　　玩具店，开的不错，有很多加盟商了，随之而来的是地域文化差异，不同的地方，玩具销量也不同，比如在海边，小鸭玩具就不能再做毛绒了，那销量肯定不好，小鸭游泳圈，小鸭船，会比毛绒玩具卖的好o(∩_∩)o ，更多想象只局限你思维啦~

　　针对这个问题，玩具加盟商需要有自己的玩具类型，它们可以使用游戏公司的小鸭模型（专利化，一般没有授权的，模仿小鸭模型会被追究的），但可以用不同的材质，一般的是毛绒，但是在海边，塑料的才好卖，还可以有气球样式...。

继续移植简单工厂的做法：

1             BeiJingStyleFactory bjFactory = new BeiJingStyleFactory();
2             DuckToyStore bjStore = new DuckToyStore(bjFactory);
3             bjStore.OrderToy("MallarDuck");

这段代码意思是：有一个北京样式商店，它有自己的工厂，我要下订单的话，只要让DuckToyStore构造一个北京样式商店，来处理我想要的”MallarDuck“，我就能得到一款，正在北京商店卖的“MallarDuck”。

当然，海南的样式（HainanStyleFactory）商店，也可以这么做，代码差不多。

就是这代码差不多！让各地商家都捆绑在了你的创建模型上面了，你管不了他们做自己的特色，现在要做个框架。让各地的玩具厂商，做自己的特色。

玩具变幻无穷~先来理一下关系。

　　玩具厂商，就好比一个工厂，他生产各种各样的玩具，但他想生产别人的专利玩具模型，就需要加盟，获得持有专利公司的授权，这个很容易理解吧，然后他才可以名正言顺的生产“鸭子玩具”。

　　一个玩具工厂，他可以生产各种各样的玩具，就意味着他可以自己制造自己的产品，他对于生产的玩具，有自己的理念，有自己的方法和创新:　　　　　　

每种玩具，可以是相同的样式，但需要不同的颜色去装饰，以及配上什么装饰品，这是玩具厂商的事，比如给专利“鸭子模型”配备一个小背包？装饰一朵小花？小花的颜色设置，这些细节问题，专利公司他管理不了这么多，更多的制作权，还是在玩具工厂，玩具公司！

　　公司需要一个自主的创建玩具的方法！现在重新设计一下，做个更有弹性的设计：

 1    public abstract class DuckToyStore
 2     {
 3 
 4        public DuckToy OrderToy(string type)
 5        {
 6            DuckToy ducktoy;
 7 
 8            //ducktoy = factory.CreateToy(type);
 9            ducktoy = CreateToy(type);//这里没有new哦
10 
11            ducktoy.Prepare();//准备
12            ducktoy.Create();//开始制作
13            ducktoy.Package();//包装
14            ducktoy.freight();//运送
15 
16            return ducktoy;
17        }
18 
19        public abstract DuckToy CreateToy(string type);//授予子类去new
20     }

把这个做成一个抽象类，让继承的子类去实现CreateToy（制造玩具），看个图：

OrderToy()现在已经被分离出来了，它不知道哪些实际的具体类参与进来了，专业点，这就是解耦（decouple）

来具体实现一下：

实现之前，先做好商店内的具体模型：

//为了方便，放一起  
  class BeiJingStyleMallarDuck:DuckToy
    {
        public BeiJingStyleMallarDuck() {
            Console.WriteLine("初始化..");//传统毛绒玩具
            name = "北京绿头鸭";
            material = "传统毛绒玩具";
            color = "白色";
        }
        
    }

    class BeiJingStyleRedHeadDuck : DuckToy
    {
        public BeiJingStyleRedHeadDuck() {
            Console.WriteLine("初始化...");
            name = "北京红头鸭";
            material = "传统毛绒玩具";
            color = "绿色";
        }
    }

    class HainanStyleMallarDuck : DuckToy
    {
        public HainanStyleMallarDuck() {
            Console.WriteLine("初始化...");//靠近海边的用塑料防水材质
            name = "海南绿头鸭";
            material = "防水橡胶材质";
            color = "白色";
        }
    }

    class HainanStyleRedHeadDuck:DuckToy{
        public HainanStyleRedHeadDuck() {
            Console.WriteLine("初始化...");
            name = "海南红头鸭";
            material = "防水橡胶材质";
            color = "绿色";
        }
    }

现在可以做商店啦，虽然代码有点多，但是都是相同的概念，在看代码的时候，要构造好这些相互之间的关系：

 1         class BeiJingStyleStore: DuckToyStore 
 2         {//北京
 3           public override DuckToy  CreateToy(string item)
 4             {
 5                 if (item.Equals("MallarDuck"))
 6                 {
 7                     return new BeiJingStyleMallarDuck();
 8                 }
 9                 else if (item.Equals("RedHeadDuck"))
10                 {
11                     return new BeiJingStyleRedHeadDuck();
12                 }
13                 else
14                 {
15                     return null;
16                 }
17             }
18         }
19         class HaiNanStyleStore:DuckToyStore
20         {//海南
21             public override DuckToy CreateToy(string item)
22             {
23                 if (item.Equals("MallarDuck"))
24                 {
25                     return new HainanStyleMallarDuck();
26                 }
27                 else if (item.Equals("RedHeadDuck"))
28                 {
29                     return new HainanStyleRedHeadDuck();
30                 }
31                 else
32                 {
33                     return null;
34                 }
35             }
36         }

是不是很期待程序的结果？？Main登场┈━═☆：

1 //亲测可用哦o(∩_∩) 
2        static void Main(string[] args)
3         {
4             DuckToyStore bjStyleStore = new BeiJingStyleStore();//创建商店
5             bjStyleStore.OrderToy("MallarDuck");//下单
6 
7         }

代码有没有觉得很是简单呢？

bjStyleStore.OrderToy("MallarDuck"); --- 这段代码的参数也许会引起不好的争论，为了方便，我就写个String了，用个Enum来集合玩具样式是个不错的方法。

结果：

有点感触吗？例子都讲完了~ 看下详细的定义，现在你的头脑里应该会有两个结构关系，像这样：

一个创建类，一个产品类，工厂模式通过子类决定该创建的对象是什么，来达到将对象创建的过程封装的目的。

正式定义，工厂方法模式：

　　定义了一个创建对象的接口，但由子类决定要实列化的类是哪一个。

　　工厂方法让类把实例化推迟到子类。

工厂方法让子类决定实列化哪一个类，不需要知道实际创建的产品是哪一个。

选择了使用哪个子类，自然就决定了实际创建的产品是什么。现在可以随意的扩展你的工厂了，比如加一个上海的商店，自定义自己的玩具模型~都很轻松啦。

现在说说简单工厂和工厂方法，大家现在应该觉得，子类看起来很像简单工厂。

简单工厂把全部的事情，在一个地方都处理完了，而工厂方法却是创建一个框架，让子类决定要如何实现。

简单工厂可以将对象封装起来，但是简单工厂不具备工厂方法的弹性，因为简单工厂不能改变正在创建的产品。

例子的前部分从依赖具体对象，讲到依赖接口实例化对象，具体设计原则如下：

要依赖抽象，不要依赖具体

对于这一原则，怎么去判断，提及一个正式的名称去区别：依赖倒置原则。

什么是依赖？比如简单工厂~典型的依赖。

看看倒置：

倒置指的是和一般面向对象设计的思考方式完全相反。不好理解？嘿，绝对让你懂。

问：“现在你需要实现一个上海玩具店，你第一件事情想到什么？”

小花：“我要自己创建自己的风格样式玩具！比如：咧嘴的绿头鸭，愤怒的绿头鸭...”

问：“现在你的思维正在顺势从顶端思考，现在倒置一下，先考虑具体的模型玩具！”

小花：“我的小鸭玩具们，都要共享一个鸭子接口。”

问：“Yes，你想到一个抽象的鸭子接口，那么你再想想，如何设计玩具店？”

小花：“噢！我现在要关心的是玩具店的样式，而不是咧嘴的绿头鸭（具体的模型）。”

---总结：

　　你要做具体的模型，就必须靠一个工厂将这些具体模型抽象出来，然后各种具体的模型都会依赖一个抽象（鸭子接口），而你的玩具商店也会依赖这个抽象接口。

现在不仅仅倒置了一个商店依赖具体类的设计，而且也倒置了你的思考方式，下面有几点指导意见，帮助你避免在面向对象设计中违反依赖倒置原则：

变量不能持有具体类的引用，就像订单方法代码中，你看不到new一样。
不要让派生自具体类，要派生就派生抽象类abstract
不要覆盖基类中已实现的方法，除非你要覆盖的是比较特殊的一部分代码。

抽象工厂模式：

　　提供一个接口，用于创建相关或依赖对象的家族，而不需要明确置顶具体类。

注意这个抽象工厂模式和工厂方法不是一个概念，他们有不同的定义，再次提醒，他们不是同一个模式，但是又有很多交织在一起的枝节。

抽象工厂的方法经常以工厂方法的方式实现。抽象工厂的任务是定义一个负责创建一组产品的接口。

这个接口内的每个方法都负责创建一个具体的产品，还没完，然后再利用实现抽象工厂的子类来提供这些具体的做法。

也就是说，抽象工厂中利用工厂方法实现生产的具体做法。

来看看抽象工厂的代码吧，毕竟看了这么多知识了，比较比较代码也是能促进学习的。

我偷懒了，只完成了一个实例，目的很简单，想让大家看到抽象工厂的实现：

先看具体DuckToy，修改版：

 1    public abstract class DuckToy
 2     {
 3        //都是封装好的类型
 4        public FactroyName name;
 5        public FactroyMaterial material;
 6        public FactroyColor color;
 7 
 8        public abstract void Prepare(); //准备工作 现在是抽象方法
 9 
10        public void Create()
11         {
12             Console.WriteLine("正在生产...(预计30分钟)");
13         }
14 
15        public void Package()
16         {
17             Console.WriteLine("正在包装...(预计2分钟)");
18         }
19        public void Freight()
20         {
21             Console.WriteLine("正在运送...");
22         }
23 
24     }

再看封装类型的字段：

//开始会难以理解。 - -。既然是工厂，那么工厂就有统一的标准，不允许用户自行修改  
  public class FactroyMaterial
    {
        public FactroyMaterial()//为了简单，我在这直接用构造函数，其实你还可以自己定义自己的方法，下面的几个类都可以自己扩展  
      {
            Console.WriteLine("材料：毛绒");
        }
    }
    public class FactroyName
    {
        public FactroyName()
        {
            Console.WriteLine("名字：北京绿头鸭");
        }
    }
    public class FactroyColor
    {
        public FactroyColor()
        {
            Console.WriteLine("颜色：白色");
        }
    }

上面的代码是北京商店特有的，为什么这么说？看看这个：

 1     public class BJToyStroeFactory: ToysFactory
 2     {//北京商店特有的材料 名字 颜色
 3         public FactroyMaterial ReturnMaterial() 
 4         {
 5             return new FactroyMaterial();
 6         }
 7         public FactroyName ReturnName()
 8         {
 9             return new FactroyName();
10         }
11         public FactroyColor ReturnColor()
12         {
13             return new FactroyColor();
14         }
15     }

现在又出来一个ToysFactory，接着就是抽象工厂的接口啦：

   public interface ToysFactory//通用接口方法
    {
        FactroyMaterial ReturnMaterial();
        FactroyName ReturnName();
        FactroyColor ReturnColor();
    }

底层都写好了，好好好，现在要看具体的鸭子模型！

 1     class BeiJingStyleMallarDuck:DuckToy
 2     {
 3         ToysFactory toysfactory;
 4         public BeiJingStyleMallarDuck(ToysFactory tosyfactory) 
 5         {
 6             this.toysfactory = tosyfactory;
 7         }
 8        public override void  Prepare()//实现
 9         {
10             Console.WriteLine("开始准备...");
11             material = toysfactory.ReturnMaterial();
12             name = toysfactory.ReturnName();
13             color = toysfactory.ReturnColor();
14         }  
15     }

继承下来的封装类型，通过Prepare，从工厂获取实物的信息。别着急，我们再向上一层。

 1 //重写了 BeiJingStyleStore   
 2      class BeiJingStyleStore: DuckToyStore 
 3         {
 4             DuckToy toy = null;
 5             ToysFactory toysfactory = new BJToyStroeFactory();
 6           public override DuckToy  CreateToy(string item)
 7             {
 8                 if (item.Equals("MallarDuck"))
 9                 {
10                     toy = new BeiJingStyleMallarDuck(toysfactory);
11                     return toy;
12                 }//偷懒了~~~~就写一个toy
13                 else
14                 {
15                     return null;
16                 }
17             }
18         }

都改了这么多了，看看Main要改什么吗？

1         static void Main(string[] args)
2         {
3             DuckToyStore bjStyleStore = new BeiJingStyleStore();
4             bjStyleStore.OrderToy("MallarDuck");
5         }
6 //什么都没改^_^