《Effective Java》 读书笔记（二） 在构造参数过多的时候优先考虑使用构造器
刚开始看见这个标题的时候，我想到了python可以选择初始化参数的语法，C++、C#能有默认参数。
为什么Java什么都没有~~
好吧，我们是使用构造器来实现它。
1.当一个类的构造函数需要很多构造函数的时候，编程人员往往容易混淆弄错，而且很多情况并不需要这么多的构造函数。
因此我们有以下几种选择：
1）是用默认构造函数构造这个对象，并在之后使用setter方法给这个对象赋值。
但是对于多线程中线程安全考虑来说，这样做排除了使类不可变的可能性，并且想要排除这种bug也是十分困难的
（注：由于代码量的原因，并没有深刻理解到为什么会有这样的问题，但是大概的意思可能是由于多线程的问题，有些对对象属性的访问可能会在setter构造之前调用
这种方式就好像生产车一样。先通过默认构造函数生产出来一个车的外壳，然后通过setter添加轮子，方向盘什么的。
但是在多线程里面，由于没有保证生产出来外壳后，接下来就一定是添加轮子，方向盘。有可能有人就直接拿着车的外壳上路了。
）
因此这种方式在多线程的环境下不推荐使用
2）使用Builder内置构造器
/**
* @Author dengchengchao
* @Time 2018/5/10
* @Description
*/
public class NutritionFacts {
private final int servingSize;
private final int servings;
private final int calories;
private final int fat;
private final int sodium;
private final int carbohydrate;
public static class Builder {
/**
* 必要的参数
*/
private final int servingSize;
private final int servings;
/**
* 可选参数
*/
private int calories = 0;
private int fat = 0;
private int sodium = 0;
private int carbohydrate = 0;
public Builder(int servingSize, int servings) {
this.servings = servings;
this.servingSize = servingSize;
}
public Builder calories(int val) {
this.calories = val;
return this;
}
public Builder fat(int val) {
this.fat = val;
return this;
}
public Builder sodium(int val) {
this.sodium = val;
return this;
}
public Builder carbohydrate(int val) {
this.carbohydrate = val;
return this;
}
public NutritionFacts build(){
return new NutritionFacts(this);
}
}
private NutritionFacts(Builder builder) {
servingSize = builder.servingSize;
servings = builder.servings;
calories = builder.calories;
fat = builder.fat;
sodium = builder.sodium;
carbohydrate = builder.carbohydrate;
}
}
可以看出来NutritionFacts使用了一个内置的Builder来够着函数，这样我们就可以使用：
NutritionFacts nutritionFacts=new Builder(240,8).
calories(100).carbohydrate(35).build();
很方便的选择初始化那些参数了。
PS1:这样使用很简单，但是在写这个Builder的时候，简直不要再麻烦。推荐使用idea的插件：Builder Generator 能快速构造。
PS2:可以看到示例代码很好的习惯，不会改变的属性都是用final，只平时写代码的时候，除了定义常量使用final,基本都没使用过，应该多思考思考，不过final在JavaBean中作为Json反序列对象得小心使用，不然很可能序列化失败。
2.Builder模式也非常适合层次结构，可以使用平行层次的builder,每个嵌套在相应的类中，就好像披萨类，内部可以包含各种芝士构造器，大小构造器等。
public abstract class 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(Objects.requireNonNull(topping));
return self();
}
abstract Pizza build();
protected abstract T self();
}
Pizza(Builder<?> builder){
toppings=builder.toppings.clone();
}
}
public class NyPizza extends Pizza {
public enum Size{SMALL,MEDIUM,LARGE}
private final Size size;
public static class Builder extends Pizza.Builder{
private final Size size;
public Builder(Size size){
this.size= Objects.requireNonNull(size);
}
@Override
public NyPizza build(){
return new NyPizza(this);
}
@Override
protected Builder self(){
return this;
}
}
private NyPizza(Builder builder){
super(builder);
size=builder.size;
}
}
public class Calzone extends Pizza {
private final boolean sauceInside;
public static class Builder extends Pizza.Builder<Builder> {
private boolean sauceInside = false;
public Builder sauceInside() {
sauceInside = true;
return this;
}
@Override
public Calzone build() {
return new Calzone(this);
}
@Override
protected Builder self() {
return this;
}
}
private Calzone(Builder builder) {
super(builder);
sauceInside = builder.sauceInside;
}
public static void main(String[] args) {
Calzone calzone = new Builder().addTopping(Topping.MUSHROOM).build();
}
}
PS:在写这段代码的时候，我发现了这种类声明方式：
abstract static class Builder<T extends Builder
刚开始我一直在想为什么需要<T extends Builder
经过仔细研究这段代码和根据后续代码来看：
-
Builder类中包含了一个self方法，需要各个子类自己实现并返回this。
-
从后面的代码来看有些子类包含了一些父类不存在的方法。
-
如果不加<T extends Builder
>.那么父类有的通用的方法addTopping应该返回什么。
想到这些问题后，再想想解决方法就明白书上为什么要这样写了：
因为后面的子类包含了一些父类不存在的方法，而子类的每一个set都需要返回this.那么在调用父类中通用的方法addTopping()后，就无法再调用子类的方法了，应为addTopping()在编译的时候，是返回的父类Pizza类型。
也就是说：
Pizza calzone=new Calzone.Builder().
addTopping(Toppig.MUSHROOM).sauceInside().build();
是编译不过的，因为addTopping()返回的是Pizza类型，Pizza没有sauceInside()方法。
同样的道理。探讨下如果不加<T extends Builder<T>> 用来指定真正的类型，那么
Calzone calzone=new Calzone.Builder().
addTopping(Toppig.MUSHROOM).sauceInside().build();
也是无法编译成功的，仔细看看:
Calzone.Builder().addTopping(Topping.MUSHROOM)
在编译阶段是返回父类Pizza类型的，那么它所调用的build()也是返回的Pizza类型，而左边确实它的子类型：Calzone,如果不强制转换，那么是无法从范围小的类型自动转换为范围大的类型的。
这样的代码，对于使用Pizaa类，Calzone类的用户来说，是非常疑惑的。
因此，我们可以定义一个self，让子类型告诉这个方法的具体返回类型。
3.对于上面的疑问，《Effective Java》也进行了解释，只是如果不认真的思考，是想不到为什么么，感觉作者只是一笔带过。
具体的技巧为：
1.在定义这个父类的时候，添加一个递归类型参数的泛型类型。例如Bulider<T extend Builder<T>>
2.定义一个self()方法，让子类实现self()方法并返回this。
3.在父类所有需要返回this的地方使用self()方法
这种技巧称为 模拟自我类型
可以看见buid()方法返回的具体的子类类型。NyPizza.Builder返回NyPizza类型，Calzone.Builder返回Calzone类型。这种一个子类方法被声明为返回在超类中声明的返回类型的子类型，称为 协变返回类型。
协变返回类型这种技巧可以应用在父类需要返回this
4.构造器方法也会带来一定的性能影响和使构造方法更加冗长的缺点，
因此最好在只有足够的参数的时候才使用它，比如4个或则更多。但是值得注意的是可能你以前不是builder而是后来发现参数越来越多的时候再转换为builder模式的时候，过时的构造方法或静态工厂就会不好处理，因此，如果采用builder模式，最好一开始就考虑好，
总之，当参数过多的时候，使用builder是一个不错的选择。特别是在许多参数是可选的的情况下。
