建造者模式

最新推荐文章于 2024-11-10 08:00:00 发布

原创最新推荐文章于 2024-11-10 08:00:00 发布 · 893 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

标签

#设计模式 #建造者

DesignPattern 专栏收录该内容

10 篇文章

订阅专栏

建造者模式（Builder Pattern）是创建型型模式（Creational Pattern）的一种，与工厂方法、抽象工厂等创建型模式不同，建造者模式需要关注一些创建的细节，它将产品的内部表象和产品的生产过程分割开来，从而使得一个创建的过程可以创建出具有不同表象的产品对象。

建造者模式的英文原话是：Sepatate the construction of a complex object from its representation so that the same construction process can create different representation。

意思是，讲一个复杂对象的构建和它的表示分离，使得同样的构建过程可以创建出不同表象的表示。

建造者模式的UML如下：

共涉及到4个角色：

产品角色（Product）：该角色是建造中的复杂对象。一个系统中可以有多个产品类，并且产品类之间可以有不同的接口实现，完全可以是不相关联的。

抽象建造者（Builder）：用于规范产品的各个部分组成，并进行抽象，一般独立于应用程序的逻辑。

具体建造者角色（ConcreteBuilder）：该角色实现抽象建造者中定义的所有方法，并返回一个建造好的产品实例。

导演类角色（Director）：该角色负责安排已有模块的顺序，然后告诉Builder开始建造。

建造者模式的实例

我们希望创建一个建造过程来生产计算机，计算机是一个复杂的对象，由CPU、主板、硬盘、显示器等构成，各个计算机中都存在着一些共性，但也存在着型号上的差异，导致具体的性能、外观表现不一。

计算机分为PC机和Server机，它们都有CPU、硬盘、操作系统，但一般Server机是不配显示器的。

于是，产品角色Product：

Computer

public abstract class Computer {  
  
    private String type;  //型号  
    private String cpu;   //CPU  
    private String hardDisk;  //硬盘  
    private String os;  //操作系统  
      
    //Setter & Getter Methods  
    public String getType() {  
        return type;  
    }  
    public void setType(String type) {  
        this.type = type;  
    }  
    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;  
    }  
}

两个具体的产品角色

Server

public class DELL_R720 extends Computer {  
  
    public DELL_R720() {  
        this.setType("DELL R720 SERVER");  
    }  
      
    @Override  
    public String toString() {  
        String str = "型号： "+this.getType();  
        str += "\ncpu: "+this.getCpu();  
        str += "\n硬盘： "+this.getHardDisk();  
        str += "\n操作系统：  "+this.getOs();  
          
        return str;  
    }  
}

public class ThinkPad extends Computer {  
  
    private String monitor;  //显示器  
      
    public ThinkPad() {  
        this.setType("ThinkPad PC");  
    }  
  
    public String getMonitor() {  
        return monitor;  
    }  
  
    public void setMonitor(String monitor) {  
        this.monitor = monitor;  
    }  
      
    @Override  
    public String toString() {  
        String str = "型号： "+this.getType();  
        str += "\ncpu: "+this.getCpu();  
        str += "\n硬盘： "+this.getHardDisk();  
        str += "\n操作系统：  "+this.getOs();  
        str += "\n显示器： " + this.getMonitor();  
          
        return str;  
    }  
  
}

抽象建造者角色Builder

public interface ComputerBuilder {  
  
    public void buildCPU(); //建造CPU  
    public void buildHardDisk(); //建造硬盘  
    public void buildOS(); //建造操作系统  
    public void buildMonitor(); //建造显示器  
      
    public Computer getComputer(); //获取计算机实例  
      
}

具体建造者角色ConcreteBuilder，实现了抽象建造者角色接口，与具体表现类对应，这里有两个具体的建造者

public class PCBuilder implements ComputerBuilder {  
  
    private ThinkPad pc = new ThinkPad();  
      
    @Override  
    public void buildCPU() {  
        pc.setCpu("i5-4750");  
    }  
      
    @Override  
    public void buildHardDisk() {  
        pc.setHardDisk("500G-720");  
    }  
      
    @Override  
    public void buildMonitor() {  
        pc.setMonitor("14s-LCD");  
    }  
  
    @Override  
    public void buildOS() {  
        pc.setOs("Windows 7");  
    }  
      
    @Override  
    public Computer getComputer() {  
        return pc;  
    }  
}

public class ServerBuilder implements ComputerBuilder {  
  
    private DELL_R720 server = new DELL_R720();  
      
    @Override  
    public void buildCPU() {  
        // TODO Auto-generated method stub  
        server.setCpu("i7-201");  
    }  
    @Override  
    public void buildHardDisk() {  
        // TODO Auto-generated method stub  
        server.setHardDisk("3T-8000");  
    }  
    @Override  
    public void buildMonitor() {  
        //无显示器  
    }  
    @Override  
    public void buildOS() {  
        // TODO Auto-generated method stub  
        server.setOs("Linux RedHat");  
    }  
    @Override  
    public Computer getComputer() {  
        return server;  
    }  
      
}

导演角色Director

public class Director {  
  
    ComputerBuilder builder;  
      
    public ThinkPad productPC() {  
        builder = new PCBuilder();  
        builder.buildCPU();  
        builder.buildHardDisk();  
        builder.buildMonitor();  
        builder.buildOS();  
          
        return (ThinkPad)builder.getComputer();  
    }  
      
    public DELL_R720 productServer() {  
        builder = new ServerBuilder();  
        builder.buildCPU();  
        builder.buildHardDisk();  
        builder.buildOS();  
          
        return (DELL_R720)builder.getComputer();  
    }  
}

至此，一个建造计算机的建造者模式就完成了

客户端测试类：

public class Test {  
  
    public static void main(String[] args) {  
        Director director = new Director();  
        Computer pc = director.productPC();  
        System.out.println(pc);  
          
        System.out.println("------------------------");  
          
        Computer server = director.productServer();  
        System.out.println(server);  
    }  
}

建造者模式的一些优点：