这些工厂的主要区别是什么时候你想用工厂做什么，什么时候你想使用它。

有时候，当你在做IOC(控制反转，例如构造函数注入)时，你知道你可以创建固体对象。如上面的水果示例所述，如果准备创建水果对象，可以使用简单的工厂模式。

但是很多时候，你不想创建实体对象，它们会在程序流的后面出现。但是配置告诉你你想在开始时使用什么样的工厂，而不是创建对象，你可以将从公共工厂类派生的工厂传递给IOC中的构造函数。

所以，我认为这也是关于对象的生命周期和创建。

基本的区别:

工厂:创建对象时不向客户端公开实例化逻辑。

工厂方法:定义用于创建对象的接口，但让子类决定实例化哪个类。Factory方法允许类延迟实例化到子类

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

AbstractFactory模式使用组合将创建对象的责任委托给另一个类，而Factory方法模式使用继承并依赖于派生类或子类来创建对象

来自oodesign的文章:

工厂类图:

例如:StaticFactory

 public class ShapeFactory {

   //use getShape method to get object of type shape 
   public static Shape getShape(String shapeType){
      if(shapeType == null){
         return null;
      }     
      if(shapeType.equalsIgnoreCase("CIRCLE")){
         return new Circle();

      } else if(shapeType.equalsIgnoreCase("RECTANGLE")){
         return new Rectangle();

      } else if(shapeType.equalsIgnoreCase("SQUARE")){
         return new Square();
      }

      return null;
   }
}

非静态工厂实现FactoryMethod的例子在这篇文章中可用:

设计模式:工厂vs工厂方法vs抽象工厂

何时使用:客户端只需要一个类，并不关心它得到的是哪个具体实现。

工厂方法类digaram:

何时使用:客户端不知道在运行时需要创建什么具体的类，而只是想获得一个可以完成这项工作的类。

来自dzone的抽象工厂类图

何时使用:当您的系统必须创建多个产品系列，或者您希望提供一个产品库而不公开实现细节时。

以上文章中的源代码示例非常有助于清楚地理解这些概念。

相关SE问题与代码示例:

工厂模式。什么时候使用工厂方法?

差异:

抽象工厂类通常使用工厂方法来实现，但它们也可以使用原型来实现 设计开始使用工厂方法(不太复杂，更可定制，子类激增)，然后向其他需要更多灵活性的创建模式(更灵活，更复杂)发展。 工厂方法通常在模板方法中调用。

其他有用的文章:

来自sourcemmaking的Factory_method

摘要工厂从sourcemmaking

来自journaldev的抽象工厂设计模式

此信息的来源:http://java.dzone.com/news/intro-design-patterns-abstract

抽象工厂与工厂方法

抽象工厂的方法被实现为工厂方法。抽象工厂模式和工厂方法模式都通过抽象类型和工厂将客户端系统与实际实现类解耦。 工厂方法通过继承创建对象，而抽象工厂通过组合创建对象。

抽象工厂模式由AbstractFactory、ConcreteFactory、AbstractProduct、ConcreteProduct和客户端组成。

如何实现

抽象工厂模式可以使用工厂方法模式、原型模式或单例模式来实现。ConcreteFactory对象可以作为一个单例对象实现，因为只需要一个ConcreteFactory对象实例。

工厂方法模式是抽象工厂模式的简化版本。工厂方法模式负责创建属于一个家族的产品，而抽象工厂模式处理多个产品家族。

工厂方法使用接口和抽象类将客户端与生成器类和生成的产品解耦。摘要工厂有一个生成器，它是几个工厂方法的容器，以及将客户端与生成器和产品分离的接口。

何时使用工厂方法模式

当需要将客户端与其使用的特定产品解耦时，请使用工厂方法模式。使用Factory方法可以减轻客户端创建和配置产品实例的责任。

何时使用抽象工厂模式

当客户端必须从产品类中解耦时，使用抽象工厂模式。 特别适用于程序配置和修改。抽象工厂模式还可以强制约束哪些类必须与其他类一起使用。建造新的混凝土工厂可能需要做很多工作。

例子:

抽象工厂实例1

本规范适用于制备不同类型面食的圆盘 在面食机中有一个抽象工厂，每个特定的圆盘都是一个工厂。 所有的工厂(意大利面食机磁盘)从抽象工厂继承他们的属性。 每个单独的磁盘都包含如何制作意大利面，而意大利面机没有。

例子2:

冲压设备对应于抽象工厂，因为它是一个 用于创建抽象产品对象的操作接口。 模具对应混凝土工厂，因为他们创造一个混凝土产品。 每个部件类别(罩、门等)都对应于抽象产品。 具体部件(即99凯美瑞的司机侧门)对应 混凝土制品。

工厂方法示例:

玩具公司对应于创造者，因为它可以使用工厂来创建产品对象。制造特定类型玩具(马或汽车)的玩具公司的部门对应于ConcreteCreator。

抽象工厂模式

Provide an interface for creating families of related or dependent objects without specifying their concrete classes. The Abstract Factory pattern is very similar to the Factory Method pattern. One difference between the two is that with the Abstract Factory pattern, a class delegates the responsibility of object instantiation to another object via composition whereas the Factory Method pattern uses inheritance and relies on a subclass to handle the desired object instantiation. Actually, the delegated object frequently uses factory methods to perform the instantiation!

工厂模式

工厂模式就是这样的例子 创建型模式 创建模式抽象了 对象实例化过程。他们 隐藏对象是如何创建和帮助的 使整个系统相互独立 它的对象是如何创建的 组成。 类创建模式的重点 使用继承来决定 对象进行实例化 工厂方法 对象创建模式所关注的 实例化的委托 到另一个对象 抽象工厂

参考: 工厂vs抽象工厂

延伸John Feminella的回答:

Apple, Banana, Cherry实现了FruitFactory，它有一个叫做Create的方法，它只负责创建Apple, Banana或Cherry。Factory方法就完成了。

现在，你想用你的水果创建一个特殊的沙拉，这就是你的抽象工厂。抽象工厂知道如何用苹果、香蕉和樱桃制作你的特殊沙拉。

public class Apple implements Fruit, FruitFactory {
    public Fruit Create() {
        // Apple creation logic goes here
    }
}

public class Banana implements Fruit, FruitFactory {
    public Fruit Create() {
        // Banana creation logic goes here
    }
}

public class Cherry implements Fruit, FruitFactory {
    public Fruit Create() {
        // Cherry creation logic goes here
    }
}

public class SpecialSalad implements Salad, SaladFactory {
    public static Salad Create(FruitFactory[] fruits) {
        // loop through the factory and create the fruits.
        // then you're ready to cut and slice your fruits 
        // to create your special salad.
    }
}

根据定义，我们可以拖出两者的差异:

工厂:接口用于创建对象，但子类决定实例化哪个类。对象的创建是在需要时完成的。

抽象工厂:抽象工厂模式充当一个超级工厂，它可以创建其他工厂。在抽象工厂模式中，接口负责创建一组相关对象或依赖对象，而不指定它们的具体类。

所以，在上面的定义中，我们可以强调一个特定的区别。也就是说，工厂模式负责创建对象，抽象工厂负责创建一组相关的对象;显然都是通过一个接口。

工厂模式:

public interface IFactory{
  void VehicleType(string n);
 }

 public class Scooter : IFactory{
  public void VehicleType(string n){
   Console.WriteLine("Vehicle type: " + n);
  }
 }

 public class Bike : IFactory{
  public void VehicleType(string n) {
  Console.WriteLine("Vehicle type: " + n);
  }
 }

 public interface IVehicleFactory{
  IFactory GetVehicleType(string Vehicle);
 }

 public class ConcreteVehicleFactory : IVehicleFactory{
 public IFactory GetVehicleType(string Vehicle){
   switch (Vehicle){
    case "Scooter":
     return new Scooter();
    case "Bike":
     return new Bike();
    default:
    return new Scooter();
  }
 }

 class Program{
  static void Main(string[] args){
   IVehicleFactory factory = new ConcreteVehicleFactory();
   IFactory scooter = factory.GetVehicleType("Scooter");
   scooter.VehicleType("Scooter");

   IFactory bike = factory.GetVehicleType("Bike");
   bike.VehicleType("Bike");

   Console.ReadKey();
 }
}

工厂模式:

interface IVehicleFactory{
 IBike GetBike();
 IScooter GetScooter();
}

class HondaFactory : IVehicleFactory{
     public IBike GetBike(){
            return new FZS();
     }
     public IScooter GetScooter(){
            return new FZscooter();
     }
 }
class HeroFactory: IVehicleFactory{
      public IBike GetBike(){
            return new Pulsur();
     }
      public IScooter GetScooter(){
            return new PulsurScooter();
     }
}

interface IBike
    {
        string Name();
    }
interface IScooter
    {
        string Name();
    }

class FZS:IBike{
   public string Name(){
     return "FZS";
   }
}
class Pulsur:IBike{
   public string Name(){
     return "Pulsur";
   }
}

class FZscooter:IScooter {
  public string Name(){
     return "FZscooter";
   }
}

class PulsurScooter:IScooter{
  public string Name(){
     return "PulsurScooter";
   }
}

enum MANUFACTURERS
{
    HONDA,
    HERO
}

class VehicleTypeCheck{
        IBike bike;
        IScooter scooter;
        IVehicleFactory factory;
        MANUFACTURERS manu;

        public VehicleTypeCheck(MANUFACTURERS m){
            manu = m;
        }

        public void CheckProducts()
        {
            switch (manu){
                case MANUFACTURERS.HONDA:
                    factory = new HondaFactory();
                    break;
                case MANUFACTURERS.HERO:
                    factory = new HeroFactory();
                    break;
            }

      Console.WriteLine("Bike: " + factory.GetBike().Name() + "\nScooter: " +      factory.GetScooter().Name());
        }
  }

class Program
    {
        static void Main(string[] args)
        {
            VehicleTypeCheck chk = new VehicleTypeCheck(MANUFACTURERS.HONDA);
            chk.CheckProducts();

            chk= new VehicleTypeCheck(MANUFACTURERS.HERO);
            chk.CheckProducts();

            Console.Read();
        }
    }