学习笔记——JAVA设计模式<3>建造者模式

建造者模式
分离了对象子组件的单独构造（由Builder来负责）和装配（由Director负责）。从而可以构造出复杂的对象。这个模式适用于：某个对象的构建过程复杂的情况下使用
由于实现了构建和装配的解耦。不同的构造器，相同的装配，也可以做出不同的对象；相同的构造器，不同的装配顺序也可以做出不同的对象。也就是实现了构造算法，装配算法的解耦，实现了更好的复用。

工厂模式创建产品 建造者模式把产品组装

建立汽车类

package studyGFO;

/**
 * 汽车
 * @author http://blog.csdn.net/thewaiting
 *
 */
public class Car {

    private Engine engine;
    private Seat seat;
    private Tyre tyre;

    public void run() {
        System.out.println("跑得快！");
    }

    public Engine getEngine() {
        return engine;
    }
    public void setEngine(Engine engine) {
        this.engine = engine;
    }
    public Seat getSeat() {
        return seat;
    }
    public void setSeat(Seat seat) {
        this.seat = seat;
    }
    public Tyre getTyre() {
        return tyre;
    }
    public void setTyre(Tyre tyre) {
        this.tyre = tyre;
    }

}

class Engine {
    private String engine;// 发动机

    public Engine(String engine) {
        super();
        this.engine = engine;
    }

    public String getEngine() {
        return engine;
    }

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

}

class Seat {
    private String Seat;// 椅子

    public Seat(String seat) {
        super();
        Seat = seat;
    }

    public String getSeat() {
        return Seat;
    }

    public void setSeat(String seat) {
        Seat = seat;
    }

}

class Tyre {
    private String tyre;// 轮胎

    public Tyre(String tyre) {
        super();
        this.tyre = tyre;
    }

    public String getTyre() {
        return tyre;
    }

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

}

建造汽车的接口

package studyGFO;

public interface CarBuilder {

    Engine builderEngine();
    Seat builderSeat();
    Tyre builderTyre();

}

组装汽车的接口

package studyGFO;

public interface CarDirector {

    Car createCar();//组装汽车

}

建造汽车的实现

package studyGFO;

public class BMWCarBuilder implements CarBuilder{

    @Override
    public Engine builderEngine() {
        System.out.println("构建发动机");
        //可以运用工厂来构造这个零件 也可以单例模式构造唯一的零件
        return new Engine("宝马发动机");
    }

    @Override
    public Seat builderSeat() {
        System.out.println("构建座椅");
        return new Seat("宝马座椅");
    }

    @Override
    public Tyre builderTyre() {
        System.out.println("构建轮胎");
        return new Tyre("宝马轮胎");
    }

}

组装汽车的实现

package studyGFO;



public class BMWCarDirector implements CarDirector{

    private CarBuilder builder;



    public BMWCarDirector(CarBuilder builder) {
        super();
        this.builder = builder;
    }



    @Override
    public Car createCar() {

        Engine engine = builder.builderEngine();
        Seat seat = builder.builderSeat();
        Tyre tyre = builder.builderTyre();

        //装配汽车对象
        Car car = new Car();
        car.setEngine(engine);
        car.setSeat(seat);
        car.setTyre(tyre);

        return car;
    }

}

测试建造一个汽车

package studyGFO;

public class Client {

    public static void main(String[] args) {

        //找到组装汽车的实现类 然后再找建造汽车的实现类
        CarDirector director = new BMWCarDirector(new BMWCarBuilder());

        //调用组装汽车的方法
        Car car = director.createCar();
        //组装好一辆汽车
        System.out.println(car.getEngine().getEngine());
        car.run();
    }

}

建造汽车零件和组装汽车分离了