背景
假设我们要建造一座房子,这个房子有很多不同的部分,比如墙壁、地板、屋顶等等。我们可以使用建造者模式来创建这座房子。
首先,我们定义一个房子类 House,它有一些属性,比如墙壁、地板和屋顶。然后,我们创建一个建造者类 HouseBuilder,它有一些方法用于构建房子的不同部分。最后,我们创建一个指挥者类 HouseDirector,它负责指导建造者如何构建房子。
解释
建造者模式(Builder Pattern)是一种创建型设计模式,旨在通过将对象的构建过程分离为不同的步骤,使得可以逐步构建复杂的对象。该模式将对象的构建与其表现分离开,使得构建过程可以重复使用,同时也方便了对对象构建过程的控制。
示例一
以建造一座房子为例
public class House {
private String wall;
private String floor;
private String roof;
public void setWall(String wall) {
this.wall = wall;
}
public void setFloor(String floor) {
this.floor = floor;
}
public void setRoof(String roof) {
this.roof = roof;
}
// ... 其他方法
}
public class HouseBuilder {
private House house;
public HouseBuilder() {
house = new House();
}
public void buildWall(String wall) {
house.setWall(wall);
}
public void buildFloor(String floor) {
house.setFloor(floor);
}
public void buildRoof(String roof) {
house.setRoof(roof);
}
public House getHouse() {
return house;
}
}
public class HouseDirector {
private HouseBuilder builder;
public HouseDirector(HouseBuilder builder) {
this.builder = builder;
}
public void constructHouse() {
builder.buildWall("brick");
builder.buildFloor("wood");
builder.buildRoof("tile");
}
}
测试
public class Main {
public static void main(String[] args) {
HouseBuilder builder = new HouseBuilder();
HouseDirector director = new HouseDirector(builder);
director.constructHouse();
House house = builder.getHouse();
System.out.println("Wall: " + house.getWall());
System.out.println("Floor: " + house.getFloor());
System.out.println("Roof: " + house.getRoof());
}
}
运行结果:
Wall: brick
Floor: wood
Roof: tile
示例二
下面是一个实际应用中的场景实例,以创建一份订单为例:
首先,定义一个产品类Order,包含订单的各个属性:
public class Order {
private String customerId;
private List<String> items;
public void setCustomerId(String customerId) {
this.customerId = customerId;
}
public void setItems(List<String> items) {
this.items = items;
}
@Override
public String toString() {
return "Order{" +
"customerId='" + customerId + '\'' +
", items=" + items +
'}';
}
}
然后,定义一个抽象建造者类OrderBuilder,用于规定订单创建的步骤和方法:
public abstract class OrderBuilder {
protected Order order;
public void createOrder() {
order = new Order();
}
public abstract void setCustomerId(String customerId);
public abstract void setItems(List<String> items);
public Order getOrder() {
return order;
}
}
接下来,定义具体的建造者类SpecificOrderBuilder,实现OrderBuilder中的抽象方法,完成订单的实际构建过程:
public class SpecificOrderBuilder extends OrderBuilder {
@Override
public void setCustomerId(String customerId) {
order.setCustomerId(customerId);
}
@Override
public void setItems(List<String> items) {
order.setItems(items);
}
}
最后,定义一个指导者类OrderDirector,用于控制具体的构建过程:
public class OrderDirector {
private OrderBuilder orderBuilder;
public OrderDirector(OrderBuilder orderBuilder) {
this.orderBuilder = orderBuilder;
}
public void setOrderBuilder(OrderBuilder orderBuilder) {
this.orderBuilder = orderBuilder;
}
public Order constructOrder(String customerId, List<String> items) {
orderBuilder.createOrder();
orderBuilder.setCustomerId(customerId);
orderBuilder.setItems(items);
return orderBuilder.getOrder();
}
}
使用建造者模式创建订单:
public class Main {
public static void main(String[] args) {
List<String> items = new ArrayList<>();
items.add("item1");
items.add("item2");
OrderBuilder orderBuilder = new SpecificOrderBuilder();
OrderDirector orderDirector = new OrderDirector(orderBuilder);
Order order = orderDirector.constructOrder("customer1", items);
System.out.println(order);
}
}