建造者模式

當我們需要建立一個複雜物件的時候往往需要利用到建造者模式(建立型模式)，典型的像StringBuilder類，其原理就是將複雜物件拆分為簡單物件來構建，各個簡單物件是通過一定的演算法來組裝的，用不同的表示就能通過同樣的建立過程創建出不同的複雜物件

下面我們通過一個簡單的例子來闡述建造者模式的特點

Product.java

public interface Product {
    float price();
    Screen screen();
    String name();
}

Phone.java

public abstract class Phone implements Product {
}
 

Apple.java

public class Apple extends Phone {
    @Override
    public float price() {
        return 6666f;
    }

    @Override
    public Screen screen() {
        return new Small();
    }

    @Override
    public String name() {
        return "Apple";
    }
}

HuaWei.java

public class HuaWei extends Phone {
    @Override
    public float price() {
        return 5555f;
    }

    @Override
    public Screen screen() {
        return new Small();
    }

    @Override
    public String name() {
        return "HuaWei";
    }
}
 

PC.java

public abstract class PC implements Product{
}

Mac.java

public class Mac extends PC {
    @Override
    public float price() {
        return 10000f;
    }

    @Override
    public Screen screen() {
        return new Big();
    }

    @Override
    public String name() {
        return "Mac";
    }
}
 

MateBook.java

public class MateBook extends PC {
    @Override
    public float price() {
        return 8888f;
    }

    @Override
    public Screen screen() {
        return new Big();
    }

    @Override
    public String name() {
        return "MateBook";
    }
}

Screen.java

public interface Screen {
    String screen();
}

Big.java

public class Big implements Screen {
    @Override
    public String screen() {
        return "Big";
    }
}

Small.java

public class Small implements Screen {
    @Override
    public String screen() {
        return "Small";
    }
}

Set.java

public class Set {
    List<Product> productList = new ArrayList<>();

    public void addProduct(Product product){
        productList.add(product);
    }

    public float getCost(){
        float cost = 0.0f;
        for (Product product:productList){
            cost += product.price();
        }
        return cost;
    }

    public void showProduct(){
        for (Product product:productList){
            System.out.println(product.name()+" "+product.price()+" "+product.screen().screen());
        }
    }
}

SetBuilder.java

public class SetBuilder {

    public Set AppleSet(){
        Set set = new Set();
        set.addProduct(new Apple());
        set.addProduct(new Mac());
        return set;
    }

    public Set HuaWeiSet(){
        Set set = new Set();
        set.addProduct(new HuaWei());
        set.addProduct(new MateBook());
        return set;
    }
}

TestBuilder.java

public class TestBuilder {
    public static void main(String[] args) {

        SetBuilder sb = new SetBuilder();

        Set set1 = sb.AppleSet();
        System.out.println("Total Cost:"+set1.getCost());
        set1.showProduct();
        System.out.println("---貧富分割線---");
        Set set2 = sb.HuaWeiSet();
        System.out.println("Total Cost:"+set2.getCost());
        set2.showProduct();
    }
}

Run result

Total Cost:16666.0
Apple 6666.0 Small
Mac 10000.0 Big
---貧富分割線---
Total Cost:14443.0
HuaWei 5555.0 Small
MateBook 8888.0 Big

由測試類我們可以看出，對於複雜物件的建立過程客戶端並不需要過多的關心，只要創建出Builder物件呼叫其中方法即可拿到複雜物件，然後再呼叫封裝好的複雜物件中的方法即可拿到資料

這樣做的好處就是Builder類相對獨立，可擴充套件複雜物件的構建過程，可以控制物件的生成，提高了安全性