我认为我们可以通过查看Java8示例代码来理解这两者之间的区别:

  interface Something{}

  interface OneWhoCanProvideSomething {
     Something getSomething();
  }

  interface OneWhoCanProvideCreatorsOfSomething{
     OneWhoCanProvideSomething getCreator();
  }


public class AbstractFactoryExample {

    public static void main(String[] args) {
        //I need something
        //Let's create one
        Something something = new Something() {};

        //Or ask someone (FACTORY pattern)
        OneWhoCanProvideSomething oneWhoCanProvideSomethingOfTypeA = () -> null;
        OneWhoCanProvideSomething oneWhoCanProvideSomethingOfTypeB = () -> null;

        //Or ask someone who knows soemone who can create something (ABSTRACT FACTORY pattern)
        OneWhoCanProvideCreatorsOfSomething oneWhoCanProvideCreatorsOfSomething = () -> null;

        //Same thing, but you don't need to write you own interfaces
        Supplier<Something> supplierOfSomething = () -> null;
        Supplier<Supplier<Something>> supplierOfSupplier = () -> null;
    }

}

现在的问题是你应该使用哪种创造方式以及为什么: 第一种方式(没有模式，只是普通的构造函数):自己创建不是一个好主意，你必须做所有的工作，你的客户端代码绑定到特定的实现。

第二种方式(使用Factory模式):为您提供了可以传递任何类型的实现的好处，这些实现可以基于某些条件(可能是传递给创建方法的参数)提供不同类型的东西。

第三种方法(使用抽象工厂模式):这为您提供了更多的灵活性。您可以根据某些条件(可能是传递的参数)找到不同类型的创建者。

请注意，您总是可以通过将两个条件组合在一起来摆脱工厂模式(这稍微增加了代码的复杂性和耦合)，我想这就是为什么我们很少看到抽象工厂模式的实际用例。

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

:D

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

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

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

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

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

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

IFruitFactory的实现是CitricFruitFactory和RedFruitFactory!

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

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

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

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

工厂模式:

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

抽象工厂模式

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抽象工厂

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