Design patterns 工厂方法：创建者层次结构的需要_Design Patterns_Subclass_Factory Pattern

Design patterns 工厂方法：创建者层次结构的需要

design-patterns

Design patterns 工厂方法：创建者层次结构的需要,design-patterns,subclass,factory-pattern,Design Patterns,Subclass,Factory Pattern,我不熟悉设计模式。在进行GOF时，实现工厂模式的一种方法是创建对应于每个产品的创建者（工厂）的并行层次结构。为什么我们需要这种等级制度？它不会创建不必要的子类吗？有人可以给我一个例子，说明我们需要这种实现。如果您不想在使用它们的上下文中决定要创建什么对象，但想推迟它，那么您需要这种模式。您可以使用工厂模式将决策推迟到运行时下面是一个例子（有点过于简单，但我希望你能理解这一点）：您想要编写一个正在创建NumberObjects的程序，您想要一个简单的或复杂的程序。但是，您不想硬编码决定在程序

我不熟悉设计模式。在进行GOF时，实现工厂模式的一种方法是创建对应于每个产品的创建者（工厂）的并行层次结构。为什么我们需要这种等级制度？它不会创建不必要的子类吗？

有人可以给我一个例子，说明我们需要这种实现。

如果您不想在使用它们的上下文中决定要创建什么对象，但想推迟它，那么您需要这种模式。您可以使用工厂模式将决策推迟到运行时

下面是一个例子（有点过于简单，但我希望你能理解这一点）：

您想要编写一个正在创建

NumberObject

s的程序，您想要一个简单的或复杂的程序。但是，您不想硬编码决定在程序中使用哪种数字对象，而是希望根据程序的命令行参数来决定

首先，创建两个类

SimpleNumberObject

和

ComplexNumberObject

，这两个类都实现了类

NumberObject

，该类具有抽象方法

print（）

，并强制子类实现它。比如：

public class NumberObject {
    protected int number;
    public NumberObject(int number) {
        this.number = number;
    }
    abstract void print();
}

public class SimpleNumberObject extends NumberObject {
    public SimpleNumberObject(int number) {
        super(number);
    }        
    public void print() {
        System.out.println("My number is " + number);
    }
}

public class ComplexNumberObject() extends NumberObject {
    public SimpleNumberObject(int number) {
        super(number);
    }        
    public void print() {
        System.out.println("My number is " + number 
            + " and I can do a lot more complex stuff");
    }
}

然后使用方法

createNumber（）

创建抽象类

NumberFactory

，以及必须实现此方法的子类

SimpleNumberFactory

和

ComplexNumberFactory

，其中它们返回相应的NumberObject:

SimpleNumberFactory

SimpleNumberObject

和

ComplexNumberFactory

ComplexNumberObject

（我将跳过此处的实现，如果您需要了解，请告诉我，然后我也可以将其放入。）

然后，设计主类，如果要使用

SimpleNumberObject

或

ComplexNumberObject

，则在构造函数中进行设计

public class MainClass {

    private NumberFactory numberFactory;

    public MainClass(String arg) {
        if (arg != null && arg.equals("complex") {
            numberFactory = new ComplexNumberFactory();
        } else {
            numberFactory = new SimpleNumberFactory();
        }
    }

    public void printSomeNumber() {
        NumberObject number = numberFactory.createNumber();
        number.print();
    }

    public static void main(String[] args) {
        MainClass mainClass = new MainClass(args[0]);
        mainClass.printSomeNumber();
    }
}

因此，这里发生的事情是，根据命令行参数，它将创建SimpleNumberObjects或ComplexNumberObjects。您没有在代码中指定它，因此编译器无法判断将使用哪个对象，只是它实现了

NumberObject

public class MainClass {

    private NumberFactory numberFactory;

    public MainClass(String arg) {
        if (arg != null && arg.equals("complex") {
            numberFactory = new ComplexNumberFactory();
        } else {
            numberFactory = new SimpleNumberFactory();
        }
    }

    public void printSomeNumber() {
        NumberObject number = numberFactory.createNumber();
        number.print();
    }

    public static void main(String[] args) {
        MainClass mainClass = new MainClass(args[0]);
        mainClass.printSomeNumber();
    }
}

在工厂里，你把责任从

MainClass

如何创建一个数字上转移了出来。他们可以使用随机生成器生成NumberObject构造函数所需的整数，或某些迭代数。事实上，主类不需要关心，您将它解耦了一点

关于延迟决定创建什么对象：它不一定是命令行参数，但可以是不同的类、一些上下文信息或其他内容。基本上，如果您想在其他地方做出决策，当然，如果您想将对象的创建委托给工厂，则可以使用此模式

您是对的，有很多子类正在进行，这使得这种模式的类很重。实际上，你必须决定使用它是否有回报。如果要使用工厂创建对象，则无论如何都会有不同的对象子类，重要的是不要在程序的某一点上决定要创建哪个子类，然后你可以考虑使用它。

如果你不想在你使用的对象中创建你想要创建的对象，但是你想推迟它，你就需要这个模式。您可以使用工厂模式将决策推迟到运行时