笨蛋学设计模式创建者模式-建造者模式【5】

创建者模式-建造者模式

    • 6.4建造者模式:arrow_up::arrow_up::arrow_up:
      • 6.4.1概念
      • 6.4.2场景
      • 6.4.3优势 / 劣势
      • 6.4.4建造者模式分为
      • 6.4.5建造者模式
      • 6.4.6实战
        • 6.4.6.1题目描述
        • 6.4.6.2输入描述
        • 6.4.6.3输出描述
        • 6.4.6.4代码
      • 6.4.7总结
      • 建造者模式

6.4建造者模式⬆️⬆️⬆️

6.4.1概念

​ 建造者模式将一个复杂对象的构建和表示分离开,使得同样的构建过程可以创建不同的表示。通过将对象的创建过程抽象为一个建造者接口,并定义了创建复杂对象的方法。具体实现类可以按照一定的顺序和方式创建对象,并最终返回创建好的复杂对象


​ 与工厂模式不同的是,工厂模式注重的是创建对象,并不关注创建对象过程及结构;但是建造者模式需要了解创建对象的结构,并按照一定的顺序和方式创建这些。


6.4.2场景

​ 我们都知道建造房子这个过程是由不同的对象组成的,比如门、窗、家具、灯饰等,且都有一定的顺序,比如得先安装门、窗等,再去布局屋内。所以当我们建造房子时,会由工人(建造者)按照一定的顺序先后对房子进行建造,由于这个过程是十分复杂的,所以我们可以与工人(建造者)进行沟通,按照我们的想法去制定不同的建造顺序来建造房子。

6.4.3优势 / 劣势

  • 提高封装性:将对象的创建过程和使用分离,使得可以相互独立,提高了代码的模块化和可维护性
  • 提升扩展性:将对象的创建过程抽象为一个建造者接口,并定义创建对象的方法,不同的实现类根据需求实现接口创建不同的对象,使得建造类之间相互独立

  • 限制使用范围:要求组成部分必须相同,限制了使用范围;若对象的部分组成不同,就需要创建不同的建造者类来处理这些差异,增加了代码的复杂度

  • 增加维护成本:若对象内部组成复杂,当发生变化时,建造者也需要同步修改,维护成本大

  • 过于复杂:若对象构建过程简单,使用建造者模式可能会显得过于复杂,反而增加了代码的复杂度


6.4.4建造者模式分为

  • 产品Product:被构建的复杂对象,包含多个组成部分
  • 抽象建造者Builder:定义构建产品各个部分的抽象接口和一个返回复杂产品的方法getResult
  • 具体建造者Concrete Builder:是心啊抽象建造者接口,构建产品的各个组成部分,并提供一个方法返回最终的产品
  • 指导者Director:调用具体建造者的方法,按照一定的顺序或逻辑来构建产品

6.4.5建造者模式

package com.designpattern.mode.builder;

public class Builder {

    public static void main(String[] args) {
        //客户端使用建造者模式,在客户端创建具体建造者对象和指导者对象,通过指导者来构建产品
        //创建具体建造者
        AbstractBuilder builder = new ConcreteBuilder();
        //创建指导者
        Director director = new Director(builder);

        //指导者构建产品
        director.construct();

        //获取构建好的产品
        Product product= builder.getResult();

        //输出产品信息
        System.out.println(product);

    }
}

//产品类,包含多个组成部分,并由这些属性和方法构成产品
class Product{
    private String part1;
    private String part2;

    public String getPart1() {
        return part1;
    }

    public void setPart1(String part1) {
        this.part1 = part1;
    }

    public String getPart2() {
        return part2;
    }

    public void setPart2(String part2) {
        this.part2 = part2;
    }

    @Override
    public String toString() {
        return "Product{" +
                "part1='" + part1 + '\'' +
                ", part2='" + part2 + '\'' +
                '}';
    }
}

//抽象建造者接口,创建接口用于包含构建产品各个部分的抽象方法,用于设置产品的各个属性
interface AbstractBuilder{
    void buildPart1(String part1);
    void buildPart2(String part2);
    Product getResult();
}

//创建具体建造者,实现抽象建造者接口,构建具体的产品
class ConcreteBuilder implements AbstractBuilder{
    private Product product=new Product();

    @Override
    public void buildPart1(String part1) {
        product.setPart1(part1);
    }

    @Override
    public void buildPart2(String part2) {
        product.setPart2(part2);
    }

    @Override
    public Product getResult() {
        return product;
    }
}

//定义Director类,指导者来控制构建产品的顺序和步骤
class Director{
    private AbstractBuilder builder;

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

    //调用方法构建产品
    public void construct(){
        builder.buildPart1("构建part1");
        builder.buildPart2("构建part2");
    }
}


6.4.6实战

6.4.6.1题目描述

小明家新开了一家自行车工厂,用于使用自行车配件(车架 frame 和车轮 tires )进行组装定制不同的自行车,包括山地车和公路车。

山地车使用的是Aluminum Frame(铝制车架)和 Knobby Tires(可抓地轮胎),公路车使用的是 Carbon Frame (碳车架)和 Slim Tries。

现在它收到了一笔订单,要求定制一批自行车,请你使用【建造者模式】告诉小明这笔订单需要使用那些自行车配置吧。

6.4.6.2输入描述

输入的第一行是一个整数 N(1 ≤ N ≤ 100),表示订单的数量。

接下来的 N 行,每行输入一个字符串,字符串表示客户的自行车需求。

字符串可以包含关键词 “mountain” 或 “road”,表示客户需要山地自行车或公路自行车。

6.4.6.3输出描述

对于每笔订单,输出该订单定制的自行车配置。

6.4.6.4代码
package com.designpattern.mode.builder;

import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int nums = scanner.nextInt();
        scanner.nextLine();

        //构建指导者
        BicycleDirector bicycleDirector = new BicycleDirector();

        for(int i=0;i<nums;i++){
            String bicycleType = scanner.nextLine();
            BicycleBuilder bicycleBuilder = null;
            //根据输入的类型,分别创建不同的具体建造者
            if(bicycleType.equals("mountain")){
                bicycleBuilder=new MountainBicycle();
            }else if(bicycleType.equals("road")){
                bicycleBuilder= new RoadBicycle();
            }

            //执行生产方法构建自行车
            Bicycle bicycle = bicycleDirector.construct(bicycleBuilder);
            System.out.println(bicycle);
        }
    }
}

//定义自行车产品
class Bicycle{
    //车架
    private String frame;
    //车轮
    private String tires;

    public String getFrame() {
        return frame;
    }

    public void setFrame(String frame) {
        this.frame = frame;
    }

    public String getTires() {
        return tires;
    }

    public void setTires(String tires) {
        this.tires = tires;
    }

    @Override
    public String toString() {
        return 
                "frame='" + frame + '\'' +
                ", tires='" + tires;
    }
}

//抽象建造者,用于定义自行车的车轮和车架
interface BicycleBuilder{

    void buildFrame();

    void buildTires();

    Bicycle getResult();
}

//创建具体建造者,构建具体的产品
class MountainBicycle implements BicycleBuilder{

    private Bicycle bicycle=new Bicycle();
    @Override
    public void buildFrame() {
        bicycle.setFrame("Aluminum Frame");
    }

    @Override
    public void buildTires() {
        bicycle.setTires("Knobby Tires");
    }

    @Override
    public Bicycle getResult() {
        return bicycle;
    }
}

class RoadBicycle implements BicycleBuilder{

    private Bicycle bicycle=new Bicycle();
    @Override
    public void buildFrame() {
        bicycle.setFrame("Carbon Frame");
    }

    @Override
    public void buildTires() {
        bicycle.setTires("Slim Tires");
    }

    @Override
    public Bicycle getResult() {
        return bicycle;
    }
}

//定义指导者,指导自行车构建顺序
class BicycleDirector{

    //构建自行车
    public Bicycle construct(BicycleBuilder bicycleBuilder){
        bicycleBuilder.buildFrame();
        bicycleBuilder.buildTires();
        return bicycleBuilder.getResult();
    }

}

6.4.7总结

  • 建造者模式

优点:

  • 将⼀个复杂对象的构建与其表示分离,通过将构建复杂对象的过程抽象出来,可以使客户端代码与具体的构建过程解耦
  • 同样的构建过程可以创建不同的表示

总结:将复杂对象的构建过程与其表示分离,以使同样的构建过程可以创建不同的表示

场景:适用于构建复杂对象的场景,并且希望将构建逻辑与表示分离的情况

你可能感兴趣的:(笨蛋学设计模式,设计模式,java,建造者模式)