创建型-建造者模式

JavaBoy_XJ2025-12-20 17:33

1. 项目结构

bash 复制代码 
	builder-pattern-demo/
	├── pom.xml
	├── src/
	│   ├── main/
	│   │   ├── java/
	│   │   │   └── com/
	│   │   │       └── example/
	│   │   │           └── builder/
	│   │   │               ├── builder/
	│   │   │               │   ├── ComputerBuilder.java
	│   │   │               │   ├── GamingComputerBuilder.java
	│   │   │               │   ├── OfficeComputerBuilder.java
	│   │   │               │   └── ComputerManualBuilder.java
	│   │   │               ├── product/
	│   │   │               │   ├── Computer.java
	│   │   │               │   └── ComputerManual.java
	│   │   │               ├── components/
	│   │   │               │   ├── CPU.java
	│   │   │               │   ├── GPU.java
	│   │   │               │   ├── Memory.java
	│   │   │               │   ├── Storage.java
	│   │   │               │   └── Motherboard.java
	│   │   │               ├── director/
	│   │   │               │   └── ComputerDirector.java
	│   │   │               └── Main.java
	│   │   └── resources/
	│   └── test/
	│       └── java/
	│           └── com/
	│               └── example/
	│                   └── builder/
	│                       └── BuilderPatternTest.java

2. 代码实现

  1. Maven配置文件 (pom.xml)

    xml 复制代码 
    <?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
         http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>
    <artifactId>builder-pattern-demo</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <properties>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <!-- JUnit for testing -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

  2. 组件类（产品部件）

    CPU类 (CPU.java):

    java 复制代码 
    package com.example.builder.components;

/**
 * CPU组件
 */
public class CPU {
    private final String brand;
    private final String model;
    private final int cores;
    private final double clockSpeed; // GHz
    private final String architecture;
    
    public CPU(String brand, String model, int cores, double clockSpeed, String architecture) {
        this.brand = brand;
        this.model = model;
        this.cores = cores;
        this.clockSpeed = clockSpeed;
        this.architecture = architecture;
    }
    
    public String getBrand() {
        return brand;
    }
    
    public String getModel() {
        return model;
    }
    
    public int getCores() {
        return cores;
    }
    
    public double getClockSpeed() {
        return clockSpeed;
    }
    
    public String getArchitecture() {
        return architecture;
    }
    
    @Override
    public String toString() {
        return String.format("%s %s (%d核 %.1fGHz %s)", 
            brand, model, cores, clockSpeed, architecture);
    }
    
    public double calculatePerformanceScore() {
        return cores * clockSpeed * (architecture.equals("x64") ? 1.2 : 1.0);
    }
}

    GPU类 (GPU.java):

    java 复制代码 
    package com.example.builder.components;

/**
 * GPU组件
 */
public class GPU {
    private final String brand;
    private final String model;
    private final int vram; // GB
    private final String memoryType;
    private final boolean rayTracingSupport;
    
    public GPU(String brand, String model, int vram, String memoryType, boolean rayTracingSupport) {
        this.brand = brand;
        this.model = model;
        this.vram = vram;
        this.memoryType = memoryType;
        this.rayTracingSupport = rayTracingSupport;
    }
    
    public String getBrand() {
        return brand;
    }
    
    public String getModel() {
        return model;
    }
    
    public int getVram() {
        return vram;
    }
    
    public String getMemoryType() {
        return memoryType;
    }
    
    public boolean hasRayTracingSupport() {
        return rayTracingSupport;
    }
    
    @Override
    public String toString() {
        return String.format("%s %s %dGB %s%s", 
            brand, model, vram, memoryType, 
            rayTracingSupport ? " (支持光线追踪)" : "");
    }
    
    public double calculatePerformanceScore() {
        double score = vram * 100;
        if (memoryType.equals("GDDR6")) score *= 1.3;
        if (memoryType.equals("GDDR6X")) score *= 1.5;
        if (rayTracingSupport) score *= 1.2;
        return score;
    }
}

    内存类 (Memory.java):

    java 复制代码 
    package com.example.builder.components;

/**
 * 内存组件
 */
public class Memory {
    private final int capacity; // GB
    private final String type;
    private final int speed; // MHz
    private final int modules;
    private final boolean rgbLighting;
    
    public Memory(int capacity, String type, int speed, int modules, boolean rgbLighting) {
        this.capacity = capacity;
        this.type = type;
        this.speed = speed;
        this.modules = modules;
        this.rgbLighting = rgbLighting;
    }
    
    public int getCapacity() {
        return capacity;
    }
    
    public String getType() {
        return type;
    }
    
    public int getSpeed() {
        return speed;
    }
    
    public int getModules() {
        return modules;
    }
    
    public boolean hasRgbLighting() {
        return rgbLighting;
    }
    
    @Override
    public String toString() {
        return String.format("%dGB %s %dMHz (%d条)%s", 
            capacity, type, speed, modules, 
            rgbLighting ? " RGB灯效" : "");
    }
    
    public double calculateBandwidth() {
        return (speed * 8 * modules) / 1000.0; // GB/s
    }
}

    存储类 (Storage.java):

    java 复制代码 
    package com.example.builder.components;

/**
 * 存储组件
 */
public class Storage {
    public enum StorageType {
        HDD, SSD, NVME_SSD
    }
    
    private final StorageType type;
    private final int capacity; // GB
    private final String brand;
    private final int readSpeed; // MB/s
    private final int writeSpeed; // MB/s
    
    public Storage(StorageType type, int capacity, String brand, int readSpeed, int writeSpeed) {
        this.type = type;
        this.capacity = capacity;
        this.brand = brand;
        this.readSpeed = readSpeed;
        this.writeSpeed = writeSpeed;
    }
    
    public StorageType getType() {
        return type;
    }
    
    public int getCapacity() {
        return capacity;
    }
    
    public String getBrand() {
        return brand;
    }
    
    public int getReadSpeed() {
        return readSpeed;
    }
    
    public int getWriteSpeed() {
        return writeSpeed;
    }
    
    @Override
    public String toString() {
        String typeStr = "";
        switch (type) {
            case HDD: typeStr = "机械硬盘"; break;
            case SSD: typeStr = "固态硬盘"; break;
            case NVME_SSD: typeStr = "NVMe固态硬盘"; break;
        }
        return String.format("%s %dGB %s (读:%dMB/s 写:%dMB/s)", 
            typeStr, capacity, brand, readSpeed, writeSpeed);
    }
    
    public double calculatePerformanceScore() {
        double score = readSpeed + writeSpeed;
        if (type == StorageType.NVME_SSD) score *= 1.5;
        else if (type == StorageType.SSD) score *= 1.2;
        return score;
    }
}

    主板类 (Motherboard.java):

    java 复制代码 
    package com.example.builder.components;

/**
 * 主板组件
 */
public class Motherboard {
    private final String brand;
    private final String model;
    private final String chipset;
    private final String socket;
    private final String formFactor;
    private final int ramSlots;
    private final boolean wifiBuiltIn;
    
    public Motherboard(String brand, String model, String chipset, 
                      String socket, String formFactor, int ramSlots, 
                      boolean wifiBuiltIn) {
        this.brand = brand;
        this.model = model;
        this.chipset = chipset;
        this.socket = socket;
        this.formFactor = formFactor;
        this.ramSlots = ramSlots;
        this.wifiBuiltIn = wifiBuiltIn;
    }
    
    public String getBrand() {
        return brand;
    }
    
    public String getModel() {
        return model;
    }
    
    public String getChipset() {
        return chipset;
    }
    
    public String getSocket() {
        return socket;
    }
    
    public String getFormFactor() {
        return formFactor;
    }
    
    public int getRamSlots() {
        return ramSlots;
    }
    
    public boolean hasWifiBuiltIn() {
        return wifiBuiltIn;
    }
    
    @Override
    public String toString() {
        return String.format("%s %s (%s芯片组, %s插槽, %s板型)%s", 
            brand, model, chipset, socket, formFactor,
            wifiBuiltIn ? " 内置WiFi" : "");
    }
}

  3. 产品类

    计算机产品 (Computer.java):

    java 复制代码 
    package com.example.builder.product;

import com.example.builder.components.*;

/**
 * 计算机产品
 */
public class Computer {
    private final CPU cpu;
    private final GPU gpu;
    private final Memory memory;
    private final Storage storage;
    private final Motherboard motherboard;
    private final boolean liquidCooling;
    private final boolean rgbLighting;
    private final String operatingSystem;
    
    // 私有构造器，只能通过Builder创建
    private Computer(ComputerBuilder builder) {
        this.cpu = builder.cpu;
        this.gpu = builder.gpu;
        this.memory = builder.memory;
        this.storage = builder.storage;
        this.motherboard = builder.motherboard;
        this.liquidCooling = builder.liquidCooling;
        this.rgbLighting = builder.rgbLighting;
        this.operatingSystem = builder.operatingSystem;
    }
    
    // Getters
    public CPU getCpu() {
        return cpu;
    }
    
    public GPU getGpu() {
        return gpu;
    }
    
    public Memory getMemory() {
        return memory;
    }
    
    public Storage getStorage() {
        return storage;
    }
    
    public Motherboard getMotherboard() {
        return motherboard;
    }
    
    public boolean hasLiquidCooling() {
        return liquidCooling;
    }
    
    public boolean hasRgbLighting() {
        return rgbLighting;
    }
    
    public String getOperatingSystem() {
        return operatingSystem;
    }
    
    public double calculateTotalPerformance() {
        double cpuScore = cpu.calculatePerformanceScore();
        double gpuScore = gpu.calculatePerformanceScore();
        double memoryBandwidth = memory.calculateBandwidth();
        double storageScore = storage.calculatePerformanceScore();
        
        return cpuScore * 0.3 + gpuScore * 0.4 + memoryBandwidth * 0.15 + storageScore * 0.15;
    }
    
    public void displaySpecifications() {
        System.out.println("=== 计算机配置详情 ===");
        System.out.println("1. CPU: " + cpu);
        System.out.println("2. GPU: " + gpu);
        System.out.println("3. 内存: " + memory);
        System.out.println("4. 存储: " + storage);
        System.out.println("5. 主板: " + motherboard);
        System.out.println("6. 散热系统: " + (liquidCooling ? "水冷" : "风冷"));
        System.out.println("7. 灯光效果: " + (rgbLighting ? "RGB灯效" : "无灯效"));
        System.out.println("8. 操作系统: " + operatingSystem);
        System.out.println("9. 性能评分: " + String.format("%.1f", calculateTotalPerformance()));
        System.out.println("10. 预估价格: ¥" + String.format("%.2f", estimatePrice()));
        System.out.println("======================");
    }
    
    public double estimatePrice() {
        double price = 0;
        price += cpu.calculatePerformanceScore() * 100;
        price += gpu.calculatePerformanceScore() * 80;
        price += memory.calculateBandwidth() * 50;
        price += storage.calculatePerformanceScore() * 30;
        if (liquidCooling) price += 800;
        if (rgbLighting) price += 300;
        return price;
    }
    
    // Builder内部类（静态内部类实现）
    public static class ComputerBuilder {
        // 必需组件
        private CPU cpu;
        private GPU gpu;
        private Memory memory;
        private Storage storage;
        private Motherboard motherboard;
        
        // 可选组件/特性
        private boolean liquidCooling = false;
        private boolean rgbLighting = false;
        private String operatingSystem = "Windows 10 专业版";
        
        // 设置必需组件的方法返回Builder本身，支持链式调用
        public ComputerBuilder setCPU(CPU cpu) {
            this.cpu = cpu;
            return this;
        }
        
        public ComputerBuilder setGPU(GPU gpu) {
            this.gpu = gpu;
            return this;
        }
        
        public ComputerBuilder setMemory(Memory memory) {
            this.memory = memory;
            return this;
        }
        
        public ComputerBuilder setStorage(Storage storage) {
            this.storage = storage;
            return this;
        }
        
        public ComputerBuilder setMotherboard(Motherboard motherboard) {
            this.motherboard = motherboard;
            return this;
        }
        
        // 设置可选特性的方法
        public ComputerBuilder setLiquidCooling(boolean liquidCooling) {
            this.liquidCooling = liquidCooling;
            return this;
        }
        
        public ComputerBuilder setRgbLighting(boolean rgbLighting) {
            this.rgbLighting = rgbLighting;
            return this;
        }
        
        public ComputerBuilder setOperatingSystem(String operatingSystem) {
            this.operatingSystem = operatingSystem;
            return this;
        }
        
        // 构建方法
        public Computer build() {
            // 验证必需组件是否已设置
            validate();
            return new Computer(this);
        }
        
        private void validate() {
            if (cpu == null) {
                throw new IllegalStateException("CPU未设置");
            }
            if (gpu == null) {
                throw new IllegalStateException("GPU未设置");
            }
            if (memory == null) {
                throw new IllegalStateException("内存未设置");
            }
            if (storage == null) {
                throw new IllegalStateException("存储未设置");
            }
            if (motherboard == null) {
                throw new IllegalStateException("主板未设置");
            }
            
            // 验证兼容性
            if (!motherboard.getSocket().equals(cpu.getArchitecture())) {
                throw new IllegalStateException("CPU与主板插槽不兼容");
            }
            
            if (memory.getModules() > motherboard.getRamSlots()) {
                throw new IllegalStateException("内存条数超过主板支持");
            }
        }
    }
}

    计算机手册 (ComputerManual.java):

    java 复制代码 
    package com.example.builder.product;

import com.example.builder.components.*;

/**
 * 计算机使用手册
 */
public class ComputerManual {
    private final String cpuInstructions;
    private final String gpuInstructions;
    private final String memoryInstructions;
    private final String storageInstructions;
    private final String motherboardInstructions;
    private final String coolingInstructions;
    private final String lightingInstructions;
    private final String osInstructions;
    private final String safetyWarnings;
    
    private ComputerManual(ManualBuilder builder) {
        this.cpuInstructions = builder.cpuInstructions;
        this.gpuInstructions = builder.gpuInstructions;
        this.memoryInstructions = builder.memoryInstructions;
        this.storageInstructions = builder.storageInstructions;
        this.motherboardInstructions = builder.motherboardInstructions;
        this.coolingInstructions = builder.coolingInstructions;
        this.lightingInstructions = builder.lightingInstructions;
        this.osInstructions = builder.osInstructions;
        this.safetyWarnings = builder.safetyWarnings;
    }
    
    public void printManual() {
        System.out.println("=== 计算机使用手册 ===");
        System.out.println("\n1. CPU使用说明:");
        System.out.println(cpuInstructions);
        
        System.out.println("\n2. GPU使用说明:");
        System.out.println(gpuInstructions);
        
        System.out.println("\n3. 内存使用说明:");
        System.out.println(memoryInstructions);
        
        System.out.println("\n4. 存储设备使用说明:");
        System.out.println(storageInstructions);
        
        System.out.println("\n5. 主板使用说明:");
        System.out.println(motherboardInstructions);
        
        System.out.println("\n6. 散热系统说明:");
        System.out.println(coolingInstructions);
        
        System.out.println("\n7. 灯光系统说明:");
        System.out.println(lightingInstructions);
        
        System.out.println("\n8. 操作系统说明:");
        System.out.println(osInstructions);
        
        System.out.println("\n9. 安全警告:");
        System.out.println(safetyWarnings);
        System.out.println("=====================");
    }
    
    // Builder内部类
    public static class ManualBuilder {
        private String cpuInstructions;
        private String gpuInstructions;
        private String memoryInstructions;
        private String storageInstructions;
        private String motherboardInstructions;
        private String coolingInstructions;
        private String lightingInstructions;
        private String osInstructions;
        private String safetyWarnings = "标准安全警告";
        
        public ManualBuilder setCpuInstructions(String instructions) {
            this.cpuInstructions = instructions;
            return this;
        }
        
        public ManualBuilder setGpuInstructions(String instructions) {
            this.gpuInstructions = instructions;
            return this;
        }
        
        public ManualBuilder setMemoryInstructions(String instructions) {
            this.memoryInstructions = instructions;
            return this;
        }
        
        public ManualBuilder setStorageInstructions(String instructions) {
            this.storageInstructions = instructions;
            return this;
        }
        
        public ManualBuilder setMotherboardInstructions(String instructions) {
            this.motherboardInstructions = instructions;
            return this;
        }
        
        public ManualBuilder setCoolingInstructions(String instructions) {
            this.coolingInstructions = instructions;
            return this;
        }
        
        public ManualBuilder setLightingInstructions(String instructions) {
            this.lightingInstructions = instructions;
            return this;
        }
        
        public ManualBuilder setOsInstructions(String instructions) {
            this.osInstructions = instructions;
            return this;
        }
        
        public ManualBuilder setSafetyWarnings(String warnings) {
            this.safetyWarnings = warnings;
            return this;
        }
        
        public ComputerManual build() {
            return new ComputerManual(this);
        }
    }
}

  4. 建造者接口和具体建造者

    抽象建造者接口 (ComputerBuilder.java):

    java 复制代码 
    package com.example.builder.builder;

import com.example.builder.components.*;
import com.example.builder.product.Computer;

/**
 * 抽象建造者接口
 * 定义创建计算机各个部件的方法
 */
public interface ComputerBuilder {
    ComputerBuilder setCPU(CPU cpu);
    ComputerBuilder setGPU(GPU gpu);
    ComputerBuilder setMemory(Memory memory);
    ComputerBuilder setStorage(Storage storage);
    ComputerBuilder setMotherboard(Motherboard motherboard);
    ComputerBuilder setLiquidCooling(boolean liquidCooling);
    ComputerBuilder setRgbLighting(boolean rgbLighting);
    ComputerBuilder setOperatingSystem(String operatingSystem);
    Computer build();
    void reset();
    Computer getResult();
}

    游戏电脑建造者 (GamingComputerBuilder.java):

    java 复制代码 
    package com.example.builder.builder;

import com.example.builder.components.*;
import com.example.builder.product.Computer;

/**
 * 具体建造者：游戏电脑建造者
 */
public class GamingComputerBuilder implements ComputerBuilder {
    private Computer computer;
    
    public GamingComputerBuilder() {
        reset();
    }
    
    @Override
    public void reset() {
        this.computer = null;
    }
    
    @Override
    public ComputerBuilder setCPU(CPU cpu) {
        // 游戏电脑通常需要高性能CPU
        System.out.println("设置游戏电脑CPU: " + cpu);
        Computer.ComputerBuilder builder = getComputerBuilder();
        builder.setCPU(cpu);
        return this;
    }
    
    @Override
    public ComputerBuilder setGPU(GPU gpu) {
        // 游戏电脑需要高性能GPU
        System.out.println("设置游戏电脑GPU: " + gpu);
        Computer.ComputerBuilder builder = getComputerBuilder();
        builder.setGPU(gpu);
        return this;
    }
    
    @Override
    public ComputerBuilder setMemory(Memory memory) {
        // 游戏电脑通常需要大容量高速内存
        System.out.println("设置游戏电脑内存: " + memory);
        Computer.ComputerBuilder builder = getComputerBuilder();
        builder.setMemory(memory);
        return this;
    }
    
    @Override
    public ComputerBuilder setStorage(Storage storage) {
        // 游戏电脑需要高速存储
        System.out.println("设置游戏电脑存储: " + storage);
        Computer.ComputerBuilder builder = getComputerBuilder();
        builder.setStorage(storage);
        return this;
    }
    
    @Override
    public ComputerBuilder setMotherboard(Motherboard motherboard) {
        // 游戏电脑需要支持超频的主板
        System.out.println("设置游戏电脑主板: " + motherboard);
        Computer.ComputerBuilder builder = getComputerBuilder();
        builder.setMotherboard(motherboard);
        return this;
    }
    
    @Override
    public ComputerBuilder setLiquidCooling(boolean liquidCooling) {
        // 游戏电脑通常配备水冷
        System.out.println("设置游戏电脑水冷: " + (liquidCooling ? "是" : "否"));
        Computer.ComputerBuilder builder = getComputerBuilder();
        builder.setLiquidCooling(liquidCooling);
        return this;
    }
    
    @Override
    public ComputerBuilder setRgbLighting(boolean rgbLighting) {
        // 游戏电脑通常有RGB灯效
        System.out.println("设置游戏电脑RGB灯效: " + (rgbLighting ? "是" : "否"));
        Computer.ComputerBuilder builder = getComputerBuilder();
        builder.setRgbLighting(rgbLighting);
        return this;
    }
    
    @Override
    public ComputerBuilder setOperatingSystem(String operatingSystem) {
        System.out.println("设置游戏电脑操作系统: " + operatingSystem);
        Computer.ComputerBuilder builder = getComputerBuilder();
        builder.setOperatingSystem(operatingSystem);
        return this;
    }
    
    @Override
    public Computer build() {
        if (this.computer == null) {
            Computer.ComputerBuilder builder = getComputerBuilder();
            this.computer = builder.build();
        }
        System.out.println("游戏电脑构建完成!");
        return this.computer;
    }
    
    @Override
    public Computer getResult() {
        return this.computer;
    }
    
    private Computer.ComputerBuilder getComputerBuilder() {
        return new Computer.ComputerBuilder();
    }
    
    // 预设的高端游戏配置
    public Computer buildHighEndGamingPC() {
        reset();
        System.out.println("\n开始构建高端游戏电脑...");
        
        CPU cpu = new CPU("Intel", "i9-13900K", 24, 5.8, "x64");
        GPU gpu = new GPU("NVIDIA", "RTX 4090", 24, "GDDR6X", true);
        Memory memory = new Memory(64, "DDR5", 6400, 2, true);
        Storage storage = new Storage(Storage.StorageType.NVME_SSD, 2048, "Samsung", 7000, 5000);
        Motherboard motherboard = new Motherboard("ASUS", "ROG MAXIMUS Z790", 
                                                 "Z790", "x64", "ATX", 4, true);
        
        return setCPU(cpu)
              .setGPU(gpu)
              .setMemory(memory)
              .setStorage(storage)
              .setMotherboard(motherboard)
              .setLiquidCooling(true)
              .setRgbLighting(true)
              .setOperatingSystem("Windows 11 专业版")
              .build();
    }
    
    // 预设的中端游戏配置
    public Computer buildMidRangeGamingPC() {
        reset();
        System.out.println("\n开始构建中端游戏电脑...");
        
        CPU cpu = new CPU("AMD", "Ryzen 7 7700X", 8, 5.4, "x64");
        GPU gpu = new GPU("NVIDIA", "RTX 4070", 12, "GDDR6X", true);
        Memory memory = new Memory(32, "DDR5", 6000, 2, true);
        Storage storage = new Storage(Storage.StorageType.NVME_SSD, 1024, "Kingston", 5000, 4000);
        Motherboard motherboard = new Motherboard("MSI", "MAG B650", 
                                                 "B650", "x64", "ATX", 4, true);
        
        return setCPU(cpu)
              .setGPU(gpu)
              .setMemory(memory)
              .setStorage(storage)
              .setMotherboard(motherboard)
              .setLiquidCooling(false)
              .setRgbLighting(true)
              .setOperatingSystem("Windows 11 家庭版")
              .build();
    }
}

    办公电脑建造者 (OfficeComputerBuilder.java):

    java 复制代码 
    package com.example.builder.builder;

import com.example.builder.components.*;
import com.example.builder.product.Computer;

/**
 * 具体建造者：办公电脑建造者
 */
public class OfficeComputerBuilder implements ComputerBuilder {
    private Computer computer;
    
    public OfficeComputerBuilder() {
        reset();
    }
    
    @Override
    public void reset() {
        this.computer = null;
    }
    
    @Override
    public ComputerBuilder setCPU(CPU cpu) {
        // 办公电脑需要稳定可靠的CPU
        System.out.println("设置办公电脑CPU: " + cpu);
        Computer.ComputerBuilder builder = getComputerBuilder();
        builder.setCPU(cpu);
        return this;
    }
    
    @Override
    public ComputerBuilder setGPU(GPU gpu) {
        // 办公电脑通常使用集成显卡或入门级独显
        System.out.println("设置办公电脑GPU: " + gpu);
        Computer.ComputerBuilder builder = getComputerBuilder();
        builder.setGPU(gpu);
        return this;
    }
    
    @Override
    public ComputerBuilder setMemory(Memory memory) {
        // 办公电脑需要足够内存
        System.out.println("设置办公电脑内存: " + memory);
        Computer.ComputerBuilder builder = getComputerBuilder();
        builder.setMemory(memory);
        return this;
    }
    
    @Override
    public ComputerBuilder setStorage(Storage storage) {
        // 办公电脑需要大容量可靠存储
        System.out.println("设置办公电脑存储: " + storage);
        Computer.ComputerBuilder builder = getComputerBuilder();
        builder.setStorage(storage);
        return this;
    }
    
    @Override
    public ComputerBuilder setMotherboard(Motherboard motherboard) {
        // 办公电脑需要稳定可靠的主板
        System.out.println("设置办公电脑主板: " + motherboard);
        Computer.ComputerBuilder builder = getComputerBuilder();
        builder.setMotherboard(motherboard);
        return this;
    }
    
    @Override
    public ComputerBuilder setLiquidCooling(boolean liquidCooling) {
        // 办公电脑通常不需要水冷
        System.out.println("设置办公电脑水冷: " + (liquidCooling ? "是" : "否"));
        Computer.ComputerBuilder builder = getComputerBuilder();
        builder.setLiquidCooling(liquidCooling);
        return this;
    }
    
    @Override
    public ComputerBuilder setRgbLighting(boolean rgbLighting) {
        // 办公电脑通常不需要RGB灯效
        System.out.println("设置办公电脑RGB灯效: " + (rgbLighting ? "是" : "否"));
        Computer.ComputerBuilder builder = getComputerBuilder();
        builder.setRgbLighting(rgbLighting);
        return this;
    }
    
    @Override
    public ComputerBuilder setOperatingSystem(String operatingSystem) {
        System.out.println("设置办公电脑操作系统: " + operatingSystem);
        Computer.ComputerBuilder builder = getComputerBuilder();
        builder.setOperatingSystem(operatingSystem);
        return this;
    }
    
    @Override
    public Computer build() {
        if (this.computer == null) {
            Computer.ComputerBuilder builder = getComputerBuilder();
            this.computer = builder.build();
        }
        System.out.println("办公电脑构建完成!");
        return this.computer;
    }
    
    @Override
    public Computer getResult() {
        return this.computer;
    }
    
    private Computer.ComputerBuilder getComputerBuilder() {
        return new Computer.ComputerBuilder();
    }
    
    // 预设的高性能办公配置
    public Computer buildHighPerformanceOfficePC() {
        reset();
        System.out.println("\n开始构建高性能办公电脑...");
        
        CPU cpu = new CPU("Intel", "i7-13700", 16, 5.2, "x64");
        GPU gpu = new GPU("Intel", "UHD Graphics 770", 0, "集成显卡", false);
        Memory memory = new Memory(32, "DDR4", 3200, 2, false);
        Storage storage = new Storage(Storage.StorageType.SSD, 1024, "Western Digital", 500, 400);
        Motherboard motherboard = new Motherboard("Gigabyte", "B760M", 
                                                 "B760", "x64", "Micro-ATX", 2, true);
        
        return setCPU(cpu)
              .setGPU(gpu)
              .setMemory(memory)
              .setStorage(storage)
              .setMotherboard(motherboard)
              .setLiquidCooling(false)
              .setRgbLighting(false)
              .setOperatingSystem("Windows 11 专业版")
              .build();
    }
    
    // 预设的经济型办公配置
    public Computer buildBudgetOfficePC() {
        reset();
        System.out.println("\n开始构建经济型办公电脑...");
        
        CPU cpu = new CPU("AMD", "Ryzen 5 5600G", 6, 4.4, "x64");
        GPU gpu = new GPU("AMD", "Radeon Graphics", 0, "集成显卡", false);
        Memory memory = new Memory(16, "DDR4", 3200, 1, false);
        Storage storage = new Storage(Storage.StorageType.SSD, 512, "Kingston", 500, 400);
        Motherboard motherboard = new Motherboard("ASRock", "B550M-HDV", 
                                                 "B550", "x64", "Micro-ATX", 2, false);
        
        return setCPU(cpu)
              .setGPU(gpu)
              .setMemory(memory)
              .setStorage(storage)
              .setMotherboard(motherboard)
              .setLiquidCooling(false)
              .setRgbLighting(false)
              .setOperatingSystem("Windows 10 专业版")
              .build();
    }
}

    手册建造者 (ComputerManualBuilder.java):

    java 复制代码 
    package com.example.builder.builder;

import com.example.builder.product.ComputerManual;

/**
 * 手册建造者
 */
public class ComputerManualBuilder {
    
    public ComputerManual buildGamingComputerManual() {
        System.out.println("创建游戏电脑手册...");
        
        return new ComputerManual.ManualBuilder()
            .setCpuInstructions("高性能CPU，支持超频。建议保持良好散热。")
            .setGpuInstructions("高端独立显卡，支持光线追踪。安装最新驱动程序以获得最佳性能。")
            .setMemoryInstructions("高频大容量内存，已启用XMP配置文件。")
            .setStorageInstructions("高速NVMe SSD，提供极速读写性能。")
            .setMotherboardInstructions("支持超频的高端主板，具有丰富的扩展接口。")
            .setCoolingInstructions("水冷散热系统，确保高性能运行时的稳定温度。")
            .setLightingInstructions("RGB灯光系统，可通过软件控制灯光效果。")
            .setOsInstructions("Windows 11专业版，已激活所有功能。")
            .setSafetyWarnings("请勿在高温环境下长时间满载运行。定期清洁散热器。")
            .build();
    }
    
    public ComputerManual buildOfficeComputerManual() {
        System.out.println("创建办公电脑手册...");
        
        return new ComputerManual.ManualBuilder()
            .setCpuInstructions("高效能CPU，提供稳定的计算性能。")
            .setGpuInstructions("集成显卡，满足日常办公需求。")
            .setMemoryInstructions("足够容量的内存，支持多任务处理。")
            .setStorageInstructions("可靠的大容量存储，确保数据安全。")
            .setMotherboardInstructions("稳定可靠的主板，提供基本的扩展功能。")
            .setCoolingInstructions("风冷散热系统，确保稳定运行。")
            .setLightingInstructions("无灯光效果，专注于办公环境。")
            .setOsInstructions("Windows专业版，已安装办公软件。")
            .setSafetyWarnings("定期备份重要数据。避免在灰尘多的环境中使用。")
            .build();
    }
}

  5. 指挥者 (ComputerDirector.java)

    java 复制代码 
    package com.example.builder.director;

import com.example.builder.builder.ComputerBuilder;
import com.example.builder.components.*;
import com.example.builder.product.Computer;

/**
 * 指挥者：控制构建过程
 */
public class ComputerDirector {
    private ComputerBuilder builder;
    
    public ComputerDirector(ComputerBuilder builder) {
        this.builder = builder;
    }
    
    public void setBuilder(ComputerBuilder builder) {
        this.builder = builder;
    }
    
    /**
     * 构建标准游戏电脑
     */
    public Computer buildStandardGamingComputer() {
        System.out.println("\n指挥者：构建标准游戏电脑");
        
        CPU cpu = new CPU("Intel", "i5-13600K", 14, 5.1, "x64");
        GPU gpu = new GPU("NVIDIA", "RTX 4060 Ti", 8, "GDDR6", true);
        Memory memory = new Memory(32, "DDR5", 6000, 2, true);
        Storage storage = new Storage(Storage.StorageType.NVME_SSD, 1024, "Samsung", 3500, 3000);
        Motherboard motherboard = new Motherboard("MSI", "B760", "B760", "x64", "ATX", 4, true);
        
        return builder.setCPU(cpu)
                     .setGPU(gpu)
                     .setMemory(memory)
                     .setStorage(storage)
                     .setMotherboard(motherboard)
                     .setLiquidCooling(true)
                     .setRgbLighting(true)
                     .setOperatingSystem("Windows 11 家庭版")
                     .build();
    }
    
    /**
     * 构建标准办公电脑
     */
    public Computer buildStandardOfficeComputer() {
        System.out.println("\n指挥者：构建标准办公电脑");
        
        CPU cpu = new CPU("Intel", "i5-13400", 10, 4.6, "x64");
        GPU gpu = new GPU("Intel", "UHD Graphics 730", 0, "集成显卡", false);
        Memory memory = new Memory(16, "DDR4", 3200, 1, false);
        Storage storage = new Storage(Storage.StorageType.SSD, 512, "Western Digital", 500, 400);
        Motherboard motherboard = new Motherboard("ASUS", "H610", "H610", "x64", "Micro-ATX", 2, false);
        
        return builder.setCPU(cpu)
                     .setGPU(gpu)
                     .setMemory(memory)
                     .setStorage(storage)
                     .setMotherboard(motherboard)
                     .setLiquidCooling(false)
                     .setRgbLighting(false)
                     .setOperatingSystem("Windows 10 专业版")
                     .build();
    }
    
    /**
     * 构建自定义电脑
     */
    public Computer buildCustomComputer(CPU cpu, GPU gpu, Memory memory, 
                                       Storage storage, Motherboard motherboard,
                                       boolean liquidCooling, boolean rgbLighting,
                                       String os) {
        System.out.println("\n指挥者：构建自定义电脑");
        
        return builder.setCPU(cpu)
                     .setGPU(gpu)
                     .setMemory(memory)
                     .setStorage(storage)
                     .setMotherboard(motherboard)
                     .setLiquidCooling(liquidCooling)
                     .setRgbLighting(rgbLighting)
                     .setOperatingSystem(os)
                     .build();
    }
}

  6. 主程序 (Main.java)

    java 复制代码 
    package com.example.builder;

import com.example.builder.builder.ComputerManualBuilder;
import com.example.builder.builder.GamingComputerBuilder;
import com.example.builder.builder.OfficeComputerBuilder;
import com.example.builder.components.*;
import com.example.builder.director.ComputerDirector;
import com.example.builder.product.Computer;
import com.example.builder.product.ComputerManual;

/**
 * 主程序
 * 演示建造者模式的使用
 */
public class Main {
    
    /**
     * 演示直接使用Builder模式（静态内部类方式）
     */
    private static void demonstrateStaticBuilder() {
        System.out.println("\n" + "=".repeat(60));
        System.out.println("演示：使用静态内部类Builder");
        System.out.println("=".repeat(60));
        
        // 创建组件
        CPU cpu = new CPU("AMD", "Ryzen 9 7950X", 16, 5.7, "x64");
        GPU gpu = new GPU("AMD", "RX 7900 XTX", 24, "GDDR6", true);
        Memory memory = new Memory(64, "DDR5", 6000, 4, true);
        Storage storage = new Storage(Storage.StorageType.NVME_SSD, 4096, "Samsung", 7000, 5000);
        Motherboard motherboard = new Motherboard("ASUS", "ROG X670E", 
                                                 "X670E", "x64", "ATX", 4, true);
        
        // 使用Builder创建计算机（链式调用）
        Computer computer = new Computer.ComputerBuilder()
            .setCPU(cpu)
            .setGPU(gpu)
            .setMemory(memory)
            .setStorage(storage)
            .setMotherboard(motherboard)
            .setLiquidCooling(true)
            .setRgbLighting(true)
            .setOperatingSystem("Windows 11 专业版")
            .build();
        
        System.out.println("\n使用静态Builder创建的计算机：");
        computer.displaySpecifications();
    }
    
    /**
     * 演示具体建造者模式
     */
    private static void demonstrateConcreteBuilders() {
        System.out.println("\n" + "=".repeat(60));
        System.out.println("演示：使用具体建造者");
        System.out.println("=".repeat(60));
        
        // 使用游戏电脑建造者
        GamingComputerBuilder gamingBuilder = new GamingComputerBuilder();
        Computer gamingPC = gamingBuilder.buildHighEndGamingPC();
        System.out.println("\n高端游戏电脑配置：");
        gamingPC.displaySpecifications();
        
        // 使用办公电脑建造者
        OfficeComputerBuilder officeBuilder = new OfficeComputerBuilder();
        Computer officePC = officeBuilder.buildHighPerformanceOfficePC();
        System.out.println("\n高性能办公电脑配置：");
        officePC.displaySpecifications();
    }
    
    /**
     * 演示指挥者模式
     */
    private static void demonstrateDirector() {
        System.out.println("\n" + "=".repeat(60));
        System.out.println("演示：使用指挥者控制构建过程");
        System.out.println("=".repeat(60));
        
        // 创建建造者
        GamingComputerBuilder gamingBuilder = new GamingComputerBuilder();
        OfficeComputerBuilder officeBuilder = new OfficeComputerBuilder();
        
        // 创建指挥者
        ComputerDirector director = new ComputerDirector(gamingBuilder);
        
        // 指挥者构建标准游戏电脑
        Computer standardGamingPC = director.buildStandardGamingComputer();
        System.out.println("\n标准游戏电脑配置：");
        standardGamingPC.displaySpecifications();
        
        // 切换建造者
        director.setBuilder(officeBuilder);
        
        // 指挥者构建标准办公电脑
        Computer standardOfficePC = director.buildStandardOfficeComputer();
        System.out.println("\n标准办公电脑配置：");
        standardOfficePC.displaySpecifications();
        
        // 指挥者构建自定义电脑
        CPU customCPU = new CPU("Intel", "i9-12900K", 16, 5.2, "x64");
        GPU customGPU = new GPU("NVIDIA", "RTX 3080", 10, "GDDR6X", true);
        Memory customMemory = new Memory(64, "DDR4", 3600, 4, true);
        Storage customStorage = new Storage(Storage.StorageType.NVME_SSD, 2048, "Samsung", 3500, 3000);
        Motherboard customMotherboard = new Motherboard("ASUS", "ROG Z690", 
                                                       "Z690", "x64", "ATX", 4, true);
        
        Computer customPC = director.buildCustomComputer(
            customCPU, customGPU, customMemory, customStorage, customMotherboard,
            true, true, "Windows 11 专业版"
        );
        
        System.out.println("\n自定义电脑配置：");
        customPC.displaySpecifications();
    }
    
    /**
     * 演示手册建造者
     */
    private static void demonstrateManualBuilder() {
        System.out.println("\n" + "=".repeat(60));
        System.out.println("演示：使用手册建造者");
        System.out.println("=".repeat(60));
        
        ComputerManualBuilder manualBuilder = new ComputerManualBuilder();
        
        // 创建游戏电脑手册
        ComputerManual gamingManual = manualBuilder.buildGamingComputerManual();
        System.out.println("\n游戏电脑使用手册：");
        gamingManual.printManual();
        
        // 创建办公电脑手册
        ComputerManual officeManual = manualBuilder.buildOfficeComputerManual();
        System.out.println("\n办公电脑使用手册：");
        officeManual.printManual();
    }
    
    /**
     * 演示构建过程灵活性
     */
    private static void demonstrateFlexibility() {
        System.out.println("\n" + "=".repeat(60));
        System.out.println("演示：构建过程的灵活性");
        System.out.println("=".repeat(60));
        
        // 逐步构建电脑
        System.out.println("\n逐步构建电脑（分步设置）：");
        
        Computer.ComputerBuilder stepBuilder = new Computer.ComputerBuilder();
        
        // 第一步：设置CPU
        stepBuilder.setCPU(new CPU("Intel", "i5-12400", 6, 4.4, "x64"));
        System.out.println("已设置CPU");
        
        // 第二步：设置GPU
        stepBuilder.setGPU(new GPU("NVIDIA", "GTX 1660 Super", 6, "GDDR6", false));
        System.out.println("已设置GPU");
        
        // 第三步：设置内存
        stepBuilder.setMemory(new Memory(16, "DDR4", 3200, 2, false));
        System.out.println("已设置内存");
        
        // 第四步：设置存储
        stepBuilder.setStorage(new Storage(Storage.StorageType.SSD, 512, "Kingston", 500, 400));
        System.out.println("已设置存储");
        
        // 第五步：设置主板
        stepBuilder.setMotherboard(new Motherboard("ASUS", "PRIME B660", 
                                                  "B660", "x64", "Micro-ATX", 2, false));
        System.out.println("已设置主板");
        
        // 可选设置
        stepBuilder.setLiquidCooling(false)
                   .setRgbLighting(false)
                   .setOperatingSystem("Windows 10 家庭版");
        
        // 构建电脑
        Computer stepByStepPC = stepBuilder.build();
        System.out.println("\n逐步构建的电脑配置：");
        stepByStepPC.displaySpecifications();
        
        // 重用Builder
        System.out.println("\n重用Builder创建另一台电脑：");
        
        Computer anotherPC = new Computer.ComputerBuilder()
            .setCPU(new CPU("AMD", "Ryzen 5 5600", 6, 4.4, "x64"))
            .setGPU(new GPU("AMD", "RX 6600", 8, "GDDR6", false))
            .setMemory(new Memory(32, "DDR4", 3600, 2, false))
            .setStorage(new Storage(Storage.StorageType.NVME_SSD, 1024, "WD Black", 2300, 1800))
            .setMotherboard(new Motherboard("MSI", "B550", "B550", "x64", "ATX", 4, true))
            .setLiquidCooling(false)
            .setRgbLighting(true)
            .setOperatingSystem("Windows 11 家庭版")
            .build();
        
        anotherPC.displaySpecifications();
    }
    
    /**
     * 演示验证机制
     */
    private static void demonstrateValidation() {
        System.out.println("\n" + "=".repeat(60));
        System.out.println("演示：Builder的验证机制");
        System.out.println("=".repeat(60));
        
        try {
            System.out.println("\n尝试构建缺少必需组件的电脑：");
            
            // 缺少CPU
            Computer invalidPC = new Computer.ComputerBuilder()
                .setGPU(new GPU("NVIDIA", "RTX 3060", 12, "GDDR6", true))
                .setMemory(new Memory(16, "DDR4", 3200, 2, false))
                // 缺少CPU、存储和主板
                .build();
                
        } catch (IllegalStateException e) {
            System.out.println("验证失败: " + e.getMessage());
        }
        
        try {
            System.out.println("\n尝试构建兼容性有问题的电脑：");
            
            // CPU与主板不兼容
            Computer incompatiblePC = new Computer.ComputerBuilder()
                .setCPU(new CPU("AMD", "Ryzen 9 7950X", 16, 5.7, "AM5"))
                .setGPU(new GPU("NVIDIA", "RTX 4090", 24, "GDDR6X", true))
                .setMemory(new Memory(64, "DDR5", 6000, 4, true))
                .setStorage(new Storage(Storage.StorageType.NVME_SSD, 2048, "Samsung", 7000, 5000))
                .setMotherboard(new Motherboard("ASUS", "ROG Z790", 
                                               "Z790", "LGA1700", "ATX", 4, true)) // 插槽不匹配
                .setLiquidCooling(true)
                .setRgbLighting(true)
                .setOperatingSystem("Windows 11 专业版")
                .build();
                
        } catch (IllegalStateException e) {
            System.out.println("兼容性检查失败: " + e.getMessage());
        }
    }
    
    public static void main(String[] args) {
        System.out.println("========== 建造者模式演示 ==========");
        System.out.println("模式说明:");
        System.out.println("1. 分离复杂对象的构建和表示");
        System.out.println("2. 允许相同的构建过程创建不同的表示");
        System.out.println("3. 提供更精细的控制构建过程");
        System.out.println("4. 提高代码可读性和可维护性");
        
        // 演示各种用法
        demonstrateStaticBuilder();
        demonstrateConcreteBuilders();
        demonstrateDirector();
        demonstrateManualBuilder();
        demonstrateFlexibility();
        demonstrateValidation();
        
        System.out.println("\n" + "=".repeat(60));
        System.out.println("模式优势总结:");
        System.out.println("1. 封装复杂对象的构建过程");
        System.out.println("2. 允许对象分步构建");
        System.out.println("3. 隔离构建和表示代码");
        System.out.println("4. 提供更好的控制构建过程");
        System.out.println("5. 提高代码复用性");
        System.out.println("6. 支持构建过程的验证");
        System.out.println("=".repeat(60));
    }
}

  7. 单元测试 (BuilderPatternTest.java)

    java 复制代码 
    package com.example.builder;

import com.example.builder.builder.GamingComputerBuilder;
import com.example.builder.builder.OfficeComputerBuilder;
import com.example.builder.components.*;
import com.example.builder.director.ComputerDirector;
import com.example.builder.product.Computer;
import org.junit.Test;
import static org.junit.Assert.*;

/**
 * 建造者模式单元测试
 */
public class BuilderPatternTest {
    
    @Test
    public void testStaticBuilderCreatesValidComputer() {
        CPU cpu = new CPU("Intel", "i5-12400", 6, 4.4, "x64");
        GPU gpu = new GPU("NVIDIA", "RTX 3060", 12, "GDDR6", true);
        Memory memory = new Memory(16, "DDR4", 3200, 2, false);
        Storage storage = new Storage(Storage.StorageType.SSD, 512, "Samsung", 500, 400);
        Motherboard motherboard = new Motherboard("ASUS", "B660", "B660", "x64", "ATX", 4, true);
        
        Computer computer = new Computer.ComputerBuilder()
            .setCPU(cpu)
            .setGPU(gpu)
            .setMemory(memory)
            .setStorage(storage)
            .setMotherboard(motherboard)
            .setLiquidCooling(false)
            .setRgbLighting(false)
            .setOperatingSystem("Windows 11")
            .build();
        
        assertNotNull("计算机不应为null", computer);
        assertEquals("CPU应匹配", cpu, computer.getCpu());
        assertEquals("GPU应匹配", gpu, computer.getGpu());
        assertEquals("内存应匹配", memory, computer.getMemory());
        assertEquals("存储应匹配", storage, computer.getStorage());
        assertEquals("主板应匹配", motherboard, computer.getMotherboard());
        assertFalse("不应有水冷", computer.hasLiquidCooling());
        assertFalse("不应有RGB灯效", computer.hasRgbLighting());
        assertEquals("操作系统应匹配", "Windows 11", computer.getOperatingSystem());
    }
    
    @Test(expected = IllegalStateException.class)
    public void testBuilderValidationMissingComponent() {
        // 缺少必需组件
        Computer computer = new Computer.ComputerBuilder()
            .setCPU(new CPU("Intel", "i5", 4, 3.5, "x64"))
            // 缺少GPU、内存、存储、主板
            .build();
    }
    
    @Test
    public void testGamingComputerBuilderCreatesGamingPC() {
        GamingComputerBuilder builder = new GamingComputerBuilder();
        Computer gamingPC = builder.buildMidRangeGamingPC();
        
        assertNotNull("游戏电脑不应为null", gamingPC);
        assertTrue("游戏电脑应有较高性能", gamingPC.calculateTotalPerformance() > 5000);
        assertEquals("应为Windows 11家庭版", "Windows 11 家庭版", gamingPC.getOperatingSystem());
    }
    
    @Test
    public void testOfficeComputerBuilderCreatesOfficePC() {
        OfficeComputerBuilder builder = new OfficeComputerBuilder();
        Computer officePC = builder.buildBudgetOfficePC();
        
        assertNotNull("办公电脑不应为null", officePC);
        assertTrue("办公电脑使用集成显卡", officePC.getGpu().getBrand().equals("AMD"));
        assertFalse("办公电脑不应有水冷", officePC.hasLiquidCooling());
        assertFalse("办公电脑不应有RGB灯效", officePC.hasRgbLighting());
    }
    
    @Test
    public void testDirectorBuildsComputers() {
        GamingComputerBuilder gamingBuilder = new GamingComputerBuilder();
        ComputerDirector director = new ComputerDirector(gamingBuilder);
        
        Computer gamingPC = director.buildStandardGamingComputer();
        
        assertNotNull("标准游戏电脑不应为null", gamingPC);
        assertTrue("标准游戏电脑应有GPU", gamingPC.getGpu() != null);
        assertEquals("应为Windows 11家庭版", "Windows 11 家庭版", gamingPC.getOperatingSystem());
    }
    
    @Test
    public void testComputerPerformanceCalculation() {
        CPU cpu = new CPU("Intel", "i9-13900K", 24, 5.8, "x64");
        GPU gpu = new GPU("NVIDIA", "RTX 4090", 24, "GDDR6X", true);
        Memory memory = new Memory(64, "DDR5", 6400, 2, true);
        Storage storage = new Storage(Storage.StorageType.NVME_SSD, 2048, "Samsung", 7000, 5000);
        Motherboard motherboard = new Motherboard("ASUS", "ROG Z790", "Z790", "x64", "ATX", 4, true);
        
        Computer highEndPC = new Computer.ComputerBuilder()
            .setCPU(cpu)
            .setGPU(gpu)
            .setMemory(memory)
            .setStorage(storage)
            .setMotherboard(motherboard)
            .setLiquidCooling(true)
            .setRgbLighting(true)
            .setOperatingSystem("Windows 11 专业版")
            .build();
        
        double performance = highEndPC.calculateTotalPerformance();
        assertTrue("高性能电脑应有高评分", performance > 10000);
        
        double price = highEndPC.estimatePrice();
        assertTrue("高性能电脑价格应较高", price > 10000);
    }
    
    @Test
    public void testComponentPerformanceMethods() {
        CPU cpu = new CPU("AMD", "Ryzen 7 5800X", 8, 4.7, "x64");
        GPU gpu = new GPU("NVIDIA", "RTX 3070", 8, "GDDR6", true);
        Memory memory = new Memory(32, "DDR4", 3600, 2, false);
        Storage storage = new Storage(Storage.StorageType.NVME_SSD, 1024, "Samsung", 3500, 3000);
        
        double cpuScore = cpu.calculatePerformanceScore();
        double gpuScore = gpu.calculatePerformanceScore();
        double memoryBandwidth = memory.calculateBandwidth();
        double storageScore = storage.calculatePerformanceScore();
        
        assertTrue("CPU评分应大于0", cpuScore > 0);
        assertTrue("GPU评分应大于0", gpuScore > 0);
        assertTrue("内存带宽应大于0", memoryBandwidth > 0);
        assertTrue("存储评分应大于0", storageScore > 0);
    }
    
    @Test
    public void testBuilderChainability() {
        Computer.ComputerBuilder builder = new Computer.ComputerBuilder();
        
        // 测试链式调用
        Computer.ComputerBuilder chainedBuilder = builder
            .setCPU(new CPU("Intel", "i5", 4, 3.5, "x64"))
            .setGPU(new GPU("Intel", "UHD Graphics", 0, "集成", false))
            .setMemory(new Memory(8, "DDR4", 2666, 1, false))
            .setStorage(new Storage(Storage.StorageType.SSD, 256, "Kingston", 500, 400))
            .setMotherboard(new Motherboard("ASUS", "H610", "H610", "x64", "Micro-ATX", 2, false))
            .setLiquidCooling(false)
            .setRgbLighting(false)
            .setOperatingSystem("Windows 10");
        
        // 链式调用应返回同一个builder实例
        assertSame("链式调用应返回同一个builder", builder, chainedBuilder);
        
        Computer computer = builder.build();
        assertNotNull("计算机不应为null", computer);
    }
}

3. 构建和运行

  1. 项目构建

    bash 复制代码 
    # 清理并编译项目
mvn clean compile

# 运行测试
mvn test

# 打包
mvn package

# 运行程序
java -cp target/builder-pattern-demo-1.0-SNAPSHOT.jar com.example.builder.Main

  2. 直接运行主类

    bash 复制代码 
    mvn compile exec:java -Dexec.mainClass="com.example.builder.Main"

  3. 运行测试

    bash 复制代码 
    mvn test

4. 核心概念

模式组成

  • Builder（抽象建造者）：创建产品各个部件的抽象接口
  • ConcreteBuilder（具体建造者）：实现Builder接口，构建和装配产品部件
  • Product（产品）：被构建的复杂对象
  • Director（指挥者）：控制构建过程
  • Client（客户端）：使用指挥者创建对象

三种实现方式

  • 经典Builder模式：抽象Builder接口 + 具体Builder + Director
  • 静态内部类Builder（本例中Computer类的实现）：在目标类中定义静态Builder类
  • 链式调用Builder：通过返回this实现链式调用

优点

  • 封装性好：构建和表示分离
  • 扩展性好：可以很容易地增加新的具体建造者
  • 便于控制细节：可以精细控制构建过程
  • 提高代码可读性：链式调用使代码更清晰
  • 支持分步构建：可以分步构建复杂对象
  • 提高复用性：相同的构建过程可以创建不同的表示

缺点

  • 创建多个Builder对象：会增加系统开销
  • 产品差异大时不适用：如果产品之间差异很大，则不适合使用建造者模式
  • 需要额外的Builder类：增加了系统的复杂度

应用场景

  • 需要生成的产品对象有复杂的内部结构
  • 需要生成的产品对象的属性相互依赖，需要指定其生成顺序
  • 对象的创建过程独立于创建该对象的类
  • 隔离复杂对象的创建和使用，并使得相同的创建过程可以创建不同的产品

静态内部类Builder的优势

  • 更简洁：不需要单独的Builder类
  • 更好的封装性：产品类的构造器可以是私有的
  • 线程安全：Builder实例不共享状态
  • 易于使用：链式调用，代码可读性好
相关推荐
hid711713662 天前
BEMD分解效果示例](https://example.com/bemd_demo.png
建造者模式
席之郎小果冻3 天前
【04】【创建型】【聊一聊，建造者模式】
java·前端·建造者模式
冷崖3 天前
建造者模式-创建型
建造者模式
ZouZou老师11 天前
C++设计模式之建造者模式：以电脑组装为例
c++·设计模式·建造者模式
雨中飘荡的记忆17 天前
设计模式之建造者模式详解
java·设计模式·建造者模式
雨中飘荡的记忆17 天前
StepBuilder模式详解
java·建造者模式
__万波__19 天前
二十三种设计模式(五)--建造者模式
java·设计模式·建造者模式
沐浴露z20 天前
为什么使用SpringAI时通常用Builder来创建对象？详解 【Builder模式】和【直接 new】的区别
java·python·建造者模式
口袋物联24 天前
设计模式之建造者模式在 C 语言中的应用（含 Linux 内核实例）
c语言·设计模式·建造者模式
热门推荐
01GitHub 镜像站点02UV安装并设置国内源03Linux下V2Ray安装配置指南04sqli-labs靶场通关笔记：第18-19关 HTTP头部注入05在VSCode配置Java开发环境的保姆级教程（适配各类AI编程IDE）06安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）07BongoCat - 跨平台键盘猫动画工具08RedissonClient的配置解析09jdk21下载、安装（Windows、Linux、macOS）10Labelme从安装到标注：零基础完整指南