設計模式之建造者模式、模版方法

1、建造者模式

建造者模式：是將一個複雜的對象的構建與它的表示分離，使得一樣的構建過程能夠建立不一樣的表示。

工廠類模式提供的是建立單個類的模式，而建造者模式則是將各類產品集中起來進行管理，用來建立複合對象，所謂複合對象就是指某個類具備不一樣的屬性，其實建造者模式就是前面抽象工廠模式和最後的Test結合起來獲得的。

建造者模式一般包括下面幾個角色：

• 一、Builder：給出一個抽象接口，以規範產品對象的各個組成成分的建造。這個接口規定要實現複雜對象的哪些部分的建立，並不涉及具體的對象部件的建立。
• 二、ConcreteBuilder：實現Builder接口，針對不一樣的商業邏輯，具體化複雜對象的各部分的建立。 在建造過程完成後，提供產品的實例。
• 三、Director：調用具體建造者來建立複雜對象的各個部分，在指導者中不涉及具體產品的信息，只負責保證對象各部分完整建立或按某種順序建立。
• 四、Product：要建立的複雜對象。

一、建造者應用場景

• 一、去肯德基，漢堡、可樂、薯條、炸雞翅等是不變的，而其組合是常常變化的，生成出所謂的"套餐"。
  19元每週三 漢堡+可樂+薯條=套餐可能會發生改變。
• 二、JAVA 中的 StringBuilder 數組（單個字符）字整合在一塊兒 字符串

使用場景：

• 一、須要生成的對象具備複雜的內部結構。
• 二、須要生成的對象內部屬性自己相互依賴。

與工廠模式的區別是：建造者模式更加關注與零件裝配的順序。

二、 創建一我的物對象Person

public class Person {

    private String head;
    private String body;
    private String foot;

    public String getHead() {
        return head;
    }

    public void setHead(String head) {
        this.head = head;
    }

    public String getBody() {
        return body;
    }

    public void setBody(String body) {
        this.body = body;
    }

    public String getFoot() {
        return foot;
    }

    public void setFoot(String foot) {
        this.foot = foot;
    }

}

1）、Builder（給出一個抽象接口，以規範產品對象的各個組成成分的建造。這個接口規定要實現複雜對象的哪些部分的建立，並不涉及具體的對象部件的建立）

public interface PersonBuilder {

    void builderHead();

    void builderBody();

    void builderFoot();

    Person BuilderPersion(); //組裝
}

2）、ConcreteBuilder（實現Builder接口，針對不一樣的商業邏輯，具體化複雜對象的各部分的建立。 在建造過程完成後，提供產品的實例）

public class ManBuilder implements PersonBuilder {
    private Person person;

    public ManBuilder() {
        person = new Person();//建立一個Person實例,用於調用set方法
    }

    public void builderHead() {
        person.setHead("建造者頭部分");
    }

    public void builderBody() {
        person.setBody("建造者身體部分");
    }

    public void builderFoot() {
        person.setFoot("建造者頭四肢部分");
    }

    public Person BuilderPersion() {
        return person;
    }

}

3）、Director（調用具體建造者來建立複雜對象的各個部分，在指導者中不涉及具體產品的信息，只負責保證對象各部分完整建立或按某種順序建立）

public class PersonDirector {

    public Person constructPerson(PersonBuilder pb) {
        pb.builderHead();
        pb.builderBody();
        pb.builderFoot();
        return pb.BuilderPersion();
    }

    public static void main(String[] args) {
        PersonDirector pb = new PersonDirector();
        Person person = pb.constructPerson(new ManBuilder());
        System.out.println(person.getHead());
        System.out.println(person.getBody());
        System.out.println(person.getFoot());
    }
}

2、模板方法

一、模板方法模式：

定義一個操做中的算法骨架，而將一些步驟延遲到子類中。模板方法使得子類能夠不改變一個算法的結構便可重定義該算法的

重複代碼所有在父類裏面，不一樣業務的，抽取給子類進行實現。抽取過程---抽象方法。

某些特定步驟。

核心：處理某個流程的代碼已經都具有，可是其中某個節點的代碼暫時不能肯定。所以，咱們採用工廠方法模式，將這個節點的代碼實現轉移給
子類完成。即：處理步驟在父類中定義好，具體的實現延遲到子類中定義。

說白了，就是將一些相同操做的代碼，封裝成一個算法的骨架。核心的部分留在子類中操做，在父類中只把那些骨架作好。
例如：
例如：

• 1.去銀行辦業務，銀行給咱們提供了一個模板就是：先取號，排對，辦理業務（核心部分咱們子類完成），給客服人員評分，完畢。

  這裏辦理業務是屬於子類來完成的，其餘的取號，排隊，評分則是一個模板。

• 2.去餐廳吃飯，餐廳給提供的一套模板就是：先點餐，等待，吃飯（核心部分咱們子類完成），買單

這裏吃飯是屬於子類來完成的，其餘的點餐，買單則是餐廳提供給咱們客戶的一個模板。

二、模板方法具體實現

這裏使用銀行辦理業務爲例

1)首先，定義一個模板。模板中把辦理業務用做核心部分，讓子類來實現。

//模板方法
public abstract class BankTemplateMethod {

    // 1.取號排隊
    public void takeNumber() {
        System.out.println("取號排隊。。");
    }

    // 2.每一個子類不一樣的業務實現，由各自子類實現.
    abstract void transact();

    // 3.評價
    public void evaluate() {
          System.out.println("反饋評價..");
    }
    
    public void process(){
        takeNumber();
        transact();
        evaluate();
    }
}

2)具體的模板方法的子類

public class DrawMoney extends BankTemplateMethod {
    @Override
    void transact() {
        System.out.println("我要取款");
    }
}

3)客戶端測試

public class Client {

     public static void main(String[] args) {
         BankTemplateMethod bankTemplate=new DrawMoney();
         bankTemplate.process();
    }
    
}

4)匿名內部類方式

BankTemplateMethod bankTemplateMethod=new BankTemplateMethod() {
            
            @Override
            void transact() {
                System.out.println("我要存錢.");
                
            }
        };
        bankTemplateMethod.process();

我的博客 蝸牛