建造者模式(Builder): 将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。
需求:设计出行路线,如乘坐汽车、飞机、轮船等,可以决定是先做飞机或者先轮船等。
建造者模式中几个比较重要的角色是:
- Product 产品类 : 产品的抽象类。
- Builder : 抽象类, 规范产品的组建,一般是由子类实现具体的组件过程
- ConcreteBuilder : 具体的构建器.
- Director : 统一组装过程(可省略)
首先,我们要坐的路线产品:
/**
* Product 产品类 。
*/
public class RouteProduct {
private String car;
private String ship;
private String plane;
private String train;
private String foot;
public String getCar() {
return car;
}
public void setCar(String car) {
this.car = car;
}
public String getShip() {
return ship;
}
public void setShip(String ship) {
this.ship = ship;
}
public String getPlane() {
return plane;
}
public void setPlane(String plane) {
this.plane = plane;
}
public String getTrain() {
return train;
}
public void setTrain(String train) {
this.train = train;
}
public String getFoot() {
return foot;
}
public void setFoot(String foot) {
this.foot = foot;
}
public String show(){
return "RouteProduct{" +
"car='" + car + '\'' +
", ship='" + ship + '\'' +
", plane='" + plane + '\'' +
", train='" + train + '\'' +
", foot='" + foot + '\'' +
'}';
}
}
路线创建者:
/**
* Builder : 抽象类, 规范产品的组建,一般是由子类实现具体的组件过程。
*/
public interface RouteBuilder {
void byCar();
void byShip();
void byTrain();
void takePlane();
void byFoot();
RouteProduct getRoute();
}
路线A:
/**
* ConcreteBuilder : 具体的构建器.
*/
public class RouteA implements RouteBuilder {
private RouteProduct product=new RouteProduct();
@Override
public void byCar() {
product.setCar("坐A小汽车..");
}
@Override
public void byShip() {
product.setShip("坐A豪华轮船..");
}
@Override
public void byTrain() {
product.setTrain("坐A高铁..");
}
@Override
public void takePlane() {
product.setPlane("坐A飞机..");
}
@Override
public void byFoot() {
product.setFoot("只能走路喽~");
}
@Override
public RouteProduct getRoute() {
return product;
}
}
路线B:
public class RouteB implements RouteBuilder {
private RouteProduct product=new RouteProduct();
@Override
public void byCar() {
product.setCar("坐B小汽车..");
}
@Override
public void byShip() {
product.setShip("坐B豪华轮船..");
}
@Override
public void byTrain() {
product.setTrain("坐B高铁..");
}
@Override
public void takePlane() {
product.setPlane("坐B飞机..");
}
@Override
public void byFoot() {
product.setFoot("只能走路喽~");
}
@Override
public RouteProduct getRoute() {
return product;
}
}
路线组装(选择)过程:
/**
Director : 统一组装过程(可省略)。
*/
public class RouteDirector {
private RouteBuilder builder;
public void consruct(RouteBuilder builder) {
this.builder = builder;
}
public void build() {
builder.byCar();
builder.byShip();
builder.byTrain();
builder.byFoot();
}
}
运行测试:
public class test {
public static void main(String[] args) {
RouteDirector director = new RouteDirector();
RouteA routeA = new RouteA();
director.consruct(routeA);
director.build();
RouteProduct product = routeA.getRoute();
System.out.println(product.show());
// RouteProduct{car='坐A小汽车..', ship='坐A豪华轮船..', plane='null', train='坐A高铁..', foot='只能走路喽~'}
RouteB routeB=new RouteB();
director.consruct(routeB);
director.build();
System.out.println(routeB.getRoute().show());
// RouteProduct{car='坐B小汽车..', ship='坐B豪华轮船..', plane='null', train='坐B高铁..', foot='只能走路喽~'}
}
}
优点:
- 良好的封装性, 使用建造者模式可以使客户端不必知道产品内部组成的细节;
- 建造者独立,容易扩展;
缺点
- 会产生多余的Builder对象以及Director对象,消耗内存;
- 对象的构建过程暴露。
本文地址:http://blog.csdn.net/ProdigalWang/article/details/76974404