MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

Java建造者模式与传统构造方式的对比分析

2024-01-171.1k 阅读

Java建造者模式与传统构造方式的基础概念

传统构造方式

在Java中，传统的对象创建方式主要依赖于类的构造函数。构造函数是类中的一种特殊方法，其名称与类名相同，用于在创建对象时对对象进行初始化操作。例如，我们创建一个简单的User类：

public class User {
    private String name;
    private int age;
    private String address;

    public User(String name, int age, String address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }

    // Getter和Setter方法
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}

使用传统构造方式创建User对象如下：

User user = new User("Alice", 30, "123 Wonderland");

这种方式简单直接，适用于对象属性较少且固定的情况。然而，当对象的属性较多，或者存在可选属性时，构造函数的参数列表会变得冗长且难以维护。例如，如果我们为User类添加更多的可选属性，如电话号码、电子邮件等：

public class User {
    private String name;
    private int age;
    private String address;
    private String phone;
    private String email;

    public User(String name, int age, String address, String phone, String email) {
        this.name = name;
        this.age = age;
        this.address = address;
        this.phone = phone;
        this.email = email;
    }

    // 省略Getter和Setter方法
}

创建对象时，即使某些属性不需要设置，也需要在构造函数中传入相应的值，这不仅繁琐，还容易出错。

建造者模式

建造者模式（Builder Pattern）是一种创建型设计模式，它将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。在建造者模式中，有以下几个关键角色：

  1. 产品（Product）：表示被构建的复杂对象。
  2. 抽象建造者（Builder）：定义创建产品各个部件的抽象接口。
  3. 具体建造者（ConcreteBuilder）：实现抽象建造者接口，负责构建产品的具体部件。
  4. 指挥者（Director）：负责安排复杂对象的构建顺序，调用具体建造者的方法来构建产品。

以建造一个Computer为例，Computer就是产品：

public class Computer {
    private String cpu;
    private String ram;
    private String hardDisk;

    public void setCpu(String cpu) {
        this.cpu = cpu;
    }

    public void setRam(String ram) {
        this.ram = ram;
    }

    public void setHardDisk(String hardDisk) {
        this.hardDisk = hardDisk;
    }

    @Override
    public String toString() {
        return "Computer{" +
                "cpu='" + cpu + '\'' +
                ", ram='" + ram + '\'' +
                ", hardDisk='" + hardDisk + '\'' +
                '}';
    }
}

抽象建造者接口：

public interface ComputerBuilder {
    void buildCPU();
    void buildRAM();
    void buildHardDisk();
    Computer getComputer();
}

具体建造者实现：

public class HighEndComputerBuilder implements ComputerBuilder {
    private Computer computer = new Computer();

    @Override
    public void buildCPU() {
        computer.setCpu("Intel i9");
    }

    @Override
    public void buildRAM() {
        computer.setRam("32GB DDR4");
    }

    @Override
    public void buildHardDisk() {
        computer.setHardDisk("1TB SSD");
    }

    @Override
    public Computer getComputer() {
        return computer;
    }
}

指挥者：

public class ComputerDirector {
    private ComputerBuilder computerBuilder;

    public ComputerDirector(ComputerBuilder computerBuilder) {
        this.computerBuilder = computerBuilder;
    }

    public Computer constructComputer() {
        computerBuilder.buildCPU();
        computerBuilder.buildRAM();
        computerBuilder.buildHardDisk();
        return computerBuilder.getComputer();
    }
}

使用建造者模式创建Computer对象：

ComputerBuilder highEndBuilder = new HighEndComputerBuilder();
ComputerDirector director = new ComputerDirector(highEndBuilder);
Computer highEndComputer = director.constructComputer();
System.out.println(highEndComputer);

建造者模式将复杂对象的构建过程分解为多个简单步骤，使得代码更易维护和扩展，并且可以根据不同的具体建造者创建出不同配置的产品。

可维护性对比

传统构造方式的可维护性问题

随着类的属性不断增加，传统构造方式面临着严重的可维护性挑战。如前面提到的User类，当属性增多时，构造函数的参数列表会变得很长，这不仅增加了调用构造函数时出错的概率，也使得代码阅读起来非常困难。例如：

public class ComplexUser {
    private String name;
    private int age;
    private String address;
    private String phone;
    private String email;
    private String occupation;
    private String hobby;
    private boolean isMarried;

    public ComplexUser(String name, int age, String address, String phone, String email, String occupation, String hobby, boolean isMarried) {
        this.name = name;
        this.age = age;
        this.address = address;
        this.phone = phone;
        this.email = email;
        this.occupation = occupation;
        this.hobby = hobby;
        this.isMarried = isMarried;
    }
}

创建ComplexUser对象时：

ComplexUser user = new ComplexUser("Bob", 25, "456 Elm St", "123 - 456 - 7890", "bob@example.com", "Engineer", "Reading", true);

如果需要修改构造函数的参数顺序或者添加新的属性，那么所有调用该构造函数的地方都需要进行相应的修改，这大大增加了维护成本。而且，由于构造函数参数过多，很难直观地看出每个参数的含义，尤其是对于一些可选参数。

建造者模式的可维护性优势

建造者模式通过将复杂对象的构建过程分解为多个独立的步骤，使得代码的可维护性大大提高。以Computer的构建为例，如果需要添加新的部件，如显卡，只需要在Computer类中添加相应的属性和设置方法，在ComputerBuilder接口中添加构建显卡的抽象方法，然后在具体的建造者类中实现该方法即可。对指挥者的代码几乎没有影响，调用方也只需要关注新的构建步骤。例如： 在Computer类中添加显卡属性：

public class Computer {
    private String cpu;
    private String ram;
    private String hardDisk;
    private String graphicsCard;

    public void setCpu(String cpu) {
        this.cpu = cpu;
    }

    public void setRam(String ram) {
        this.ram = ram;
    }

    public void setHardDisk(String hardDisk) {
        this.hardDisk = hardDisk;
    }

    public void setGraphicsCard(String graphicsCard) {
        this.graphicsCard = graphicsCard;
    }

    @Override
    public String toString() {
        return "Computer{" +
                "cpu='" + cpu + '\'' +
                ", ram='" + ram + '\'' +
                ", hardDisk='" + hardDisk + '\'' +
                ", graphicsCard='" + graphicsCard + '\'' +
                '}';
    }
}

在ComputerBuilder接口中添加构建显卡的方法：

public interface ComputerBuilder {
    void buildCPU();
    void buildRAM();
    void buildHardDisk();
    void buildGraphicsCard();
    Computer getComputer();
}

在具体建造者类中实现该方法：

public class HighEndComputerBuilder implements ComputerBuilder {
    private Computer computer = new Computer();

    @Override
    public void buildCPU() {
        computer.setCpu("Intel i9");
    }

    @Override
    public void buildRAM() {
        computer.setRam("32GB DDR4");
    }

    @Override
    public void buildHardDisk() {
        computer.setHardDisk("1TB SSD");
    }

    @Override
    public void buildGraphicsCard() {
        computer.setGraphicsCard("NVIDIA RTX 3080");
    }

    @Override
    public Computer getComputer() {
        return computer;
    }
}

指挥者代码基本无需修改：

public class ComputerDirector {
    private ComputerBuilder computerBuilder;

    public ComputerDirector(ComputerBuilder computerBuilder) {
        this.computerBuilder = computerBuilder;
    }

    public Computer constructComputer() {
        computerBuilder.buildCPU();
        computerBuilder.buildRAM();
        computerBuilder.buildHardDisk();
        computerBuilder.buildGraphicsCard();
        return computerBuilder.getComputer();
    }
}

使用建造者模式创建对象的代码也只需关注新的构建步骤：

ComputerBuilder highEndBuilder = new HighEndComputerBuilder();
ComputerDirector director = new ComputerDirector(highEndBuilder);
Computer highEndComputer = director.constructComputer();
System.out.println(highEndComputer);

这种方式使得代码的结构更加清晰，易于理解和维护。

可读性对比

传统构造方式的可读性挑战

传统构造方式在面对多参数构造函数时，可读性较差。由于参数列表中只是简单的数据类型和变量名，很难快速理解每个参数的含义和用途。例如：

public class Book {
    private String title;
    private String author;
    private int publishYear;
    private String isbn;
    private double price;
    private int pageCount;

    public Book(String title, String author, int publishYear, String isbn, double price, int pageCount) {
        this.title = title;
        this.author = author;
        this.publishYear = publishYear;
        this.isbn = isbn;
        this.price = price;
        this.pageCount = pageCount;
    }
}

创建Book对象：

Book book = new Book("Design Patterns", "Erich Gamma et al.", 1994, "0201633612", 39.99, 395);

对于不熟悉Book类构造函数参数顺序的开发者来说，很难一眼看出每个参数代表什么。如果参数顺序发生变化，那么阅读代码的难度会进一步增加。

建造者模式的可读性优势

建造者模式通过将对象的构建过程分解为多个具有明确语义的方法，大大提高了代码的可读性。以构建Car为例，假设Car有发动机、底盘、轮胎等部件： 产品Car类：

public class Car {
    private String engine;
    private String chassis;
    private String tires;

    public void setEngine(String engine) {
        this.engine = engine;
    }

    public void setChassis(String chassis) {
        this.chassis = chassis;
    }

    public void setTires(String tires) {
        this.tires = tires;
    }

    @Override
    public String toString() {
        return "Car{" +
                "engine='" + engine + '\'' +
                ", chassis='" + chassis + '\'' +
                ", tires='" + tires + '\'' +
                '}';
    }
}

抽象建造者接口：

public interface CarBuilder {
    void buildEngine();
    void buildChassis();
    void buildTires();
    Car getCar();
}

具体建造者实现：

public class SportsCarBuilder implements CarBuilder {
    private Car car = new Car();

    @Override
    public void buildEngine() {
        car.setEngine("High - performance V8");
    }

    @Override
    public void buildChassis() {
        car.setChassis("Lightweight carbon fiber");
    }

    @Override
    public void buildTires() {
        car.setTires("High - speed racing tires");
    }

    @Override
    public Car getCar() {
        return car;
    }
}

指挥者：

public class CarDirector {
    private CarBuilder carBuilder;

    public CarDirector(CarBuilder carBuilder) {
        this.carBuilder = carBuilder;
    }

    public Car constructCar() {
        carBuilder.buildEngine();
        carBuilder.buildChassis();
        carBuilder.buildTires();
        return carBuilder.getCar();
    }
}

使用建造者模式创建Car对象：

CarBuilder sportsCarBuilder = new SportsCarBuilder();
CarDirector director = new CarDirector(sportsCarBuilder);
Car sportsCar = director.constructCar();
System.out.println(sportsCar);

从代码中可以清晰地看到，buildEngine、buildChassis和buildTires等方法明确地表示了构建Car的各个步骤，使得代码的意图一目了然，大大提高了可读性。

灵活性对比

传统构造方式的灵活性局限

传统构造方式一旦定义好构造函数，对象的创建方式就相对固定。如果需要创建具有不同配置的对象，可能需要定义多个重载的构造函数。例如，对于前面的User类，如果我们需要创建一些具有部分默认属性的用户，可能需要这样定义构造函数：

public class User {
    private String name;
    private int age;
    private String address;
    private String phone;
    private String email;

    public User(String name, int age, String address, String phone, String email) {
        this.name = name;
        this.age = age;
        this.address = address;
        this.phone = phone;
        this.email = email;
    }

    public User(String name, int age, String address) {
        this.name = name;
        this.age = age;
        this.address = address;
        this.phone = "N/A";
        this.email = "N/A";
    }
}

然而，这种方式随着不同配置需求的增加，会导致构造函数数量急剧增多，代码变得臃肿且难以维护。而且，如果需要动态地改变对象的创建过程，传统构造方式很难满足需求。

建造者模式的灵活性优势

建造者模式提供了更高的灵活性。通过不同的具体建造者，可以创建出具有不同配置的产品。同时，指挥者可以根据需要灵活地调整构建步骤的顺序。例如，对于Computer的构建，我们可以有不同配置的具体建造者，如游戏电脑建造者、办公电脑建造者等。并且，如果需要改变构建顺序，只需要在指挥者中调整方法调用顺序即可。假设我们有一个OfficeComputerBuilder：

public class OfficeComputerBuilder implements ComputerBuilder {
    private Computer computer = new Computer();

    @Override
    public void buildCPU() {
        computer.setCpu("Intel i5");
    }

    @Override
    public void buildRAM() {
        computer.setRam("16GB DDR4");
    }

    @Override
    public void buildHardDisk() {
        computer.setHardDisk("512GB SSD");
    }

    @Override
    public Computer getComputer() {
        return computer;
    }
}

如果我们想先构建硬盘再构建内存，可以在指挥者中调整：

public class ComputerDirector {
    private ComputerBuilder computerBuilder;

    public ComputerDirector(ComputerBuilder computerBuilder) {
        this.computerBuilder = computerBuilder;
    }

    public Computer constructComputer() {
        computerBuilder.buildCPU();
        computerBuilder.buildHardDisk();
        computerBuilder.buildRAM();
        return computerBuilder.getComputer();
    }
}

这种灵活性使得建造者模式在面对复杂多变的对象创建需求时，能够更好地适应变化。

性能对比

传统构造方式的性能特点

传统构造方式在对象创建时，一次性完成所有属性的初始化。如果对象的属性较少且初始化操作简单，那么性能消耗相对较小。例如，对于一个简单的Point类：

public class Point {
    private int x;
    private int y;

    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }
}

创建Point对象时，只需要进行简单的赋值操作，性能开销较低。然而，当对象的属性较多且部分属性的初始化操作较为复杂时，传统构造方式可能会导致性能问题。例如，假设User类的address属性需要从数据库中查询获取，那么在构造函数中初始化address时会增加创建对象的时间开销。

建造者模式的性能考量

建造者模式在构建对象时，由于将构建过程分解为多个步骤，可能会引入一些额外的方法调用开销。但是，这种开销通常是非常小的，尤其是在现代JVM的优化下。而且，建造者模式可以根据需要延迟某些部件的构建，直到真正需要使用这些部件时才进行初始化。例如，在构建Computer时，如果graphicsCard在某些情况下可能不会被使用，那么可以在具体建造者的buildGraphicsCard方法中进行延迟初始化，只有在真正需要使用显卡相关功能时才进行初始化操作，从而提高整体性能。另外，建造者模式的灵活性使得可以根据不同的需求优化构建过程，比如对于一些性能敏感的应用场景，可以调整构建步骤的顺序以减少资源的浪费。

适用场景对比

传统构造方式适用场景

  1. 简单对象创建：当对象的属性较少且固定，不需要太多的灵活性时，传统构造方式是非常合适的。例如，一些简单的数据载体类，如前面提到的Point类，其属性只有x和y，使用传统构造方式可以简洁地创建对象。
  2. 对性能要求极高且对象创建过程简单：在一些对性能要求极高的场景中，如果对象的创建过程非常简单，如只涉及基本数据类型的赋值，传统构造方式由于没有额外的方法调用开销等，可以提供较好的性能。

建造者模式适用场景

  1. 复杂对象构建：当需要创建复杂对象，且对象的构建过程涉及多个步骤，每个步骤可能有不同的实现方式时，建造者模式非常适用。如前面提到的Computer、Car等复杂对象的构建。
  2. 对象有多种配置需求：如果需要创建具有不同配置的对象，通过不同的具体建造者可以轻松满足这一需求。例如，不同配置的电脑、不同款式的汽车等。
  3. 构建过程需要动态调整：当对象的构建过程可能需要根据不同的条件进行动态调整时，建造者模式可以通过指挥者灵活地改变构建步骤的顺序，以适应不同的需求。

代码复杂度对比

传统构造方式的代码复杂度

传统构造方式的代码复杂度主要体现在构造函数上。当对象的属性增多，尤其是存在可选属性时，为了满足不同的创建需求，可能需要定义多个重载的构造函数，这会使构造函数部分的代码变得复杂。例如，对于User类，如果有多个可选属性，为了提供不同的初始化方式，可能需要多个构造函数：

public class User {
    private String name;
    private int age;
    private String address;
    private String phone;
    private String email;

    public User(String name, int age) {
        this.name = name;
        this.age = age;
        this.address = "N/A";
        this.phone = "N/A";
        this.email = "N/A";
    }

    public User(String name, int age, String address) {
        this.name = name;
        this.age = age;
        this.address = address;
        this.phone = "N/A";
        this.email = "N/A";
    }

    public User(String name, int age, String address, String phone) {
        this.name = name;
        this.age = age;
        this.address = address;
        this.phone = phone;
        this.email = "N/A";
    }

    // 省略更多构造函数
}

这些构造函数之间可能存在大量的重复代码，增加了代码的维护成本和复杂度。

建造者模式的代码复杂度

建造者模式虽然涉及多个角色（产品、抽象建造者、具体建造者、指挥者），看起来代码结构相对复杂，但是每个角色的职责明确。产品类负责表示对象，抽象建造者定义构建接口，具体建造者实现构建细节，指挥者控制构建过程。这种清晰的职责划分使得代码更易于理解和维护。而且，随着对象构建过程的复杂程度增加，建造者模式的优势更加明显，它可以通过合理的分工和结构设计，将复杂的构建过程进行有效的管理，相比传统构造方式在面对复杂对象构建时，代码复杂度反而更低。例如，对于更复杂的Aircraft的构建，包含机身、机翼、发动机、航电系统等多个复杂部件，使用建造者模式可以将每个部件的构建和整体的构建过程清晰地分离，而如果使用传统构造方式，构造函数将变得极其复杂且难以维护。

综上所述，Java中的建造者模式和传统构造方式各有其特点和适用场景。在实际开发中，需要根据对象的复杂程度、灵活性需求、性能要求等多方面因素综合考虑，选择合适的对象创建方式，以实现高效、可维护且可读性强的代码。