设计模式之建造者模式

2023-12-25 10:38:08

建造者模式

建造者模式(Builder Pattern)是一种创建型设计模式,它可以将复杂对象的构建过程与其表示分离,使得同样的构建过程可以创建不同的表示。该模式将对象的构建过程分解为多个简单的步骤,并将这些步骤按照特定的顺序进行组合,从而构建出不同的对象。

在Java中,建造者模式通常包含以下几个角色:

  1. 产品类(Product):表示被构建的复杂对象,包含多个部件;
  2. 抽象建造者类(Builder):定义了创建产品各个部件的抽象方法,以及返回产品的方法;
  3. 具体建造者类(ConcreteBuilder):实现了抽象建造者类中定义的所有方法,并且返回组装好的产品对象;
  4. 指挥者类(Director):负责调用具体建造者类中的方法来构建产品对象,它并不知道具体的建造细节。

使用建造者模式创建一份电脑配置清单:

在这里插入图片描述

Computer.java

package com.sin.pojo;

/**
 * @createTime 2023/12/21 9:40
 * @createAuthor SIN
 * @use
 */
public class Computer {
    // cpu
    private String cpu;
    // 内存
    private String memory;
    // 磁盘
    private String hardDisk;

    public void setCpu(String cpu) {
        this.cpu = cpu;
    }

    public void setMemory(String memory) {
        this.memory = memory;
    }

    public void setHardDisk(String hardDisk) {
        this.hardDisk = hardDisk;
    }

    public String toString() {
        return "电脑: CPU=" + cpu + ", 内存=" + memory + ", 磁盘=" + hardDisk;
    }

}

ComputerBuilder.java

package com.sin.builder;

import com.sin.pojo.Computer;

/**
 * @createTime 2023/12/21 9:45
 * @createAuthor SIN
 * @use 抽象建造者类
 */
public abstract class ComputerBuilder {
    protected Computer computer;

    // 创建CPU
    public abstract void buildCpu();
    // 创建内存
    public abstract void buildMemory();
    // 创建磁盘
    public abstract void buildHardDisk();

    public void createComputer(){
        computer = new Computer();
    }

    public Computer getComputer(){
        return computer;
    }
}

ComputerDirecter.java

package com.sin.director;

import com.sin.builder.ComputerBuilder;

/**
 * @createTime 2023/12/21 9:53
 * @createAuthor SIN
 * @use 指挥者类
 */
public class ComputerDirector {
    private ComputerBuilder computerBuilder;

    public ComputerDirector(ComputerBuilder computerBuilder) {
        this.computerBuilder = computerBuilder;
    }

    public void constructComputer(){
        computerBuilder.createComputer();
        computerBuilder.buildCpu();
        computerBuilder.buildMemory();
        computerBuilder.buildHardDisk();
    }
}

HighEndComputerBuilder.java

package com.sin.builder;

/**
 * @createTime 2023/12/21 9:50
 * @createAuthor SIN
 * @use 具体建造者
 */
public class HighEndComputerBuilder extends ComputerBuilder{
    @Override
    public void buildCpu() {
        computer.setCpu("英特尔酷睿i9");
    }

    @Override
    public void buildMemory() {
        computer.setMemory("32GB");
    }

    @Override
    public void buildHardDisk() {
        computer.setHardDisk("1TB");
    }
}

MidRangeComputerBuilder.java

package com.sin.builder;

/**
 * @createTime 2023/12/21 9:52
 * @createAuthor SIN
 * @use
 */
public class MidRangeComputerBuilder extends ComputerBuilder{
    @Override
    public void buildCpu() {
        super.computer.setCpu("英特尔酷睿i5");
    }

    @Override
    public void buildMemory() {
        super.computer.setMemory("16GB");
    }

    @Override
    public void buildHardDisk() {
        super.computer.setHardDisk("500GB");
    }
}

SuperComputerBuilder.java

package com.sin.builder;

/**
 * @createTime 2023/12/21 10:04
 * @createAuthor SIN
 * @use
 */
public class SuperComputerBuilder extends ComputerBuilder{
    @Override
    public void buildCpu() {
        super.computer.setCpu("AMD 锐龙5 5600G");
    }

    @Override
    public void buildMemory() {
        super.computer.setMemory("128GB");
    }

    @Override
    public void buildHardDisk() {
        super.computer.setHardDisk("10TB");
    }
}

BuilderPatternDemo.java

package com.sin.demo;

import com.sin.builder.ComputerBuilder;
import com.sin.builder.HighEndComputerBuilder;
import com.sin.builder.MidRangeComputerBuilder;
import com.sin.builder.SuperComputerBuilder;
import com.sin.director.ComputerDirector;
import com.sin.pojo.Computer;

/**
 * @createTime 2023/12/21 9:55
 * @createAuthor SIN
 * @use
 */
public class BuilderPatternDemo {

    public static void main(String[] args) {
        ComputerDirector director;
        System.out.println("----------------高端电脑----------------");
        ComputerBuilder highEndBuilder = new HighEndComputerBuilder();
        director = new ComputerDirector(highEndBuilder);
        director.constructComputer();
        Computer highEndComputer = highEndBuilder.getComputer();
        System.out.println("高端电脑配置信息:"+highEndComputer);


        System.out.println("----------------低端电脑----------------");
        ComputerBuilder midRangeBuilder = new MidRangeComputerBuilder();
        director= new ComputerDirector(midRangeBuilder);
        director.constructComputer();
        Computer midRangeComputer = midRangeBuilder.getComputer();
        System.out.println("低端电脑配置信息:"+midRangeComputer);


        System.out.println("-------------------超级电脑---------------");
        ComputerBuilder superComputerBuilder = new SuperComputerBuilder();
        director= new ComputerDirector(superComputerBuilder);
        director.constructComputer();
        Computer superComputer = superComputerBuilder.getComputer();
        System.out.println("超级电脑配置信息:"+superComputer);
    }
}

优缺点

优点:

  1. 可以使得代码结构更加清晰,易于理解和维护。
  2. 可以使得产品的构建过程与其表示分离,使得相同的构建过程可以创建不同的产品表现形式。
  3. 可以控制产品对象的组装顺序,从而更加灵活地创建复杂的对象。
  4. 可以封装复杂对象的创建和部件之间的依赖关系,使得客户端不必了解具体产品内部的实现细节。

缺点:

  1. 建造者模式需要编写较多的代码,因此会增加系统的开销和复杂度。
  2. 如果产品内部发生变化,例如添加了一个新的部件,建造者模式的代码可能需要进行较大的修改。
  3. 在某些情况下,建造者模式可能不太适用,因为它要求产品必须有一个共同的接口或者抽象类,从而限制了产品的类型。

文章来源:https://blog.csdn.net/qq_44715376/article/details/135191257
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。