十年JAVA搬砖路—— 建造者模式（Builder Pattern）

￡神魔★判官ぃ 2023-10-13 23:07 92阅读 0赞

### 定义： ###

建造者模式（Builder Pattern）是一种创建型设计模式，用于将对象的构建过程与其表示分离。它允许逐步构建复杂对象，同时保持灵活性和可读性。

### 常见例子： ###

public class Person {
        private final String name;
        private final int age;
        private final String address;
         private Person(String name, int age, String address) {
            this.name = name;
            this.age = age;
            this.address = address;
        }
         public String getName() {
            return name;
        }
         public int getAge() {
            return age;
        }
         public String getAddress() {
            return address;
        }
         public static class PersonBuilder {
            private String name;
            private int age;
            private String address;
             public PersonBuilder setName(String name) {
                this.name = name;
                return this;
            }
             public PersonBuilder setAge(int age) {
                this.age = age;
                return this;
            }
             public PersonBuilder setAddress(String address) {
                this.address = address;
                return this;
            }
             public Person build() {
                return new Person(name, age, address);
            }
        }
    }
    //具体使用
    Person person = new Person.PersonBuilder()
        .setName("John")
        .setAge(30)
        .setAddress("123 Main St")
        .build();

### 优点： ###

1.  在对象的构造和表示之间提供明确的分离。  
    2.允许逐步构建复杂的对象，使代码更具可读性和可维护性。
2.  提供设置对象不同属性的灵活性，而无需多个构造函数或重载方法。
3.  确保对象在使用前已完全构造，避免创建不完整或不一致的对象。
4.  允许创建不可变对象，提供线程安全并防止意外修改。

### 缺点： ###

1.  需要实现单独的构建器类，这可能会增加代码库的复杂性。
2.  对于具有几个属性的简单对象，构建器模式可能不是必需的，因为它可能会引入不必要的开销。
3.  构建器模式可能会导致项目中类和文件的数量增加，这可能会使代码库更难导航

### 使用场景： ###

1.  创建具有多个可选参数的对象：通过建造者模式，可以避免使用多个构造函数或方法来处理不同参数组合的情况，使代码更加清晰和易于维护。
2.  创建不可变对象：通过使用建造者模式，可以确保构建完成后的对象不可变，即对象的状态无法更改。这可以提高对象的安全性和线程安全性。
3.  创建具有一致构建过程的对象：建造者模式允许我们定义一个统一的构建过程，确保所有必要的步骤都按照标准化的方式执行。
4.  创建具有不同表示的对象：建造者模式可以用于根据相同的构建过程创建具有不同表示或配置的对象。这在需要创建不同变体的对象时非常有用，而无需重复构建逻辑。