建造者模式 使用场景 示例 java

建造者模式是一种创建型设计模式，它允许你创建复杂对象的不同部分并将它们组装成最终的对象。通常使用建造者模式来创建那些包含多个组成部分的对象，这些组成部分的类型和顺序可能不同，但是它们都遵循同样的构建过程。

示例：

假设你正在开发一个游戏，需要创建不同类型的角色，每个角色都有不同的属性和装备。你可以使用建造者模式来创建这些角色。

首先，定义一个角色接口：

public interface Role {
    void setRoleName(String name);
    void setHealth(int health);
    void setAttack(int attack);
    void setDefense(int defense);
    void setEquipment(String equipment);
}

然后，创建一个具体的角色类实现这个接口：

public class Warrior implements Role {
    private String roleName;
    private int health;
    private int attack;
    private int defense;
    private String equipment;

    @Override
    public void setRoleName(String name) {
        this.roleName = name;
    }

    @Override
    public void setHealth(int health) {
        this.health = health;
    }

    @Override
    public void setAttack(int attack) {
        this.attack = attack;
    }

    @Override
    public void setDefense(int defense) {
        this.defense = defense;
    }

    @Override
    public void setEquipment(String equipment) {
        this.equipment = equipment;
    }

    @Override
    public String toString() {
        return "Warrior{" +
                "roleName='" + roleName + '\'' +
                ", health=" + health +
                ", attack=" + attack +
                ", defense=" + defense +
                ", equipment='" + equipment + '\'' +
                '}';
    }
}

接下来，定义一个角色建造者接口：

public interface RoleBuilder {
    void buildRoleName(String name);
    void buildHealth(int health);
    void buildAttack(int attack);
    void buildDefense(int defense);
    void buildEquipment(String equipment);
    Role getRole();
}

然后，创建一个具体的角色建造者类实现这个接口：

public class WarriorBuilder implements RoleBuilder {
    private Warrior warrior = new Warrior();

    @Override
    public void buildRoleName(String name) {
        warrior.setRoleName(name);
    }

    @Override
    public void buildHealth(int health) {
        warrior.setHealth(health);
    }

    @Override
    public void buildAttack(int attack) {
        warrior.setAttack(attack);
    }

    @Override
    public void buildDefense(int defense) {
        warrior.setDefense(defense);
    }

    @Override
    public void buildEquipment(String equipment) {
        warrior.setEquipment(equipment);
    }

    @Override
    public Role getRole() {
        return warrior;
    }
}

最后，创建一个角色创建者类来组装角色：

public class RoleDirector {
    public Role constructWarrior(String name, int health, int attack, int defense, String equipment) {
        RoleBuilder builder = new WarriorBuilder();
        builder.buildRoleName(name);
        builder.buildHealth(health);
        builder.buildAttack(attack);
        builder.buildDefense(defense);
        builder.buildEquipment(equipment);
        return builder.getRole();
    }
}

使用示例：

public class BuilderPatternExample {
    public static void main(String[] args) {
        RoleDirector director = new RoleDirector();
        Role warrior = director.constructWarrior("Jack", 100, 50, 30, "Sword");
        System.out.println(warrior);
    }
}

输出结果：

Warrior{roleName='Jack', health=100, attack=50, defense=30, equipment='Sword'}

在这个示例中，我们使用建造者模式来创建一个 Warrior 类型的角色。首先，定义了一个 Role 接口和一个 Warrior 类实现这个接口，表示角色的属性和行为。然后，定义了一个 RoleBuilder 接口和一个 WarriorBuilder 类实现这个接口，表示角色的建造过程。最后，创建了一个 RoleDirector 类，用来组装角色，并且提供一个构建 Warrior 类型角色的方法 constructWarrior。在这个方法中，我们使用 WarriorBuilder 来建造 Warrior 类型的角色，然后返回这个角色对象。