Java 生成器模式精度

我目前正在开发生成器模式。有一件事我不明白，那就是。比如说，我想创建计算机、笔记本电脑和台式机。我应该创建一个

ComputerBuilder

，根据传递给它的参数使用不同的过程，还是应该创建一个

LaptopBuilder

和

DesktopBuilder

？我在网上的代码示例中都看到过。Wikipedia在其pizza示例中使用了第二种方法。对我来说，这看起来更像工厂的模式，但我可以使用一些外部光线。谢谢

创建一个抽象生成器，并将其扩展到两个具体的生成器子类。这就把逻辑抽象出来了

下面是一些示例代码。在这段代码中，抽象类中定义了三个标准方法。扩展类可以选择实现哪一个。最后，所有抽象类将实现抽象方法并返回一台计算机

public abstract class Builder {

    public void doSomethingA() {};
    public void doSomethingB() {};
    public void doSomethingC() {};
    public abstract Computer returnComputer();
}

现在，LaptopBuilder类扩展了这个抽象类，并拥有自己的两个方法版本：

public class LaptopBuilder {

    private Computer computer;

    public LaptopBuilder(Computer computer) {
        this.computer = computer;
    }

    public void doSomethingA() {
        System.out.println("Laptop Method A");
    }

    public void doSomethingB() {
        System.out.println("Laptop Method B");
    }

    public Computer returnComputer() {
        return computer;
    }
}

public class DesktopBuilder {

    private Computer computer;

    public DesktopBuilder(Computer computer) {
        this.computer = computer;
    }

    public void doSomethingB() {
        System.out.println("Desktop Method B");
    }

    public void doSomethingC() {
        System.out.println("Desktop Method C");
    }

    public Computer returnComputer() {
        return computer;
    }
}

最后，DesktopBuilder类扩展了抽象类，并有自己的两个方法版本：

public class LaptopBuilder {

    private Computer computer;

    public LaptopBuilder(Computer computer) {
        this.computer = computer;
    }

    public void doSomethingA() {
        System.out.println("Laptop Method A");
    }

    public void doSomethingB() {
        System.out.println("Laptop Method B");
    }

    public Computer returnComputer() {
        return computer;
    }
}

public class DesktopBuilder {

    private Computer computer;

    public DesktopBuilder(Computer computer) {
        this.computer = computer;
    }

    public void doSomethingB() {
        System.out.println("Desktop Method B");
    }

    public void doSomethingC() {
        System.out.println("Desktop Method C");
    }

    public Computer returnComputer() {
        return computer;
    }
}

现在只需要创建一个director抽象类，以及一个台式机和笔记本电脑的具体director：

public abstract class Director {
    public abstract Computer build(Builder builder);
}

public class LaptopDirector extends Director {
    public Computer build(Builder builder) {
        builder.doSomethingA();
        builder.doSomethingB();
        return builder.returnComputer();
    }
}

public class DesktopDirector extends Director {
    public Computer build(Builder builder) {
        builder.doSomethingB();
        builder.doSomethingC();
        return builder.returnComputer();
    }
}

最后，在您的客户机中，只需创建您的计算机，创建相关的生成器，创建相关的控制器并调用build方法

---

编辑：这篇文章也可能有价值：

创建一个抽象生成器，并将其扩展到两个具体的生成器子类。这就把逻辑抽象出来了

下面是一些示例代码。在这段代码中，抽象类中定义了三个标准方法。扩展类可以选择实现哪一个。最后，所有抽象类将实现抽象方法并返回一台计算机

public abstract class Builder {

    public void doSomethingA() {};
    public void doSomethingB() {};
    public void doSomethingC() {};
    public abstract Computer returnComputer();
}

现在，LaptopBuilder类扩展了这个抽象类，并拥有自己的两个方法版本：

public class LaptopBuilder {

    private Computer computer;

    public LaptopBuilder(Computer computer) {
        this.computer = computer;
    }

    public void doSomethingA() {
        System.out.println("Laptop Method A");
    }

    public void doSomethingB() {
        System.out.println("Laptop Method B");
    }

    public Computer returnComputer() {
        return computer;
    }
}

public class DesktopBuilder {

    private Computer computer;

    public DesktopBuilder(Computer computer) {
        this.computer = computer;
    }

    public void doSomethingB() {
        System.out.println("Desktop Method B");
    }

    public void doSomethingC() {
        System.out.println("Desktop Method C");
    }

    public Computer returnComputer() {
        return computer;
    }
}

最后，DesktopBuilder类扩展了抽象类，并有自己的两个方法版本：

public class LaptopBuilder {

    private Computer computer;

    public LaptopBuilder(Computer computer) {
        this.computer = computer;
    }

    public void doSomethingA() {
        System.out.println("Laptop Method A");
    }

    public void doSomethingB() {
        System.out.println("Laptop Method B");
    }

    public Computer returnComputer() {
        return computer;
    }
}

public class DesktopBuilder {

    private Computer computer;

    public DesktopBuilder(Computer computer) {
        this.computer = computer;
    }

    public void doSomethingB() {
        System.out.println("Desktop Method B");
    }

    public void doSomethingC() {
        System.out.println("Desktop Method C");
    }

    public Computer returnComputer() {
        return computer;
    }
}

现在只需要创建一个director抽象类，以及一个台式机和笔记本电脑的具体director：

public abstract class Director {
    public abstract Computer build(Builder builder);
}

public class LaptopDirector extends Director {
    public Computer build(Builder builder) {
        builder.doSomethingA();
        builder.doSomethingB();
        return builder.returnComputer();
    }
}

public class DesktopDirector extends Director {
    public Computer build(Builder builder) {
        builder.doSomethingB();
        builder.doSomethingC();
        return builder.returnComputer();
    }
}

最后，在您的客户机中，只需创建您的计算机，创建相关的生成器，创建相关的控制器并调用build方法

---

编辑：这篇文章可能也很有价值：

这不是一种工厂方法吗？据我所知，这就是构建者模式。我今年才开始研究它们，但我几乎直接从Tony Bevis的“设计模式要点”中选取了这个例子。你的例子实际上很好。它是一个构建器，因为两个

builder

类做不同的事情。出于某种原因，我一直无法理解这一点，直到我在GOF书中看到一个示例，其中开发人员有一个公共

doSomething（）

函数，然后调用了私有

doThing（）

。这让我真正理解了内部逻辑的概念，不同的构建者之间的逻辑是不同的。对我来说，维基百科的例子仍然是一个非常糟糕的例子，它没有显示建设者可以做什么。@mm2703：我对这方面的内容进行了一次测试，我经常发现不同的网站使用不同版本的设计模式，其中一些例子通常是明显错误的（即工厂方法、抽象工厂和简单工厂之间的区别）。这不是工厂方法吗？据我所知，这是构建器模式。我今年才开始研究它们，但我几乎直接从Tony Bevis的“设计模式要点”中选取了这个例子。您的示例实际上很好。它是一个构建器，因为两个

builder

类都做不同的事情。出于某种原因，我无法理解这一点，直到我在GOF书中看到一个示例，其中开发人员有一个公共

doSomething（）

函数，然后称为私有

doThing（）

。这让我真正掌握了内部逻辑的概念，不同的构建者之间的逻辑是不同的。对我来说，维基百科的例子仍然是一个非常糟糕的例子，没有说明构建者可以做什么。@mm2703：我即将对这方面进行考试，我经常发现不同的网站使用不同版本的设计模式，其中一些例子往往明显错误（即工厂方法、抽象工厂和简单工厂之间的差异）。