Java设计模式(三)——建造者模式

建造者模式是一个对象易于扩展的设计模型，比如说一个套餐、一个游戏人物，都属于一个产品类，随着产品的不断增加，每种产品既有节本属性，也有自己独立的属性，这个时候进行产品的交付过程中，代码要易于扩展和解耦。

个人理解：建造者模式是将客户端和建造者隔离，客户端不需要知道具体的产品实现细节，各个建造者之间系统分开，完成各自负责的具体对象，易于扩展

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

UML类图如下：

从类图中可以看出，导演者角色持有抽象接口的引用，通过实例具体的Builder来实现组装产品的各个组件，最终获得产品，同时，可以看出，具体的Builder类实例化了产品类，从而可以在组件各个产品组件过程中，自定义产品属性。

角色：
director：导演角色，建造制作流程的控制者，负责各部分复杂对象被创建或者按照顺序被创建
builder：接口类，抽象对象，指明要建造的部分，不包含产品对象具体实现
Concretebuilder:具体实现建造对象，并输出复杂产品
product：最终产品

具体代码实现如下：

产品类：

public class Bike {
    private String seat;
    private String Wheel;
    private String lock;
    private String color;

    /*public Bike(NewBuiler newBuiler) {
        this.seat = newBuiler.seat;
        this.Wheel = newBuiler.Wheel;
        this.lock = newBuiler.lock;
        this.color = newBuiler.color;
    }*/
    public String getSeat() {
        return seat;
    }

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

    public String getWheel() {
        return Wheel;
    }

    public void setWheel(String wheel) {
        Wheel = wheel;
    }

    public String getLock() {
        return lock;
    }

    public void setLock(String lock) {
        this.lock = lock;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }
}

接口类针对产品组件：

public interface Mybuilder {
    public void buildseat();
    public void buildcolor();
    public void buildwheel();
    public void buidlock();

    public Bike getBike();
}

具体实现类：

public class OfoBikeBuilder implements Mybuilder {
    private Bike bike = new Bike();
    @Override
    public void buildseat() {
        bike.setSeat("seat");
    }

    @Override
    public void buildcolor() {
        bike.setColor("yellow");
    }

    @Override
    public void buildwheel() {
        bike.setWheel("wheel");
    }

    @Override
    public void buidlock() {
        bike.setLock("machine");
    }

    @Override
    public Bike getBike() {
        return bike;
    }
}

导演类：

public class MyDirector {
    private Mybuilder mybuilder;
    public MyDirector(Mybuilder mybuilder) {
        this.mybuilder = mybuilder;
    }
    public Bike construct() {
        mybuilder.buildwheel();
        mybuilder.buildseat();
        mybuilder.buidlock();
        mybuilder.buildcolor();
        return mybuilder.getBike();
    }
}

客户端：

button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                showbike(new OfoBikeBuilder());
                showbike(new MobikeBuilder());
}

private void showbike (Mybuilder mybuilder) {
        myDirector = new MyDirector(mybuilder);
        myDirector.construct();
    }

还有一种方式，在产品类中，定义内部静态Builder类，不用初始化构造方法带有很多参数，代码可读性大大增强：

public static final class NewBuiler {
        private String seat;
        private String Wheel;
        private String lock;
        private String color;

        public NewBuiler() {

        }

        public NewBuiler seat(String seat) {
            this.seat = seat;
            return this;
        }
        public NewBuiler Wheel(String wheel) {
            this.Wheel = wheel;
            return this;
        }
        public NewBuiler Lock(String lock) {
            this.lock = lock;
            return this;
        }
        public NewBuiler Color(String color) {
            this.color = color;
            return this;
        }

        public Bike builer() {
            return new Bike(this);
        }
    }
//====================
//客户端调用如下：
 Bike bike = new Bike.NewBuiler()
                        .Color("white")
                        .Lock("wifi")
                        .Wheel("wheel")
                        .seat("seat")
                        .builer();

总结：

1、建造者模式将一个复杂对象创建过程封装起来，客户端调用只需要通过实例化具体的建造者就能得到复杂对象，而不必关心具体产品的组件的实现过程。

2、产品创建过程和产品本身分离，具体产品建造者相互独立，增加或者减少相互不构成影响。

3、建造者模式依赖差异产品具有较多共同属性，如果差异增大，建造者模式将不再适用。

Java设计模式(三)——建造者模式

猜你喜欢