抽象工厂模式（abstract)创建型模式

（一）简单工厂模式？

       现在的学习是面向对象面向接口的，但是执行时的操作需要实例化后的对象。随着我们需要的类的增加，我们就需要把这些共同的东西提取出来，放在一个抽象类中，让这些子类来继承抽象类。当我们调用具体的类时，需要首先实例化它们，而实例化必须要针对具体的类。如果直接实例化，则破坏了面向接口的原则，实例化一个具体的类就要根据父类把所有的子类选择一遍才可以实例化，这样的运算时间就大大增多。这时我们就需要有一个地方来供我们选择要实例化哪个类，而不需要我们知道怎么创建和调用类的，这就是简单工厂模式（Simple Factory Pattern ）。通俗的说就是有一个专门的类来负责创建实例的过程。

 

简单工厂模式的图形表示：

       首先这个模式有三个角色：

1、工厂角色：核心部分，负责实现创建所有实例的内部逻辑（选择分支），被外界调用的接口，创建所需的对象。

2、抽象类角色：所要创建的类的抽象父类，描述类所有实例所共有的公共接口。可以是抽象类也可以是接口。

3、具体类角色：所要创建的具体实例对象。它们拥有共同的父类。

     

 

 

简单工厂模式的应用以及代码实现

   

     在某个炎热的夏天，我们的学校突然来了一群新伙伴，那就是一批自动售货机，分布在学校的每一个角落，包括我们的五楼电梯口。当你投入硬币取出一瓶冰凉的饮料时，有没有想过我们可以把它写成一个简单工厂模式呢？至少去年的夏天还没有学设计模式的我不会。

     当一个人想要喝里面的饮料时，他自己是不会做饮料或者是冰镇的，这说明人这个对象不用自己去创建各种饮料的对象；每个人都有每个人的爱好，来到售货机前，只要投入钱自己点按钮就可以了。这个时候我们就抽象出一些对象的类。例如要买饮料的人就是一个类、各种饮料抽象成为一个饮料类、每种饮料包括（美年达、雪碧、奶咖）之类的就是具体的饮料对象。uml类图如下： 

     

     

 

     我们首先写这个抽象的类，饮料类

//抽象出的一个父类角色
public abstract class Drink
{
    public abstract string DrinkShow();
}

   

 

     接着是一些具体的饮料子类，它们有共同的父类饮料类。有共同的行为和属性。

 

//具体角色
    class 美年达:Drink
    {
        //获取一瓶美年达
        public override string DrinkShow()
        {
             return "你选择的是美年达";
        }
    }
   class 雪碧:Drink
   {
       //获取一瓶雪碧
       public override string DrinkShow()
       {
           return "您选择的是雪碧";
       }
   }
   class 可口可乐:Drink
   {
       //获取一瓶可口可乐
       public override string DrinkShow()
       {
           return "您选择的是可口可乐";
       }
   }

     然后建立一个自动售货机的工厂来出饮料：

 

//现在建立一个自动售货机工厂类
  public class DrinkFactory
  {
      public static Drink createDrink(string type)
      {
          Drink dri=null ;
          switch (type )
          {
              case "美年达":
                  dri = new 美年达();
                  break;
              case "雪碧":
                  dri = new 雪碧();
                  break;
              case "可口可乐":
                  dri = new 可口可乐();
                  break;
          }
          return dri;
      }
  }

     最后建立测试客户端，就是主函数main

 

static void Main(string[] args)
       {
           try
           {
               //实例化各种饮料
               Drink 美年达 = DrinkFactory.createDrink("美年达");
               Drink 雪碧 = DrinkFactory.createDrink("雪碧");
               Drink 可口可乐 = DrinkFactory.createDrink("可口可乐");
               //获取饮料
               if (美年达 != null)
               {
                   Console.WriteLine(美年达.DrinkShow());
               }
               if (雪碧 != null)
               {
                   Console .WriteLine ( 雪碧.DrinkShow());
               }
               if (可口可乐 != null)
               {
                  Console .WriteLine(可口可乐.DrinkShow());
               }
           }
           catch(Exception ex)
           {
               Console.WriteLine("您输入有错：" + ex.Message);
           }
       }

     输出结果如下：

    

 

(二)抽象工厂模式（abstract)创建型模式 c#简单例子

适用于玩家用户数play1、play2....有变化，而行为move、jum无变化时

玩家playone的行为：向左移动和向上跳跃

玩家playtwo的行为：向右移动和向下跳跃

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace adapterpattern
{
    public partial class abstractForm : Form
    {
        public abstractForm()
        {
            InitializeComponent();
        }

        private void btnDisplay_Click(object sender, EventArgs e)
        {
            playFactory pf1 = new playone();//隐藏行为move和jump.
            playWorld p1 = new playWorld(pf1);//行为向左移动和向上跳跃
            this.listBox1.Items.Add(p1.createPlay());
            playWorld p2 = new playWorld(new playtwo());//行为向右移动和向下跳跃
            this.listBox1.Items.Add(p2.createPlay());
        }

    }
    public class playWorld//实体工厂和抽象工厂的交接
    {
        imove move;
        ijump jump;
        public playWorld(playFactory pp)
        {
            this.move = pp.move();
            this.jump = pp.jump();
        }
        public string createPlay()
        {
            move.move();
            jump.jump();
            return move.movestring + jump.jumpstring;

        }

    }
    public abstract class playFactory//抽象工厂
    {
        public abstract imove move();
        public abstract ijump jump();

    }
    public class playone : playFactory//抽象工厂实例1
    {

        public override imove move()
        {
            return new leftmove();
        }

        public override ijump jump()
        {
            return new topJump();
        }
    }
    public class playtwo : playFactory//抽象工厂实例2
    {


        public override imove move()
        {
            return new rightmove();
        }

        public override ijump jump()
        {
            return new downJump();
        }
    }
    public abstract class imove//抽象行为imove
    {
        public string movestring;
        public abstract void move();
    }
    public abstract class ijump//抽象行为jump
    {
        public string jumpstring;
        public abstract void jump();
    }
    public class leftmove : imove//move行为实例1
    {

        public override void move()
        {
            movestring = "左移动";
        }
    }
    public class rightmove : imove//move行为实例2
    {
        public override void move()
        {
            movestring = "右移动";
        }
    }
    public class topJump : ijump//jump行为实例1
    {
        public override void jump()
        {
            jumpstring = "向上跳";
        }
    }
    public class downJump : ijump//jump行为实例2
    {
        public override void jump()
        {
            jumpstring = "向下跳";
        }
    }
}

当需要增加新玩家时，只要再增加一个继承playfacotry的类，其他都不需要改动

 新玩家行为：向左移动和向下跳跃

 

public class newplay:playFactory//新增加玩家：向左移动和向下跳跃
    {
        public override imove move()
        {
            return new leftmove();
        }

        public override ijump jump()
        {
            return new downJump();
        }
    }

最后在客户端新增

            playWorld newp = new playWorld(new newplay());
            this.listBox1 .Items .Add (newp .createPlay ());