创建型模式5之4-Builder建造者模式例子理解

将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。 [构建与表示分离，同构建不同表示]

与抽象工厂的区别：在建造者模式里，有个指导者，由指导者来管理建造者，用户是与指导者联系的，指导者联系建造者最后得到产品。即建造模式可以强制实行一种分步骤进行的建造过程。

　　建造模式是将复杂的内部创建封装在内部，对于外部调用的人来说，只需要传入建造者和建造工具，对于内部是如何建造成成品的，调用者无需关心。

　　举个简单的例子，如汽车，有很多部件，车轮，方向盘，发动机还有各种小零件等等，部件很多，但远不止这些，如何将这些部件装配成一部汽车，这个装配过程也很复杂（需要很好的组装技术）， builder模式就是为了将部件和组装分开。
　　
例子一
1.Builder

package com.test.buildermodel;//Builder：为创建一个产品对象的各个部件指定抽象接口。public interface IThePhoneBuilder {    public void produceScreen();    public void produceBody();    public void produceBattery();}

2.IPhoneCom_Builder、HuaweiCom_Builder等对抽象接口接口实现

package com.test.buildermodel;//实现Builder的接口以构造和装配该产品的各个部件，定义并明确它所创建的表示，并提供一个检索产品的接口。public class IPhoneCom_Builder implements IThePhoneBuilder{    @Override    public void produceScreen() {        // TODO Auto-generated method stub        System.out.println("IPhoneCom produceScreen");    }    @Override    public void produceBody() {        // TODO Auto-generated method stub        System.out.println("IPhoneCom produceBody");    }    @Override    public void produceBattery() {        // TODO Auto-generated method stub        System.out.println("IPhoneCom produceBattery");    }}

package com.test.buildermodel;//实现Builder的接口以构造和装配该产品的各个部件，定义并明确它所创建的表示，并提供一个检索产品的接口。public class HuaweiCom_Builder implements IThePhoneBuilder{    @Override    public void produceScreen() {        // TODO Auto-generated method stub        System.out.println("HuaweiCom produceScreen");    }    @Override    public void produceBody() {        // TODO Auto-generated method stub        System.out.println("HuaweiCom produceScreen");    }    @Override    public void produceBattery() {        // TODO Auto-generated method stub        System.out.println("HuaweiCom produceBattery");    }}

3.Director指挥者

package com.test.buildermodel;//指挥者：设想是设计图（生产方式）public class Director {    IThePhoneBuilder iThePhoneBuilder;    public Director(IThePhoneBuilder iThePhoneBuilder) {        // TODO Auto-generated constructor stub        this.iThePhoneBuilder=iThePhoneBuilder;    }    void directorProducePhone() {        iThePhoneBuilder.produceScreen();        iThePhoneBuilder.produceBody();        iThePhoneBuilder.produceBattery();    }}

4.测试

package com.test.buildermodel;public class MainTest {    public static void main(String[] args) {        IThePhoneBuilder iThePhoneBuilder_iPhone=new IPhoneCom_Builder();        Director director=new Director(iThePhoneBuilder_iPhone);        director.directorProducePhone();        IThePhoneBuilder iThePhoneBuilder_huawei=new HuaweiCom_Builder();        Director director2=new Director(iThePhoneBuilder_huawei);        director2.directorProducePhone();    }}

例子二

package com.test.buildermodel;/** * 建造者模式的优点:        首先，建造者模式的封装性很好。使用建造者模式可以有效的封装变化，在使用建造者模式的场景中，一般产品类和建造者类是比较稳定的，因此，将主要的业务逻辑封装在导演类中对整体而言可以取得比较好的稳定性。        其次，建造者模式很容易进行扩展。如果有新的需求，通过实现一个新的建造者类就可以完成，基本上不用修改之前已经测试通过的代码，因此也就不会对原有功能引入风险。建造者模式与工厂模式的区别:       我们可以看到，建造者模式与工厂模式是极为相似的，总体上，建造者模式仅仅只比工厂模式多了一个“导演类”的角色。在建造者模式的类图中，假如把这个导演类看做是最终调用的客户端，那么图中剩余的部分就可以看作是一个简单的工厂模式了。       与工厂模式相比，建造者模式一般用来创建更为复杂的对象，因为对象的创建过程更为复杂，因此将对象的创建过程独立出来组成一个新的类——导演类。也就是说，工厂模式是将对象的全部创建过程封装在工厂类中，由工厂类向客户端提供最终的产品；而建造者模式中，建造者类一般只提供产品类中各个组件的建造，而将具体建造过程交付给导演类。由导演类负责将各个组件按照特定的规则组建为产品，然后将组建好的产品交付给客户端。总结:       建造者模式与工厂模式类似，他们都是建造者模式，适用的场景也很相似。一般来说，如果产品的建造很复杂，那么请用工厂模式；如果产品的建造更复杂，那么请用建造者模式。 * @author Administrator * */public class AllIn {    //产品类：一般是一个较为复杂的对象，也就是说创建对象的过程比较复杂，一般会有比较多的代码量。在本类图中，产品类是一个具体的类，而非抽象类。实际编程中，产品类可以是由一个抽象类与它的不同实现组成，也可以是由多个抽象类与他们的实现组成。    static class Product {        private String name;        private String type;        public void setName(String name) {            this.name = name;        }        public void setType(String type) {            this.type = type;        }        public void showProduct() {            System.out.println("名称：" + name);            System.out.println("型号：" + type);        }    }    // 抽象建造者：引入抽象建造者的目的，是为了将建造的具体过程交与它的子类来实现。这样更容易扩展。一般至少会有两个抽象方法，一个用来建造产品，一个是用来返回产品。    static abstract class Builder {        public abstract void setPart(String arg1, String arg2);        public abstract Product getProduct();    }    //// 建造者：实现抽象类的所有未实现的方法，具体来说一般是两项任务：组建产品；返回组建好的产品。    static class ConcreteBuilder extends Builder {        private Product product = new Product();        public Product getProduct() {            return product;        }        public void setPart(String name, String type) {            product.setName(name);            product.setType(type);        }    }    // 导演类：负责调用适当的建造者来组建产品，导演类一般不与产品类发生依赖关系，与导演类直接交互的是建造者类。一般来说，导演类被用来封装程序中易变的部分。    public static class Director {        private Builder builder = new ConcreteBuilder();        public Product getAProduct() {            builder.setPart("宝马", "X7");            return builder.getProduct();        }        public Product getBProduct() {            builder.setPart("奥迪", "Q5");            return builder.getProduct();        }    }    public static class Customer {        public static void main(String[] args) {            Director director = new Director();            Product product1 = director.getAProduct();            product1.showProduct();            Product product2 = director.getBProduct();            product2.showProduct();        }    }}

例子三

package designpatterns.builder;// 待构建产品class Starbucks {    private String size;    private String drink;    public void setSize(String size) {        this.size = size;    }    public void setDrink(String drink) {        this.drink = drink;    }}//抽象builderabstract class StarbucksBuilder {    protected Starbucks starbucks;    public Starbucks getStarbucks() {        return starbucks;    }    public void createStarbucks() {        starbucks = new Starbucks();        System.out.println("a drink is created");    }    public abstract void buildSize();    public abstract void buildDrink();}// 泡茶builderclass TeaBuilder extends StarbucksBuilder {    public void buildSize() {        starbucks.setSize("large");        System.out.println("build large size");    }    public void buildDrink() {        starbucks.setDrink("tea");        System.out.println("build tea");    }}// 泡咖啡builderclass CoffeeBuilder extends StarbucksBuilder {    public void buildSize() {        starbucks.setSize("medium");        System.out.println("build medium size");    }    public void buildDrink() {        starbucks.setDrink("coffee");        System.out.println("build coffee");    }}//指导如何封装builderclass Waiter {    private StarbucksBuilder starbucksBuilder;    public void setStarbucksBuilder(StarbucksBuilder builder) {        starbucksBuilder = builder;    }    public Starbucks getstarbucksDrink() {        return starbucksBuilder.getStarbucks();    }    public void constructStarbucks() {        starbucksBuilder.createStarbucks();        starbucksBuilder.buildDrink();        starbucksBuilder.buildSize();    }}//客户public class Customer {    public static void main(String[] args) {        Waiter waiter = new Waiter();        StarbucksBuilder coffeeBuilder = new CoffeeBuilder();        //也可以用泡茶builder沏茶        //StarbucksBuilder teaBuilder = new TeaBuilder();        waiter.setStarbucksBuilder(coffeeBuilder);        waiter.constructStarbucks();        //取到饮料        Starbucks drink = waiter.getstarbucksDrink();    }}

建造者模式的优点
首先，建造者模式的封装性很好。使用建造者模式可以有效的封装变化，在使用建造者模式的场景中，一般产品类和建造者类是比较稳定的，因此，将主要的业务逻辑封装在导演类中对整体而言可以取得比较好的稳定性。
其次，建造者模式很容易进行扩展。如果有新的需求，通过实现一个新的建造者类就可以完成，基本上不用修改之前已经测试通过的代码，因此也就不会对原有功能引入风险。

建造者模式与工厂模式的区别
我们可以看到，建造者模式与工厂模式是极为相似的，总体上，建造者模式仅仅只比工厂模式多了一个“导演类”的角色。在建造者模式的类图中，假如把这个导演类看做是最终调用的客户端，那么图中剩余的部分就可以看作是一个简单的工厂模式了。
与工厂模式相比，建造者模式一般用来创建更为复杂的对象，因为对象的创建过程更为复杂，因此将对象的创建过程独立出来组成一个新的类——导演类。也就是说，工厂模式是将对象的全部创建过程封装在工厂类中，由工厂类向客户端提供最终的产品；而建造者模式中，建造者类一般只提供产品类中各个组件的建造，而将具体建造过程交付给导演类。由导演类负责将各个组件按照特定的规则组建为产品，然后将组建好的产品交付给客户端。

总结
建造者模式与工厂模式类似，他们都是建造者模式，适用的场景也很相似。一般来说，如果产品的建造很复杂，那么请用工厂模式；如果产品的建造更复杂，那么请用建造者模式。