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

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

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

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

工厂模式:

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();
        }
    }

对于John的回答，我有几点要补充如下:

抽象工厂是工厂中的工厂!

使用“Factory方法”(因为只有“Factory”是不明确的)，您可以生成特定接口的实现(Lemon、Orange等)——比如，IFruit。这个工厂可以被称为CitricFruitFactory。

但是现在您想要创建CitricFruitFactory无法创建的另一种水果。如果您在CitricFruitFactory中创建一个草莓，那么它的代码可能就没有意义了(草莓不是柠檬酸水果!)。

所以你可以创建一个名为RedFruitFactory的新工厂，生产草莓，覆盆子等。

就像John Feminella说的: 使用抽象工厂模式，您可以生成特定工厂接口的实现——例如，IFruitFactory。他们每个人都知道如何创造不同种类的水果。”

IFruitFactory的实现是CitricFruitFactory和RedFruitFactory!

使用Factory模式，您可以生成特定接口(例如，IFruit)的实现实例(Apple、Banana、Cherry等)。

使用抽象工厂模式，您可以为任何人提供他们自己的工厂提供一种方法。这使得您的仓库可以是IFruitFactory或IJuiceFactory，而不需要您的仓库了解任何关于水果或果汁的信息。

抽象工厂是创建相关对象的接口，而工厂方法是一种方法。抽象工厂采用工厂方法实现。

点击这里查看:http://www.allapplabs.com/java_design_patterns/abstract_factory_pattern.htm 似乎Factory方法使用一个特定的类(不是抽象类)作为基类，而抽象工厂则使用一个抽象类。此外，如果使用接口而不是抽象类，结果将是抽象工厂模式的不同实现。

:D

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

抽象工厂与工厂方法

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

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

如何实现

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

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

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

何时使用工厂方法模式

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

何时使用抽象工厂模式

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

例子:

抽象工厂实例1

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

例子2:

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

工厂方法示例:

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