Java设计模式学习笔记，三：建造者模式

Posted 2020-10-07

建造者模式：实现了构建和装配的解耦，即对象的各个子组件单独构建，再进行装配，从而建造完整对象。

该模式适用于构建较为复杂的对象（多个子组件）。

不同的构建者，使用相同的装配者，可以建造不同的对象实例。相同的构建者，不同的装配顺序，也可能建造出不同的对象实例。

举例：

　　汽车对象，子组件包括引擎、轮子和车体。

　　Audi汽车构建者，负责制造Audi牌各个子组件。BMW汽车构建者，负责制造BMW牌各个子组件。然后将子组件统一送至汽车装配者的生产线中进行组装，最后会建造出Audi牌汽车和BMW汽车。

以下代码实现：

　　首先，定义汽车类，及其子组件类。

  1 package com.corey.builder;
  2 
  3 /**
  4  * 汽车类---产品类
  5  * @author Corey
  6  *
  7  */
  8 public class Car {
  9     private Engine engine;
 10     private Wheel wheel;
 11     private CarBody body;
 12     
 13     public Engine getEngine() {
 14         return engine;
 15     }
 16     public void setEngine(Engine engine) {
 17         this.engine = engine;
 18     }
 19     public Wheel getWheel() {
 20         return wheel;
 21     }
 22     public void setWheel(Wheel wheel) {
 23         this.wheel = wheel;
 24     }
 25     public CarBody getBody() {
 26         return body;
 27     }
 28     public void setBody(CarBody body) {
 29         this.body = body;
 30     }
 31     
 32     public void Run(){
 33         System.out.println("启动汽车，开始行程！");
 34     }
 35     
 36     
 37 }
 38 
 39 /**
 40  * 发动机类
 41  * @author Corey
 42  *
 43  */
 44 class Engine {
 45     private String name;
 46 
 47     public Engine(String name) {
 48         super();
 49         this.name = name;
 50     }
 51 
 52     public String getName() {
 53         return name;
 54     }
 55 
 56     public void setName(String name) {
 57         this.name = name;
 58     }
 59     
 60 }
 61 
 62 /**
 63  * 车轮类
 64  * @author Corey
 65  *
 66  */
 67 class Wheel {
 68     private String name;
 69 
 70     public Wheel(String name) {
 71         super();
 72         this.name = name;
 73     }
 74 
 75     public String getName() {
 76         return name;
 77     }
 78 
 79     public void setName(String name) {
 80         this.name = name;
 81     }
 82     
 83 }
 84 
 85 /**
 86  * 车体类
 87  * @author Corey
 88  *
 89  */
 90 class CarBody {
 91     private String name;
 92 
 93     public CarBody(String name) {
 94         super();
 95         this.name = name;
 96     }
 97 
 98     public String getName() {
 99         return name;
100     }
101 
102     public void setName(String name) {
103         this.name = name;
104     }
105     
106 }

　　然后，定义汽车制造者接口。

 1 package com.corey.builder;
 2 
 3 /**
 4  * 汽车制造者接口
 5  * @author Corey
 6  *
 7  */
 8 public interface CarBuilder {
 9     
10     String getBrand();
11     Engine buildEngine();
12     Wheel buildWheel();
13     CarBody buildCarBody();
14     
15     
16 }

　　分别实现Audi汽车制造者类和BMW汽车制造者类。

 1 package com.corey.builder;
 2 
 3 /**
 4  * 奥迪汽车建造者---接口实现类
 5  * @author Corey
 6  *
 7  */
 8 public class AudiCarBuidler implements CarBuilder{
 9     
10 
11 
12     @Override
13     public Engine buildEngine() {
14         System.out.println("建造奥迪发动机！");
15         return new Engine("Audi发动机");
16     }
17 
18     @Override
19     public Wheel buildWheel() {
20         System.out.println("建造奥迪车轮！");
21         return new Wheel("Audi车轮");
22     }
23 
24     @Override
25     public CarBody buildCarBody() {
26         System.out.println("建造奥迪车体！");
27         return new CarBody("Audi车体");
28     }
29 
30     @Override
31     public String getBrand() {
32         return "Audi";
33     }
34 
35 }

 1 package com.corey.builder;
 2 
 3 public class BMWCarBuilder implements CarBuilder{
 4 
 5     @Override
 6     public String getBrand() {
 7         return "BMW";
 8     }
 9 
10     @Override
11     public Engine buildEngine() {
12         System.out.println("建造宝马发动机！");
13         return new Engine("BMW发动机");
14     }
15 
16     @Override
17     public Wheel buildWheel() {
18         System.out.println("建造宝马车轮！");
19         return new Wheel("BMW车轮");
20     }
21 
22     @Override
23     public CarBody buildCarBody() {
24         System.out.println("建造宝马车体！");
25         return new CarBody("BMW车体");
26     }
27 
28 }

　　定义汽车装配者类。

package com.corey.builder;

/**
 * 奥迪汽车组装者--接口实现类
 * @author Corey
 *
 */
public class CarDirector{

    private CarBuilder builder;
    
    public CarDirector(CarBuilder builder) {
        super();
        this.builder = builder;
    }

    public Car directCar() {
        Car car = new Car();
        car.setEngine(builder.buildEngine());
        car.setWheel(builder.buildWheel());
        car.setBody(builder.buildCarBody());
        String brand = builder.getBrand();
        System.out.println("组装" + brand + "汽车完成！");
        return car;
        
    }

}

由此，我们可以进行汽车生产了。

指定汽车制造商，送入汽车装配厂，生产汽车，上路。以下是测试代码：

 1 package com.corey.builder;
 2 
 3 public class Test {
 4 
 5     public static void main(String[] args) {
 6         
 7         CarBuilder builder = new AudiCarBuidler();
 8         CarDirector director = new CarDirector(builder);
 9         Car car = director.directCar();
10         System.out.println(car.getEngine().getName());
11         car.Run();
12         
13         System.out.println("----------------------------------");
14         
15         CarBuilder builder1 = new BMWCarBuilder();
16         CarDirector director1 = new CarDirector(builder1);
17         Car bmwCar = director1.directCar();
18         System.out.println(bmwCar.getEngine().getName());
19         bmwCar.Run();
20     }
21 }

运行结果：

建造奥迪发动机！
建造奥迪车轮！
建造奥迪车体！
组装Audi汽车完成！
Audi发动机
启动汽车，开始行程！
----------------------------------
建造宝马发动机！
建造宝马车轮！
建造宝马车体！
组装BMW汽车完成！
BMW发动机
启动汽车，开始行程！

 

至此，建造者模式完成。

Java框架中很多都是用建造者模式写的，一般都会以Builder结尾，常见的如StringBuilder。