Java 建造者模式

建造者模式本质：

                分离了对象的各部分组件的单独构造和组装，从而可以构造出不同的复杂对象。

 适用场景：

               在某一个对象的构造过程十分复杂的情况下，可以使用。

模式特点：

              因为分离了对象的各部分组件的单独构造和组装,所以按相同的装配顺序，但是有不同的构造器的情况下，可以创建出不同的对象,还有如果有相同的构造器，但是按不同的装配顺序，也可以创建不同的对象。

 

建造者模式的角色：

             抽象建造者角色：抽象产品对象各个组成部分的建造

             真实建造者角色：针对不同的产品对象，具体化对象各部分的建造，在建造完成之后，提供对象各部分的实例。

             抽象组装者：抽象了对对象个部分的组装

             真实组装者：具体化对对象各种组成成分的组装，组装完成后，提供完整的产品实例。

            

接下来案例中，我们以建造者模式，创建沃尔沃汽车。

//汽车，我们的产品对象
public class Car {

    private Tyre tyre; //轮胎

    private Seat  seat; //座椅

    private Engine engine; //发动机

    public Tyre getTyre() {
        return tyre;
    }

    public void setTyre(Tyre tyre) {
        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 class Tyre {

    private String tyreName;

    public Tyre(String tyreName) {
        this.tyreName = tyreName;
        Log.d("partsName","tyreName="+tyreName);
    }

    public String getTyreName() {
        return tyreName;
    }

    public void setTyreName(String tyreName) {
        this.tyreName = tyreName;
    }
}

 

//座椅，汽车组成部分
public class Seat {

    private String seatName;

    public Seat(String seatName) {
        this.seatName = seatName;
        Log.d("partsName","seatName="+seatName);
    }

    public String getSeatName() {
        return seatName;
    }

    public void setSeatName(String seatName) {
        this.seatName = seatName;
    }
}

//发动机，汽车组成部分
public class Engine {
    private String engineName;

    public Engine(String engineName) {
        this.engineName = engineName;
        Log.d("partsName","engineName="+engineName);
    }

    public String getEngineName() {
        return engineName;
    }

    public void setEngineName(String engineName) {
        this.engineName = engineName;
    }
}

//抽象建造者，抽象产品对象各个组成部分的建造
public interface CarBuilder {
    Tyre buildTyre();
    Seat buildSeat();
    Engine buildEngine();
}

//具体化产品对象的各个组成部分的建造，在建造完毕之后，提供各个组成部分的对象的实例
public class ConcreteCarBuilder implements CarBuilder{
    @Override
    public Tyre buildTyre() {
        Log.d("partsName","构建汽车轮胎");
        return new Tyre("沃尔沃的轮胎");
    }

    @Override
    public Seat buildSeat() {
        Log.d("partsName","构建汽车座椅");
        return new Seat("沃尔沃的座椅");
    }

    @Override
    public Engine buildEngine() {
        Log.d("partsName","构建汽车发动机");
        return new Engine("沃尔沃的发动机");
    }
}

//抽象组装者，抽象化对产品的组装，在组装的过程中，不涉及产品组成部分的创建，只是负责各个组成部分的实例组装起来
public interface CarDirector {
    
    Car directCar();
}

 

//真实组装者，用建造者提供的各部分的组成成分实例，组成我们的产品
//不同的组装顺序，可能会出不同的产品
public class ConcreteCarDirector  implements CarDirector{

    private CarBuilder carBuilder;

    public ConcreteCarDirector(CarBuilder carBuilder) {
        this.carBuilder = carBuilder;
    }

   //用建造者提供的产品组成部分的实例，组装我们的产品，汽车
    @Override
    public Car directCar() {

        Tyre volvoTyre=carBuilder.buildTyre();
        Seat volvoSeat=carBuilder.buildSeat();
        Engine volvoEngine=carBuilder.buildEngine();

        Car volvoCar=new Car();
        volvoCar.setTyre(volvoTyre);
        volvoCar.setSeat(volvoSeat);
        volvoCar.setEngine(volvoEngine);
        return volvoCar;
    }
}

//实例化组装者
CarDirector   carDirector=new ConcreteCarDirector(new ConcreteCarBuilder());
//组装者组装汽车各部分实例，返回完整的汽车对象
Car volvoCar=carDirector.directCar();
Log.d("partsName","tyreName="+volvoCar.getTyre().getTyreName());
Log.d("partsName","seatName="+volvoCar.getSeat().getSeatName());
Log.d("partsName","engineName="+volvoCar.getEngine().getEngineName());

结果：