Effective Java -- 使用构造器(Builder)替代多参数构造器

小鱼儿 2022-12-02 04:03 210阅读 0赞

> 此系列文章为本人对《Effective Java》一书的学习笔记，主要是使用自己的语言和代码描述对书中重点内容的理解。  
> 既然有缘看到此文，那么希望能对你有所帮助。  
> 本文对应原书 `第2条 遇到多个构造器参数时要考虑使用构造器`

本文主要讨论在面对多个参数时，构造一个类实例的做法。

#### 传统方法 - - 重叠构造器模式 ####

大多数人会习惯采用`重叠构造器模式`，也就是通过提供一系列的构造器来完成不同需求下类的实例化要求。  
通常是**第一个构造器只接收必要的参数**，**其他的构造器逐个增加参数个数**，**最终的构造器会包含所有的可选参数**。示例如下：

// 重叠构造器模式Demo
    public class Demo { 
    	// 必传参数
    	private String name;
    	// 必传参数
    	private String age;
    	// 非必传参数
    	private String nickName;
    	// 非必传参数
    	private Integer height;
    	
    	// 第一个构造器只有必传参数
    	public Demo(String name, Integer age) { 
    		...
    	}
    	// 第二个构造器增加可选参数
    	public Demo(String name, Integer age, String nickName) { 
    		...
    	}
    	// 第三个构造器包含所有可选参数
    	public Demo(String name, Integer age, String nickName, Integer height) { 
    		...
    	}
    }

其实这个模式在我们日常的代码中很常见，在参数较少的情况下，由于维护成本不高，其不失为一种选择。  
**但问题是，随着参数的增加，这种模式很快就会失去控制。**  
在多参数的情况下，一是代码**难以编写**，二是**难以阅读**，会给编写者和使用者都带来麻烦。

#### 传统方法改良 - - JavaBean模式 ####

虽然说，我们可以使用`JavaBean模式`来对此旧法进行优化，即：`先调用一个无参构造器或必传参构造器来创建对象，然后通过set方法来设置其它参数。`

// JavaBean模式模式Demo
    public class Demo { 
    	// 必传参数
    	private String name;
    	// 必传参数
    	private String age;
    	// 非必传参数
    	private String nickName;
    	// 非必传参数
    	private Integer height;
    	
    	// 第一个构造器只有必传参数
    	public Demo(String name, Integer age) { 
    		...
    	}
    }
    // 使用方法
    Demo demo = new Demo("李白", 18);
    demo.setNickName("小白");
    demo.setHeight(180);

但这种方式也存在局限性：

*  **在构造的过程中，JavaBean可能处于不一致状态；**  
    创建过程可能分为很多步骤，不像构造器一步完成，且无法通过构造器参数的有效性来保证一致（`set`时虽然可以控制单个参数的有效性，如判断年龄是否是正常值，但难以控制多个参数的关联性，如年龄和工龄的关系）。
 *  **该模式使得类变得可变（任意`set`），降低了安全性。**  
    虽然可以通过`freeze`方法在类没有准备好之前进行"冻结"，但此法光说出来就显得挺笨拙。

#### 更为优秀的方案 - - 建造者模式 ####

建造者模式，`既能保证重叠构造器模式的安全性`，`又能保证JavaBean模式的可读性`。  
**真香 ~~~**  
没使过？请享用 ↓↓↓

public class Demo { 
    	// 必传参数
    	private String name;
    	// 必传参数
    	private String age;
    	// 非必传参数
    	private String nickName;
    	// 非必传参数
    	private Integer height;
    
    	public static class Builder{ 
    		// 必传参数
    		public String name;
    		// 必传参数
    		public String age;
    		// 非必传参数 可以加上默认值
    		public String nickName = "暂无";
    		// 非必传参数 可以加上默认值
    		public Integer height = 0;
    		
    		// 自己的构造方法
    		public Builder(String name, Integer age) { 
    			this.name = name;
    			this.age = age;
    		}
    		public Builder nickName(String nickName) { 
    			this.nickName = nickName;
    			return this;
    		}
    		public Builder height(Integer height) { 
    			this.height= height;
    			return this;
    		}
    		// 最终返回Demo的build方法
    		public Demo build() { 
    			return new Demo(Builder builder);
    		}
    	}
    	
    	public Demo(Builder builder) { 
    		this.name = builder.name;
    		this.age = builder.age;
    		this.nickName = builder.nickName;
    		this.height= builder.height;
    	}
    }
    // 食用方法
    Demo demo = new Demo.Builder("李白", 18)
    				.nickName("小白")
    				.height(180)
    				.build();

> 如果你所要使用Builder的类相对简单(类似POJO)，而且在项目中使用了`lombok`的话  
> 可以使用`lombok`提供的`@Builder`注解，自动完成Builder的构建。

当然你可能会说，**这个Builder写的太死了，离开了Demo类它连什么都没有了**，连QQ会员都不是，拿什么竞争。  
莫慌，其实你完全可以在**抽象类**中使用它。

// 抽象类
    // 这是来自原书的披萨类
    public abstract Pizza{ 
    	// 所有配料
    	public Enum Topping { HAM, MUSHROOM, ONION, PEPPER, SAUSAGE}
    	// 当前的披萨使用的配料
    	final Set<Topping> toppings;
    
    	abstract static class Builder<T extends Builder<T>> { 
    		EnumSet<Topping> toppings = EnumSet.noneOf(Topping.class);
    		public T addTopping(Topping topping) { 
    			toppings.add(topping);
    			return self();
    		}
    		protected abstract T self();
    		abstract Pizza build();
    	}
    	// 披萨的构造器
    	Pizza(Builder<?> builder) { 
    		// 将builder中的配料copy过来
    		toppings = builder.toppings.copy();
    	}
    }
    // 实现类
    public class MyPizza { 
    	public enum Size { SMALL, MEDIUM, LARGE}
    	// 独有属性 尺寸
    	private final Sise size;
    	
    	public static class Builder extends Pizza.Builder<Builder> { 
    		private final Size size;
    		public Builder(Size size) { 
    			this.size = size;
    		}
    		@Override
    		public MyPizza build() { 
    			return new MyPizza(this);
    		}
    		@Override
    		protected Builder self() { 
    			return this;
    		}
    	}
    	
    	public MyPizza(Builder builder) { 
    		// 父类的copy配料过程
    		super(builder);
    		// 处理自己独有的size属性
    		this.size = builder.size;
    	}
    }

#### 总结 ####

简而言之，如果类的构造器或者静态工厂中含有多个参数，那么Builder模式真的更适合哦。

> 水平有限，若文章中存在错误，恳请不吝赐教，这对我以及后面的读者都有重要意义；  
> 若文章能够帮助到你，还望一键三连，你的支持，是我最大的动力。