Java設計模式學習筆記，三：建造者模式

建造者模式：實現了構建和裝配的解耦，即對象的各個子組件單獨構建，再進行裝配，從而建造完整對象。

該模式適用於構建較爲複雜的對象（多個子組件）。

不一樣的構建者，使用相同的裝配者，能夠建造不一樣的對象實例。相同的構建者，不一樣的裝配順序，也可能建造出不一樣的對象實例。

舉例：

　　汽車對象，子組件包括引擎、輪子和車體。

　　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。