工厂方法模式与组合(Factory Method pattern vs composition)

 从关于工厂方法模式的GoF章节： 
 
 
 
 定义创建对象的接口，但让子类决定实例化哪个类 。 工厂方法让类将实例化推迟到子类。 
 
 
 这个想法是让子类决定实例化哪个类，并且GoF实现这个想法，是在超类中提供一个抽象方法，该子类需要重写，从而提供它们自己的实例化逻辑。 
 
 我不明白的是，为什么使用抽象方法实现它，而不是使用工厂的类成员。 我会解释。 
 
 这是GoF的方式： 
 
public abstract class Creator {
    public void doStuff() {
        Product product = createProduct();
        /* etc. */
    }

    public abstract Product createProduct();
}
 
 用法： 
 
    MyCreator myCreator = new Creator() {
        @Override
        public Product createProduct() {
            return new MyProduct();
        }
    }

    myCreator.doStuff();
 
 但是为什么要打扰子类等呢？ 我建议这种方法： 
 
public class Creator {
    private Factory factory;

    /* constructor */
    public Creator(Factory factory) {
        this.factory = factory;
    }

    public void doStuff() {
        Product product = factory.createProduct();
        /* etc. */
    }
}
 
 这就是你使用它的方式： 
 
    MyFactory myFactory = new MyFactory();
    Creator creator = new Creator(myFactory);
    creator.doStuff();
 
 那么GoF的方法有什么好处？ 为什么不把工厂组成为Creator类而不是用抽象方法表达它呢？ 

From GoF chapter about the Factory Method pattern:
 
 
 
Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.
 
 
The idea is to let subclasses decided which class to instantiate, and GoF's implementation of the idea, is to provide an abstract method in the superclass, that subclasses need to override, and thus providing their own instantiation logic.
 
What I don't understand is, why implementing it using an abstract method, and not using a class member which is the factory. I'll explain.
 
This is the GoF way:
 
public abstract class Creator {
    public void doStuff() {
        Product product = createProduct();
        /* etc. */
    }

    public abstract Product createProduct();
}
 
Usage:
 
    MyCreator myCreator = new Creator() {
        @Override
        public Product createProduct() {
            return new MyProduct();
        }
    }

    myCreator.doStuff();
 
But why bother with the subclassing, etc.? I suggest this approach:
 
public class Creator {
    private Factory factory;

    /* constructor */
    public Creator(Factory factory) {
        this.factory = factory;
    }

    public void doStuff() {
        Product product = factory.createProduct();
        /* etc. */
    }
}
 
And this is how you use it:
 
    MyFactory myFactory = new MyFactory();
    Creator creator = new Creator(myFactory);
    creator.doStuff();
 
So what is the benefit in GoF's approach? Why not composing the Factory into the Creator class instead of expressing it using an abstract method?

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