设计模式-建造者模式

定义电脑类以及两种具体的电脑类型ThinkPad以及MacBook

public class Computer {
    private int price;
    private String cpu;
    private String hardDisk;
    private String os;
    private String monitor;
    private String ram;

    public int getPrice() {
        return price;
    }
    public void setPrice(int price) {
        this.price = price;
    }
    public String getCpu() {
        return cpu;
    }
    public void setCpu(String cpu) {
        this.cpu = cpu;
    }
    public String getHardDisk() {
        return hardDisk;
    }
    public void setHardDisk(String hardDisk) {
        this.hardDisk = hardDisk;
    }
    public String getOs() {
        return os;
    }
    public void setOs(String os) {
        this.os = os;
    }
    public String getMonitor() {
        return monitor;
    }
    public void setMonitor(String monitor) {
        this.monitor = monitor;
    }
    public String getRam() {
        return ram;
    }
    public void setRam(String ram) {
        this.ram = ram;
    }
    @Override
    public String toString() {
        return "Computer{" +
                "price=" + price +
                ", cpu='" + cpu + '\'' +
                ", hardDisk='" + hardDisk + '\'' +
                ", os='" + os + '\'' +
                ", monitor='" + monitor + '\'' +
                ", ram='" + ram + '\'' +
                '}';
    }
}
class MacBook extends Computer{

}
class ThinkPad extends Computer{

}

定义电脑建造者接口，在其中定义建造电脑的方法

public interface ComputerBuilder {
    void serPrice();
    void buildCPU();
    void buildHardDisk();
    void buildOS();
    void buildMoitor();
    void buildRAM();
    Computer getResultComputer();
}

以及对应品牌电脑的建造者实现类

public class MacBookBuilder implements ComputerBuilder{
    Computer mackBook = new MacBook();

    @Override
    public void serPrice() {
        mackBook.setPrice(10000);
    }

    @Override
    public void buildCPU() {
        mackBook.setCpu("10800k");
    }
    @Override
    public void buildHardDisk() {
        mackBook.setHardDisk("1T");
    }
    @Override
    public void buildOS() {
        mackBook.setOs("IOS");
    }
    @Override
    public void buildMoitor() {
        mackBook.setMonitor("2K");
    }
    @Override
    public void buildRAM() {
        mackBook.setRam("16G");
    }
    @Override
    public Computer getResultComputer() {
        return mackBook;
    }
}

public class ThinkPadBuilder implements ComputerBuilder{
    Computer thinkPad = new ThinkPad();

    @Override
    public void serPrice() {
        thinkPad.setPrice(8000);
    }
    @Override
    public void buildCPU() {
        thinkPad.setCpu("7700k");
    }
    @Override
    public void buildHardDisk() {
        thinkPad.setHardDisk("500G");
    }
    @Override
    public void buildOS() {
        thinkPad.setOs("windows10");
    }
    @Override
    public void buildMoitor() {
        thinkPad.setMonitor("4k");
    }
    @Override
    public void buildRAM() {
        thinkPad.setRam("16G");
    }
    @Override
    public Computer getResultComputer() {
        return thinkPad;
    }
}

电脑导演类，执行创造电脑的步骤

public class ComputerDirector {
    ComputerBuilder macBookBuilder = new MacBookBuilder();
    public MacBook constructMacBook(){
        macBookBuilder.serPrice();
        macBookBuilder.buildCPU();
        macBookBuilder.buildHardDisk();
        macBookBuilder.buildMoitor();
        macBookBuilder.buildOS();
        macBookBuilder.buildRAM();
        return (MacBook) macBookBuilder.getResultComputer();
    }
    ComputerBuilder thinkPadBuilder = new ThinkPadBuilder();
    public ThinkPad constructThinkPad(){
        thinkPadBuilder.serPrice();
        thinkPadBuilder.buildCPU();
        thinkPadBuilder.buildHardDisk();
        thinkPadBuilder.buildMoitor();
        thinkPadBuilder.buildOS();
        thinkPadBuilder.buildRAM();
        return (ThinkPad) thinkPadBuilder.getResultComputer();
    }
}

去买电脑相当于实例化一个电脑导演类，然后导演去建造对应品牌的电脑

ComputerDirector computerDirector = new ComputerDirector();
Computer myMacBook = computerDirector.constructMacBook();
System.out.println(myMacBook);
Computer myThinkPad = computerDirector.constructThinkPad();
System.out.println(myThinkPad);

输出为

Computer{price=10000, cpu='10800k', hardDisk='1T', os='IOS', monitor='2K', ram='16G'}
Computer{price=8000, cpu='7700k', hardDisk='500G', os='windows10', monitor='4k', ram='16G'}