了解工厂方法模式(Understanding the factory method pattern)

 我正在阅读有关工厂方法模式的内容。 
 
 我可以理解什么时候有一个工厂类，即StoreFactory#getStore() ，它返回一个基于某个运行时或其他状态的Store实现。 
 
 但是，从阅读（例如这个链接 ），似乎有一个人们创建抽象工厂类的一般模式，其他工厂类扩展到： 
 
 public abstract class AbstractFactory {
     public abstract Store getStore(int store);
 }

 public class StoreFactoryA extends AbstractFactory {
     public Store getStore(int Store) {
         if(Store == 1) { return new MyStoreImplA(); }
         if(Store == 2) { return new MyStoreImplB(); }
     }
 }

 public class StoreFactoryB extends AbstractFactory {
     public Store getStore(int Store) {
         if(Store == 1) { return new MyStoreImplC(); }
         if(Store == 2) { return new MyStoreImplD(); }
     }
 }

 public class Runner {
    public static void main(String[] args) {
        AbstractFactory storeFactory = new StoreFactoryA();
        Store myStore = storeFactory.getStore(1);
    }
 }
 
 我的例子是人为的，但模仿上述链接的模型。 
 
 这个实现对我来说似乎有点鸡蛋。 使用Factory Method模式消除了客户端代码指定类类型的需要，但现在客户端代码需要有选择地选择要使用的正确工厂，即StoreFactoryA ， StoreFactoryB ？ 
 
 在这里使用抽象类的原因是什么？ 

I'm reading about the Factory Method pattern. 
 
I can understand when there is a single factory class, i.e. StoreFactory#getStore(), that returns a Store implementation based on some runtime or other state. 
 
But, from reading (e.g. this link), there seems to be a general pattern of people creating an abstract factory class, to which other factory classes extend:
 
 public abstract class AbstractFactory {
     public abstract Store getStore(int store);
 }

 public class StoreFactoryA extends AbstractFactory {
     public Store getStore(int Store) {
         if(Store == 1) { return new MyStoreImplA(); }
         if(Store == 2) { return new MyStoreImplB(); }
     }
 }

 public class StoreFactoryB extends AbstractFactory {
     public Store getStore(int Store) {
         if(Store == 1) { return new MyStoreImplC(); }
         if(Store == 2) { return new MyStoreImplD(); }
     }
 }

 public class Runner {
    public static void main(String[] args) {
        AbstractFactory storeFactory = new StoreFactoryA();
        Store myStore = storeFactory.getStore(1);
    }
 }
 
My example is contrived, but models that of the aforementioned link.
 
This implementation seems kind of chicken-egg to me. Use the Factory Method pattern to eliminate the need for the client code to specify a class type, yet now the client code needs to selectively choose the correct factory to use, i.e. StoreFactoryA, StoreFactoryB?
 
What is the reasoning behind using the abstract class here?

原文：https://stackoverflow.com/questions/12293427