建造者模式

当我们需要创建一个复杂对象的时候往往需要利用到建造者模式(创建型模式)，典型的像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类相对独立，可扩展复杂对象的构建过程，可以控制对象的生成，提高了安全性

对象

构造者模式

建造者模式