建造者模

最新推荐文章于 2023-06-02 09:00:00 发布

zvub

最新推荐文章于 2023-06-02 09:00:00 发布

阅读量120

点赞数

分类专栏：设计模式

设计模式专栏收录该内容

9 篇文章 0 订阅

订阅专栏

Builder模式，将产品的内部表象和产品的生成过程分割开来，从而使一个建造过程生成具有不同的内部

表象的产品对象。建造模式使得产品内部表象可以独立的变化，客户不必知道产品内部组成的细节。建造模式可以强制实行一种分步骤进行的建造过程。

将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

相关模式：思路和模板方法模式很像，模板方法是封装算法流程，对某些细节，提供接口由子类修改，建造者模式更为高层一点，将所有细节都交由子类实现。

建造者模式的使用情况：

以下情况应当使用建造者模式：

1、需要生成的产品对象有复杂的内部结构。

2、需要生成的产品对象的属性相互依赖，建造者模式可以强迫生成顺序。

3、在对象创建过程中会使用到系统中的一些其它对象，这些对象在产品对象的创建过程中不易得到。

优缺点：

优点：1、建造者模式的使用使得产品内部表象可以独立的变化，使客户端不必知道产品内部组成细节。

2、每一个Builder都相对独立，而与其它的Builder无关。

3、可以使对构造过程更加精细控制，以降低控制细节的风险。

4、将构建代码和表示代码分开。

缺点：1、由于其的变化点在于对象创建的细节，故其也难于分步骤构建的算法需求的变动，因为其关注的是对象创建顺序。

建造者模式一般适用于稳定的系统，比如说同样是对人的描述，如果描述的是正常人，就可用，但是对于残疾人，因为系统不再稳定，再使用的话就无法满足“开闭原则”了。

当要生产的一种产品具有相同的结构，并且每个构件的生产都很繁杂，就可以用Builder模式将具体构件的生产与整个成品的组装分离开来。还是拿本文的代码来举例，生产一台笔记本，笔记本的厂家不需要知道CPU怎么生产的，不需要关心内存怎么生产的，也不需要关心主板怎么生产的等。当他在生产一台笔记本的时候，只会说，我要一块Intel的CPU，于是就有了CPU（至于Intel的CPU怎么生产的他不关心，他只要一个CPu），他又说我要一块金士顿内存，于是就有了金士顿内存，这样直到他得到了所有的构件，然后他把这些构件组装起来，组成一台笔记本卖给客户。这就是一个典型的Builder模式。下面是代码：

 
   [java]  
   view plaincopy
/** 
 * CPU抽象类 
 */  
public abstract class CPU {  
    public abstract CPU getCPU();  
}  

 
   [java]  
   view plaincopy
/** 
 * Intel的cpu 
 */  
public class IntelCPU extends CPU {  
  
    public IntelCPU(){};  
      
    @Override  
    public CPU getCPU() {  
        // TODO Auto-generated method stub  
        return new IntelCPU();  
    }  
      
     public String toString(){    
            return " IntelCPU ";    
        }    
}  

 
   [java]  
   view plaincopy
/** 
 * AMD的cpu  
 */  
public class AMDCPU extends CPU {  
  
    public AMDCPU(){};  
    @Override  
    public CPU getCPU() {  
        // TODO Auto-generated method stub  
        return new AMDCPU();  
    }  
      
     public String toString(){    
            return " AMDCPU ";    
        }    
  
}  

 
   [java]  
   view plaincopy
/** 
 * 内存抽象类 
 */  
public abstract class Memory {  
    public abstract Memory getMemory();  
}  

 
   [java]  
   view plaincopy
/** 
 * 金士顿内存 
 */  
public class KingstonMemory extends Memory {  
    public KingstonMemory(){};  
    @Override  
    public Memory getMemory() {  
        return new KingstonMemory();  
    }  
      
     public String toString(){    
            return " KingstonMemory ";    
        }    
}  

 
   [java]  
   view plaincopy
/** 
 * 宇瞻内存 
 */  
public class ApacerMemory extends Memory {  
    public ApacerMemory(){};  
    @Override  
    public Memory getMemory() {  
        // TODO Auto-generated method stub  
        return new ApacerMemory();  
    }  
      
    public String toString(){    
        return " ApacerMemory ";    
    }    
}  

 
   [java]  
   view plaincopy
**  
 * 主板抽象类  
 */  
public abstract class Mainboard {  
    public abstract Mainboard getMainboard();  
}  

 
   [java]  
   view plaincopy
/** 
 * 华硕主板 
 */  
public class AsusMainboard extends Mainboard {  
    public AsusMainboard(){};  
    @Override  
    public Mainboard getMainboard() {  
        // TODO Auto-generated method stub  
        return new AsusMainboard();  
    }  
      
    public String toString(){    
        return " AsusMainboard ";    
    }    
}  

 
   [java]  
   view plaincopy
/** 
 * 技嘉主板 
 */  
public class GaMainboard extends Mainboard {  
    public GaMainboard(){}  
  
    @Override  
    public Mainboard getMainboard() {  
        return new GaMainboard();  
    };  
      
     public String toString(){    
            return " GaMainboard ";    
        }    
}  

 
   [java]  
   view plaincopy
/** 
 * 计算机所需组件 
 */  
public class Computer {  
    private CPU cpu;  
    private Memory memory;  
    private Mainboard mainboard;  
    public CPU getCpu() {  
        return cpu;  
    }  
    public void setCpu(CPU cpu) {  
        this.cpu = cpu;  
    }  
    public Memory getMemory() {  
        return memory;  
    }  
    public void setMemory(Memory memory) {  
        this.memory = memory;  
    }  
    public Mainboard getMainboard() {  
        return mainboard;  
    }  
    public void setMainboard(Mainboard mainboard) {  
        this.mainboard = mainboard;  
    }  
}  

 
   [java]  
   view plaincopy
/** 
 * 计算机Builder 
 */  
public interface ComputerBuilder {  
    public void buildCPU();    
    public void buildMemory();    
    public void buildMainboard();    
    public Computer getComputer();   
}  

 
   [java]  
   view plaincopy
/** 
 * 联想计算机Builder 
 */  
public class LenoveComputerBuilder implements ComputerBuilder {  
     private Computer lenoveComputer=null;    
        public LenoveComputerBuilder(){    
            lenoveComputer=new Computer();    
        }    
      
    @Override  
    public void buildCPU() {  
        lenoveComputer.setCpu(new IntelCPU());  
    }  
  
    @Override  
    public void buildMemory() {  
        lenoveComputer.setMemory(new KingstonMemory());  
    }  
  
    @Override  
    public void buildMainboard() {  
        lenoveComputer.setMainboard(new AsusMainboard());  
    }  
  
    @Override  
    public Computer getComputer() {  
        buildCPU();    
        buildMemory();    
        buildMainboard();    
        return lenoveComputer;  
    }  
  
}  

 
   [java]  
   view plaincopy
/** 
 * 惠普计算机Builder 
 */  
public class HPComputerBuilder implements ComputerBuilder {  
     private Computer HPComputer=null;    
    public HPComputerBuilder(){  
        HPComputer = new Computer();  
    }  
      
    @Override  
    public void buildCPU() {  
        HPComputer.setCpu(new AMDCPU());  
  
    }  
  
    @Override  
    public void buildMemory() {  
        HPComputer.setMemory(new ApacerMemory());  
    }  
  
    @Override  
    public void buildMainboard() {  
        HPComputer.setMainboard(new GaMainboard());  
  
    }  
  
    @Override  
    public Computer getComputer() {  
        buildCPU();    
        buildMemory();    
        buildMainboard();    
        return HPComputer;  
    }  
  
}  

 
   [java]  
   view plaincopy
public class Director {  
     private ComputerBuilder builder;     
        public Director(ComputerBuilder builder) {     
            this.builder = builder;     
        }    
        public Computer construct() {     
            return builder.getComputer();    
        }     
}  

 
   [java]  
   view plaincopy
public class TestBuilder {  
  
    /** 
     * @param args 
     */  
    public static void main(String[] args) {  
        Computer lenoveComputer,hpComputer;    
        ComputerBuilder lenoveComputerBuilder = new LenoveComputerBuilder();    
        ComputerBuilder hpComputerBuilder = new HPComputerBuilder();    
        Director director;    
        director = new Director(lenoveComputerBuilder);    
        lenoveComputer=director.construct();    
        director = new Director(hpComputerBuilder);    
        hpComputer=director.construct();    
        System.out.println("lenoveComputer is made by:"+lenoveComputer.getCpu()+lenoveComputer.getMemory()+lenoveComputer.getMainboard());    
        System.out.println("hpComputer is made by:"+hpComputer.getCpu()+hpComputer.getMemory()+hpComputer.getMainboard());    
    }  
  
}  

运行结果：

lenoveComputer is made by: IntelCPU KingstonMemory AsusMainboard
hpComputer is made by: AMDCPU ApacerMemory GaMainboard

注解：

在main函数里面，director调用了builder里面的getComputer()方法，getComputer()方法实际就是组装的过程，getComputer()里面的buildCPU(); buildMemory(); buildMainboard(); 就是在购买构件，而这些构件生产的具体过程放在了这些构件自身的类里面，可以看到buildCPU()里面有new一个对象，这就是在进行生产。这样就达到了组装和生产构件之间的分离。

最后，说说Builder模式和Factory模式之间区别的理解。Builder和Factory之间的区别就是组装和生产之间的区别，Builder着重将组装和构件的生产分离，Factory着重于优化生产的过程。本文的代码实际上还可以进行重构，例如，在buildCPU()函数里面，用到了new这个关键字，实际上可以将这个new换成工厂类，让工厂类来生产CPU。换一种说法，就是Factory不进行组装，Builder进行组装，当Factory进行组装的时候，它就变成Builder了。

原文：https://blog.csdn.net/fuhao715/article/details/7195770