再战设计模式(三)之建造者模式

建造者模式

他的本质主要是:

分离了组件的构造(由builder来负责),和装配(由Director负责),从而构造出复杂的对象,这个模式使用于:某个对象构建过程复杂的情况下使用

建造模式可以将一个产品的内部表象（internal representation）与产品的生产过程分割开来，从而可以使一个建造过程生成具有不同的内部表象的产品对象。

由于实现了构建和装配的解耦。不同的构建器和不同的装配器 可以组合成很多不同的对象。也就是实现了构建算法、装配 算法的解耦，实现了更好的复用

场景:

 在日常开发中,有时候我们需要一个复杂的对象.由于需求的原因.但是其中各部分的子对象经常变化,但是我们可以让他们组合起来相对简单稳定

使用场景. 1.我们需要很多零件 2.我们要把这些零件组装起来 当然在工作中,可能要和工厂模式搭配起来使用

代码:

这些实例可以使用简单工厂模式来生成不同的发动机 座椅啊.轮胎啊.

/**
 * 汽车
 * @Created by xiaodao
 */
public class Car {

    private Seat seat;
    private Engine engine;//发动机

    private Tyre tyre;//轮胎



    public Car(Seat seat, Engine engine, Tyre tyre) {

        this.seat = seat;
        this.engine = engine;
        this.tyre = tyre;
    }

    public Seat getSeat() {
        return seat;
    }

    public void setSeat(Seat seat) {
        this.seat = seat;
    }

    public Engine getEngine() {
        return engine;
    }

    public void setEngine(Engine engine) {
        this.engine = engine;
    }

    public Tyre getTyre() {
        return tyre;
    }

    public void setTyre(Tyre tyre) {
        this.tyre = tyre;
    }
}

/**
 * @Created by xiaodao
 * 引擎实例
 */
public class Engine {

    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Engine(String name) {
        this.name = name;
    }
}


/**
 * @Created by xiaodao
 * 座椅
 */
public class Seat {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Seat(String name) {
        this.name = name;
    }
}

/**
 * @Created by xiaodao
 *轮胎
 */
public class Tyre {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Tyre(String name) {
        this.name = name;
    }
}

builder接口:

/**
 * @Created by xiaodao
 * 构建接口 这里也可以是抽象方法
 */
public interface CarBuilder {

    /**
     * 构建引擎
     *
     * @return
     */
    Engine builderEngine();

    Seat builderSeat();

    Tyre builderTyre();
}

builder实现类:

/**
 * @Created by xiaodao
 */
public class AudiCarBuilderImpl implements CarBuilder {
    @Override
    public Engine builderEngine() {
        return new Engine("奥迪引擎");
    }

    @Override
    public Seat builderSeat() {
        return new Seat("奥迪座椅");
    }

    @Override
    public Tyre builderTyre() {
        return new Tyre("奥迪轮胎");
    }
}

direactor:用来引入builder类的引用.他不知道builder的子类是什么

/**
 * @Created by xiaodao
 */
public class CarDirector {

    private CarBuilder builder;

    public CarDirector(CarBuilder builder) {
        this.builder = builder;
    }

    /**
     * 装配汽车
     * @return
     */
    public Car directCar(){

        Engine engine = builder.builderEngine();
        Seat seat = builder.builderSeat();
        Tyre tyre = builder.builderTyre();
        return new Car(seat,engine,tyre);
    }
}

调用者:

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

        CarDirector carDirector = new CarDirector(new AudiCarBuilderImpl());
        Car car = carDirector.directCar();
        System.out.println(car.getEngine().getName());
        System.out.println(car.getSeat().getName());
        System.out.println(car.getTyre().getName());
    }
}

奥迪引擎
奥迪座椅
奥迪轮胎

类图:

登场角色

builder角色负责定义用户生成实例的接口 

concreteBuilder(具体的builder) concreteBuilder角色是实现了Builder接口的类.定义了具体的方法

director(监工) 负责使用builder角色的接口来生成实例,他不依赖与Builder的子类 无论子类如何定义都不影响 director的使用

client 具体的调用者 

这里我们可以把car 的各种属性变成工厂模式 

总结:

建造者模式与抽象工厂模式相似.(director 和abstractFactory 的实现类)今天下午与同事讨论半天总是在这方面比较模糊.欢迎大家踊跃评论.

个人感觉工厂模式是用于创建什么样的对象

建造模式就用来怎么创建对象

工厂方法模式和建造者模式都属于对象创建类模式，都用来创建类的对象。但它们之间的区别还是比较明显的。 　

下面来自某位群友的讲解

　● 意图不同 　

　　　在工厂方法模式里，我们关注的是一个产品整体，如超人整体，无须关心产品的各部分是如何创建出来的；但在建造者模式中，一个具体产品的产生是依赖各个部件的产生以及装配顺序，它关注的是“由零件一步一步地组装出产品对象”。简单地说，工厂模式是一个对象创建的粗线条应用，建造者模式则是通过细线条勾勒出一个复杂对象，关注的是产品组成部分的创建过程。 　

　● 产品的复杂度不同 　　

　　工厂方法模式创建的产品一般都是单一性质产品，如成年超人，都是一个模样，而建造者模式创建的则是一个复合产品，它由各个部件复合而成，部件不同产品对象当然不同。这不是说工厂方法模式创建的对象简单，而是指它们的粒度大小不同。一般来说，工厂方法模式的对象粒度比较粗，建造者模式的产品对象粒度比较细。 　　两者的区别有了，那在具体的应用中，我们该如何选择呢？是用工厂方法模式来创建对象，还是用建造者模式来创建对象，这完全取决于我们在做系统设计时的意图，如果需要详细关注一个产品部件的生产、安装步骤，则选择建造者，否则选择工厂方法模式。