工厂方法和抽象工厂的区别

抽象工厂是针对的一系列的产品的创建，工厂方法是针对的单个产品的创建。

工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。

工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。

具体一点：抽象工厂就像工厂，而工厂方法则像是工厂中一种产品生产线。

工厂方法创建一般只有一个方法，创建一种产品。

　　抽象工厂一般有多个方法，创建一系列产品。

　　目的不一样

　　工厂方法创建 "一种" 产品，他的着重点在于"怎么创建"，也就是说如果你开发，你的大量代码很可能围绕着这种产品的构造，初始化这些细节上面。也因为如此，类似的产品之间有很多可以复用的特征，所以会和模版方法相随。

　　抽象工厂需要创建一些列产品，着重点在于"创建哪些"产品上，也就是说，如果你开发，你的主要任务是划分不同差异的产品线，并且尽量保持每条产品线接口一致，从而可以从同一个抽象工厂继承。

　　一、简单工厂

　　简单工厂模式中工厂为具体工厂，产品为抽象产品，由工厂实例创建产品实例。

　　二、工厂方法

　　工厂方法中有抽象的工厂类，一种抽象的产品类，而工厂类中仅创建此抽象产品类的实例，具体产品实例由具体的工厂类创建。

　　三、抽象工厂

　　抽象工厂创建多类产品，可将这些产品理解为一套相关的产品，由工厂在创建时一起创建，每类产品有不同的实例。实践中一般会用反射来创建工厂的实例，配合配置文件或依赖注入容器来避免创建不同产品时还需要修改客户端代码，即符合“修改封闭，扩展开放原则”，一点拙见，欢迎指正。

　　以下转自terryLee的博客：

　　概述

　　在软件系统中，经常面临着“一系列相互依赖的对象”的创建工作;同时由于需求的变化，往往存在着更多系列对象的创建工作。如何应对这种变化?如何绕过常规的对象的创建方法(new)，提供一种“封装机制”来避免客户程序和这种“多系列具体对象创建工作”的紧耦合?这就是我们要说的抽象工厂模式。

　　意图

　　提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

　　模型图

　　逻辑模型：

　　

　　物理模型：

　　

 

 

using System;

using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 抽象工厂
{
    class Program
    {
        static void Main(string[] args)
        {
            //这是具体的客户提的要求
            //ModernFacilitieFactory modern = new ModernFacilitieFactory();
            ////销售人员就是把客户需求带到工厂生产
            //GameManager g = new GameManager(modern);
            //g.BUildGameFactilites();

            //g.Run();

            TestCar testcar = new TestCar();
            baomacarFactory baoma = new baomacarFactory();
            testcar.BuildContext(baoma);
            testcar.testcarstart();
            testcar.testcarstop();
            testcar.testcarTurn();
            Console.Read();
        }
    }
   
    #region 抽象工厂模式
    /*
    /// <summary>
    /// 工厂抽象，这里面放了很多产品的模型，包括，道路抽象模型，跑道抽象模型，丛林抽象模型
    /// </summary>
  public  abstract class FactoryFacilities
    {
      public abstract Road BuildRoad();
      public abstract RunWay BuildRunWay();
      public abstract jungle BuildJungle();
    }
    /// <summary>
    /// 这是产品的抽象，道路
    /// </summary>
  public abstract class Road
    {
     
     public abstract void SpeakName();

    }
    /// <summary>
    /// 这是产品的抽象，跑到
    /// </summary>
  public abstract class RunWay
  {
     
      public abstract void SpeakName();
  }
    /// <summary>
    /// 这是产品的抽象，丛林
    /// </summary>
  public abstract class jungle
    {
     
        public abstract void SpeakName();
    }
  /// <summary>
  /// 这是具体的产品，现在化的道路，还是山路
  /// </summary>
  public  class ModernRoad:Road
  {

     

      public override void SpeakName()
      {
          Console.WriteLine("hi,my name is ModernRoad");
          //throw new NotImplementedException();
      }
  }
    /// <summary>
    /// 这是具体的产品，现在跑到，如滑雪跑道还是赛车跑道
    /// </summary>
  public class ModernRunWay:RunWay
  {

    

      public override void SpeakName()
      {
          Console.WriteLine("hi,my name is ModernRunWay");
      }
  }
    /// <summary>
    /// 这是具体产品，这是路旁的丛林还是其他丛林
    /// </summary>
  public class Modernjungle:jungle
  {

    

      public override void SpeakName()
      {
          Console.WriteLine("hi,my name is ModernRunWay");
      }
  }
    /// <summary>
    /// 这是继承抽象工厂，具提就是来创建这些指定的产品模型，可以出售
    /// </summary>
  public class ModernFacilitieFactory : FactoryFacilities
  {
      public override Road BuildRoad()
      {
          return new ModernRoad();
          //throw new NotImplementedException();
      }

      public override RunWay BuildRunWay()
      {
          return new ModernRunWay();
          //throw new NotImplementedException();
      }

      public override jungle BuildJungle()
      {
          return new  Modernjungle();
         // throw new NotImplementedException();
      }
  }
    /// <summary>
    /// 客户程序，这是个中间人，产品销售人员，如何从购买到使用的过程
    /// </summary>
    class GameManager
    {
        RunWay runway;
        jungle jungle;
        Road road;
        FactoryFacilities factoryfactilites;
        public GameManager(FactoryFacilities factoryfactilites )
        {
            this.factoryfactilites = factoryfactilites;
        }
       public  void BUildGameFactilites()
        {
             road = factoryfactilites.BuildRoad();
             jungle = factoryfactilites.BuildJungle();
             runway = factoryfactilites.BuildRunWay();
        }
       public void Run() {//不依赖具体的实现，依赖抽象类
          // road.Create();
           road.SpeakName();
           jungle.SpeakName();
           runway.SpeakName();
       }
    }   */
#endregion
    #region 工厂方法是每个产品都有一个抽象的模型，
    //跟抽象工厂是有区别的。工厂创建一种产品
    //，抽象工厂创建的是一组产品，是一个产品系列
    //。这里要注意的是“系列”的意思，也就是说，抽象工厂创建出的一组产品是成套的。
//当你发现，有一个接口可以有多种实现的时候，可以考虑使用工厂方法来创建实例。
//当你返现，有一组接口可以有多种实现方案的时候，可以考虑使用抽象工厂创建实例组。
    public  class TestCar
    {
        AbstractCar car;
       public  void BuildContext(FactoryCar factoryCar) {

            car = factoryCar.BuildCar();
        }
       public void testcarstart()
       {
           car.Start();
       }
       public void testcarstop()
       {
           car.Stop();
       }
       public void testcarTurn()
       {
           car.Turn();
       }
    }
    public abstract class FactoryCar
    {
      public   abstract AbstractCar BuildCar();
    }

    public class baomacarFactory : FactoryCar
    {
        public override AbstractCar BuildCar()
        {
            return new baoma();
        }
    }
    public abstract class AbstractCar
    {
       public abstract void Start();
       public abstract void Stop();
        public abstract void Turn();
    
    }
    public class baoma : AbstractCar
    {

        public override void Start()
        {
            Console.WriteLine("宝马启动");
        }

        public override void Stop()
        {
            Console.WriteLine("宝马Stop");
        }

        public override void Turn()
        {
            Console.WriteLine("宝马Turn");
        }
    }
    
    #endregion



}