天天5分钟-建造者模式

建造者模式

---

什么是建造者模式呢，顾名思义，把某个东西建立出来，说得准确点是，把各类部件按照须要的方式建形成一个产品。建造者模式须要四个类，抽象建造者，具体建造者，产品类，导演类。

产品类：

public class Phone {
    //手机的部件
    private String cpu;
    private String screen;
    private String camera;
    
    //对部件的逻辑处理
    public void setCpu(String cpu) {
        this.cpu = cpu;
    }

    public void setScreen(String screen) {
        this.screen = screen;
    }
    
    public void setCamera(String camera) {
        this.camera = camera;
    }
    
    public String use() {
        return "Phone{" +
                "cpu='" + cpu + '\'' +
                ", screen=" + screen +
                ", camera=" + camera +
                '}';
    }
    
}

抽象建造者类：

public abstract class AbstractBuilder {
    
    //多个部件供咱们组合成不一样的产品
    public abstract void midCpu();
    public abstract void midScreen();
    public abstract void midCamera();
    public abstract void topCpu();
    public abstract void topScreen();
    public abstract void topCamera();

    //组合完成后返回产品类
    public abstract Phone buildPhone();

}

具体建造者类：

注意并非具体的产品，而是具体的厂商，生产不一样品牌部件的建造者，在本例中有两个具体建造者类，一个是生产一加的各部件，一个是生产魅族的各部件。

public class OnePlusBuilder extends AbstractBuilder {

    Phone phone = new Phone();

    @Override
    public void midCpu() {
        phone.setCpu("一加高配处理器");
    }

    @Override
    public void midScreen() {
        phone.setScreen("一加高配屏幕");
    }

    @Override
    public void midCamera() {
        phone.setCamera("一加高配相机");
    }

    @Override
    public void topCpu() {
        phone.setCpu("一加顶配处理器");
    }

    @Override
    public void topScreen() {
        phone.setScreen("一加顶配屏幕");
    }

    @Override
    public void topCamera() {
        phone.setCamera("一加顶配相机");
    }

    @Override
    public Phone buildPhone() {
        return phone;
    }
}

public class MeizuBuilder extends AbstractBuilder {
    Phone phone = new Phone();

    @Override
    public void midCpu() {
        phone.setCpu("魅族中配处理器");
    }

    @Override
    public void midScreen() {
        phone.setScreen("魅族中配屏幕");
    }

    @Override
    public void midCamera() {
        phone.setCamera("魅族中配相机");
    }

    @Override
    public void topCpu() {
        phone.setCpu("魅族高配处理器");
    }

    @Override
    public void topScreen() {
        phone.setScreen("魅族高配屏幕");
    }

    @Override
    public void topCamera() {
        phone.setCamera("魅族高配相机");
    }

    @Override
    public Phone buildPhone() {
        return phone;
    }
}

导演类:

导演嘛，很形象，指挥要建造什么具体的产品

public class Director {
    AbstractBuilder builder;

    public Director(AbstractBuilder builder) {
        this.builder = builder;
    }

    public Phone buildMidPhone() {
        builder.midCpu();
        builder.midCamera();
        builder.midScreen();
        return builder.buildPhone();
    }

    public Phone buildTopPhone() {
        builder.topCpu();
        builder.topCamera();
        builder.topScreen();

        return builder.buildPhone();
    }

}

如今不是都说手机是堆料嘛，导演类就负责，我可以用不一样的料，甚至一样的料不一样的堆积方法来给你堆出不一样的产品。

像上面的例子中，我有6个部件，可是不一样的部件我可以生产不一样的产品。

测试类：

public class Test {
    public static void main(String[] args) {
        Director director = new Director(new OnePlusBuilder());
        System.out.println(director.buildMidPhone().use());
        System.out.println(director.buildTopPhone().use());

        director = new Director(new MeizuBuilder());
        System.out.println(director.buildMidPhone().use());
        System.out.println(director.buildTopPhone().use());
    }
}

与工厂模式的区别：

二者比较类似，可是不一样的点仍是比较清晰。

• 工厂模式注重的是个体，你要什么手机，我就生产一部手机出来给你，没必要要关心你内部的部件是怎样组合的，一般是一个方法生产一个产品。
• 建造者模式就不同了，注重的是部件的组合，不一样的部件组合能够生产出来不同的产品，一般是几个方法的整合次啊能生产一个产品