Item2:当构造器有多个构造参数时，考虑用builder

目录

1.重叠构造器模式

2.JavaBeans模式

3.为了解决上述问题，可以考虑采用Builder 模式：

4.结合上面例子，来看一下采用Builder Pattern的几个准则：

1.内部Builder类应该有与外部类相同的属性，这样才能利用外部类的私有构造函数来设置属性值

2.外部类的构造函数必须是private类型，这样才能阻断外界利用外部类的构造器

3.在内部Builder类的build()方法中实现创建外部类实例

4.必需参数通过Builder构造方法传入，可选参数利用工厂方法，工厂方法返回的是Builder类实例

5.Builder Pattern得以实现的本质原因

6.适用场景

7.Builder Pattern的不足

---

在创建一个类的实例的时候，我们通常会把参数传给构造器。当该类有多个参数的时候，会根据可选参数的需求创建多个构造方法，首先是不带参数的默认构造方法，接着是带一个参数的构造方法，然后是带两个参数的构造方法,...，包含所有参数的构造方法。

1.重叠构造器模式

就像这样：

下面是一个营养成分类，该类包含了多个属性值，比如每份的含量、每罐的含量、每份的卡路里、脂肪等等。根据不同必需属性值，该类有多个构造方法，如下：

在main()方法中，根据所需参数调用具体的构造方法，创建对应的实例。

public class NutritionFacts {
	private final int servingSize; // (mL) required
	private final int servings; // (per container) required
	private final int calories; // optional
	private final int fat; // (g) optional
	private final int sodium; // (mg) optional
	private final int carbohydrate; // (g) optional

	public NutritionFacts(int servingSize, int servings) {
		this(servingSize, servings, 0);
	}

	public NutritionFacts(int servingSize, int servings, int calories) {
		this(servingSize, servings, calories, 0);
	}

	public NutritionFacts(int servingSize, int servings, int calories, int fat) {
		this(servingSize, servings, calories, fat, 0);
	}

	public NutritionFacts(int servingSize, int servings, int calories, int fat,
			int sodium) {
		this(servingSize, servings, calories, fat, sodium, 0);
	}

	public NutritionFacts(int servingSize, int servings, int calories, int fat,
			int sodium, int carbohydrate) {
		this.servingSize = servingSize;
		this.servings = servings;
		this.calories = calories;
		this.fat = fat;
		this.sodium = sodium;
		this.carbohydrate = carbohydrate;
	}

	public static void main(String[] args) {
		NutritionFacts cocaCola = new NutritionFacts(240, 8, 100, 0, 35, 27);
	}
}

设想一下，假如该类有20个可选参数，那得写多少个构造方法呀～

当然，为了解决该问题，可以创建一个无参构造器，并利用set方法来设置需要的参数

2.JavaBeans模式

像下面这样：

public class NutritionFacts {
	// Parameters initialized to default values (if any)
	private int servingSize = -1; // Required; no default value
	private int servings = -1; // "     " "      "
	private int calories = 0;
	private int fat = 0;
	private int sodium = 0;
	private int carbohydrate = 0;

	public NutritionFacts() {
	}

	// Setters
	public void setServingSize(int val) {
		servingSize = val;
	}

	public void setServings(int val) {
		servings = val;
	}

	public void setCalories(int val) {
		calories = val;
	}

	public void setFat(int val) {
		fat = val;
	}

	public void setSodium(int val) {
		sodium = val;
	}

	public void setCarbohydrate(int val) {
		carbohydrate = val;
	}

	public static void main(String[] args) {
		NutritionFacts cocaCola = new NutritionFacts();
		cocaCola.setServingSize(240);
		cocaCola.setServings(8);
		cocaCola.setCalories(100);
		cocaCola.setSodium(35);
		cocaCola.setCarbohydrate(27);
	}
}

上面这种方式存在一定弊端：

1.如果构造的过程在几个调用中，可能导致JavaBean状态不一致

2.采用这种做法，对外提供了修改类属性的入口，使得类无法成为不可变类。对于可变类，需要考虑其线程安全问题。

3.为了解决上述问题，可以考虑采用Builder 模式：

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 {
		// Required parameters
		private final int servingSize;
		private final int servings;

		// Optional parameters - initialized to default values
		private int calories = 0;
		private int fat = 0;
		private int carbohydrate = 0;
		private int sodium = 0;

		public Builder(int servingSize, int servings) {
			this.servingSize = servingSize;
			this.servings = servings;
		}

		public Builder calories(int val) {
			calories = val;
			return this;
		}

		public Builder fat(int val) {
			fat = val;
			return this;
		}

		public Builder carbohydrate(int val) {
			carbohydrate = val;
			return this;
		}

		public Builder sodium(int val) {
			sodium = 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;
	}

	public static void main(String[] args) {
		NutritionFacts cocaCola = new NutritionFacts.Builder(240, 8)
				.calories(100).sodium(35).carbohydrate(27).build();
	}
}

 

4.结合上面例子，来看一下采用Builder Pattern的几个准则：

1.内部Builder类应该有与外部类相同的属性，这样才能利用外部类的私有构造函数来设置属性值

看上面例子，Builder类也具有servingSize、servings、calories、fat、sodium、carbohydrate这几个属性，从而通过设置Builder类的这些属性值来达到设置外部类属性值的目的

2.外部类的构造函数必须是private类型，这样才能阻断外界利用外部类的构造器

private NutritionFacts(Builder builder) {...

3.在内部Builder类的build()方法中实现创建外部类实例

return new NutritionFacts(this);  //this指的是Builder类的实例

4.必需参数通过Builder构造方法传入，可选参数利用工厂方法，工厂方法返回的是Builder类实例

以下是Builder类的构造方法

        public Builder(int servingSize, int servings) {
			this.servingSize = servingSize;
			this.servings = servings;
		}

以下是工厂方法，工厂方法返回的是Builder类实例

        public Builder calories(int val) {
			calories = val;
			return this;
		}

		public Builder fat(int val) {
			fat = val;
			return this;
		}

		public Builder carbohydrate(int val) {
			carbohydrate = val;
			return this;
		}

		public Builder sodium(int val) {
			sodium = val;
			return this;
        }

5.Builder Pattern得以实现的本质原因

看上述代码可以发现，其实Builder类是一个静态内部类。静态内部类可以访问外部类的属性，可以修改外部类的属性

6.适用场景

Builder Pattern特别适合类分层模型，看下面例子

public abstract class Pizza {
    public enum Topping {
        HAM, MUSHROOM, ONION, PEPPER, SAUSAGE
    }
    //该属性不能被继承，因此设置为final
    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();

        // Subclasses must override this method to return "this"
        protected abstract T self();
    }

    Pizza(Builder<?> builder){
        toppings = builder.toppings.clone();
    }
}

定义子类NyPizza如下：

public class NyPizza extends Pizza {
    public enum Size{
        SMALL, MEDIUM, LARGE
    }

    private final Size size;

    public static class Builder extends Pizza.Builder<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 static void main(String[] args){
        NyPizza pizza = new NyPizza.Builder(SMALL).addTopping(SAUSAGE).addTopping(ONION).build();
    }
}

定义子类Calzone如下：

public class Calzone extends Pizza {

    private final boolean sauceInside;

    public static class Builder extends Pizza.Builder<Builder>{
        private boolean sauceInside = false; //Default

        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(HAM).sauceInside().build();
    }
}

7.Builder Pattern的不足

创建一个类时，必须创建其Builder类

建造者模式详解，请参看https://blog.csdn.net/IFollowRivers/article/details/72236077

参考：

1.《Effective Java》