建造者模式

• 定义

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

• 使用场景

• 相同的方法，不同的执行顺序，产生不同的事件结果时；
• 多个部件或零件，都可以装配到一个对象中，但是产生的运行结果又不相同时；

• 产品类非常复杂，或者产品类中的调用顺序不同产生了不同的效能，这个时候使用建造者模式非常合适；

• 实现方式

利用Builder类来构造A类的一个对象，并将A类的构造方法私有化，构造函数参数只有Builder。实现代码如下：

Phone.java

package com.design.builder;

public class Phone {

   private String cpu;
   
   private int ram;
   
   private String screen;
   
   private Phone(PhoneBuilder builder) {
       this.cpu = builder.cpu;
       this.ram = builder.ram;
       this.screen = builder.screen;
   }
   
   public String getCpu() {
       return cpu;
   }
   public void setCpu(String cpu) {
       this.cpu = cpu;
   }
   public int getRam() {
       return ram;
   }
   public void setRam(int ram) {
       this.ram = ram;
   }
   public String getScreen() {
       return screen;
   }
   public void setScreen(String screen) {
       this.screen = screen;
   }
   
   public static class PhoneBuilder{
       private String cpu;
       
       private int ram;
       //default screen
       private String screen = "1280 * 720";
       
       public PhoneBuilder cpu(String cpu){
           this.cpu = cpu;
           return this;
       }
       
       public PhoneBuilder ram(int ram){
           this.ram = ram;
           return this;
       }
       
       public PhoneBuilder screen(String screen){
           this.screen = screen;
           return this;
       }
       
       public Phone build(){
           //default handle
           if (ram == 0){
               ram = 1024;
           }
           return new Phone(this);
       }
   }
 }

App.java

package com.design.builder;

import com.design.builder.Phone.PhoneBuilder;

public class App {

   public static void main(String[] args) {
       Phone iphone = new PhoneBuilder()
                       .cpu("A7")
                       .ram(2048)
                       .screen("1136 * 720")
                       .build();
   }

}

• 总结优缺点

• 优点
  • 良好的封装性，能够生成多种多样的对象
  • 代码简洁易读
• 缺点
  • 编写麻烦，产生多余的Builder对象