Effective Java -- 创建和销毁对象 -- 遇到多个构造器参数时考虑使用构造器（建造者模式）

最新推荐文章于 2022-07-19 16:58:58 发布

叭了个叭叭叭叭叭

最新推荐文章于 2022-07-19 16:58:58 发布

阅读量210

点赞数 1

分类专栏： Effective Java笔记

本文链接：https://blog.youkuaiyun.com/weixin_43164759/article/details/96868956

版权

Effective Java笔记专栏收录该内容

7 篇文章

订阅专栏

第二章创建和销毁对象

第二条遇到多个构造器参数时考虑使用构造器

（也就是建造者Builder模式）

静态工厂和构造器有个共同的局限性：它们都不能很好地扩展到大量的可选参数。
比如一个类表示包装食品外面显示的营养成分标签，包含超过20个可选域：总脂肪量、饱和脂肪量、胆固醇、钠等等。此时应该用哪种构造器或者静态工厂来编写呢？

1.重叠构造器模式
即重载出所有参数组合的构造器，当创建实例的时候就利用对应的构造器：

NutritionFacts cocaCola = new NutritionFacts(240,8,100,0,35,27);

重叠构造器模式可行，但是当有许多参数的时候，客户端代码会很难编写，并且难以阅读。

2.JavaBeans模式
即先调用无参构造器来创建对象，然后再调用setter方法来设置每个必要的参数：

NutritionFacts cocaCola = new NutritionFacts();
cocaCola.setServingSize(240);
cocaCola.setServings(8);
cocaCola.setCalories(100);
cocaCola.setSodium(35);
cocaCola.setCarbohydrate(27);

但是由于构造过程被分到了几个调用中，在构造过程中JavaBean可能处于不一致的状态，并且无法把类作为不可变的（无法保证线程安全）。

3.建造者模式
既能像重叠构造器模式那样保证安全性，也能像JavaBeans模式那样有可读性。

一例子

public class NutritionFacts {
	private final int servingSize;		//每一份量
    private final int servings;			//份量
    private final int calories = 0;		//卡路里
    private final int fat = 0;			//脂肪
    private final int sodium = 0;		//钠
    private final int carbohydrate = 0;	//碳水化合物
    
    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.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 sodium(int val) {
			sodium = val;
			return this;
		}
		public Builder carbohydrate(int val) {
			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的设值方法返回builder本身，以便把调用链接起来，得到一个流式的API。

	NutritionFacts cocaCola = new NutritionFacts.Builder(240,8).calories(100).sodium(35).carbohydrate(27).build();

二类层次结构中的Builder模式

假设有一个抽象类表示各式各样的披萨

/*披萨父类*/
public abstract class Pizza {
	//需要加在披萨上的馅料
    public enum Topping {
        HAM, MUSHROOM, ONION, PEPPER, SAISAGE
    }

    final Set<Topping> toppings;

	//抽象的Builder
    abstract static class Builder<T extends Builder<T>> {
        EnumSet<Topping> toppings = EnumSet.noneOf(Topping.class);

		//在披萨上加馅料的方法，通过self()方法返回子类的Builder
        public T addTopping(Topping topping) {
            toppings.add(Objects.requireNonNull(topping));
            return self();
        }

        abstract Pizza build();

		//子类必须重写这个方法并返回“this”
        protected abstract T self();
    }

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

Pizza.Builder的类型是泛型，带有一个递归类型参数（这里有点懵）。它和抽象的self方法一样，允许在子类中适当地进行方法链接，不需要转换类型。

下面是两个披萨的子类，其中经典纽约风味披萨需要一个尺寸参数：

/*经典纽约风味披萨*/
public class NyPizza extends Pizza {
	//披萨的尺寸参数
    public enum Size {SMALL, MEDIUM, LARGE}

    private final Size size;

	//子类的Builder继承父类的Builder
    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 class Calzone extends Pizza {
	//是否酱料内置
    private final boolean sauceInside;

    public static class Builder extends Pizza.Builder<Builder> {
    	//默认酱料外置
        private boolean sauceInside = false;

		//通过sauceInside()方法使酱料内置
        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;
    }
}

上面两个子类builder中的build方法都返回其自身类型：NyPizza.Builder的build方法返回NyPizza，Calzone.Builder的build方法返回Calzone。这种子类方法声明返回父类中声明的返回类型的子类型（这里有点绕，其实意思就是子类方法返回的就是这个子类本身），称作协变返回类型。它允许客户端无需转换类型就能使用这些builder。
客户端代码：

        NyPizza nyPizza = new NyPizza.Builder(NyPizza.Size.SMALL).addTopping(Pizza.Topping.SAUSAGE).addTopping(Pizza.Topping.ONION).build();
        Calzone calzone = new Calzone.Builder().sauceInside().addTopping(Pizza.Topping.HAM).build();