创建者模式(Builder)

创建者模式：（builder）
 1、定义：创建者模式就是将一个复杂对象的构建与它的表示相分离，使得同样的构建过程可以创建不同的表示，而且客户端
 不用知道对象的构建细节。
 2、原理：有五部分：组装类，抽象对象创建类，实现抽象对象创建类的具体创建类，抽象产品类，实现抽象产品类的具体创建产品类。

 

下面分别说明一下以上五部分：

 --->需要组装的一个抽象产品类（整体上的宏观概念产品）Macrocosm.java

 

package org.bestupon.builder.products;
/**
 * 本类是整体的一个产品接口类
 * @author bestupon
 *
 */
public interface Macrocosm {
	/**
	 * 该方法用于创建该方法的产品
	 * 业务方法
	 */
	public String build();
	/**
	 * 打印产品信息
	 * 辅助方法
	 */
	public void printInfo();
}

 

----->零部件产品抽象类（角色：抽象产品类）：这里列举了四个产品，分别是FirstProduct.SecondProduct.ThridProduct.ForthProduct.都是interface。列举其中之一：

 

package org.bestupon.builder.products;
/**
 * 用户零部件的第一个产品抽象类
 * @author bestupon
 *
 */
public interface FirstProduct {
	public String build();
	public void printInfo();
}

 

----->零部件产品的实现类（角色抽象产品的实现类）：

 

package org.bestupon.builder.products.impl;

import org.bestupon.builder.products.FirstProduct;

public class FirstProductImpl implements FirstProduct {

	public String build() {
		return "创建了产品一";
	}

	public void printInfo() {
		System.out.println(this.build());
	}

}

 

---->整体宏观产品实现类：

 

package org.bestupon.builder.products.impl;

import org.bestupon.builder.products.Macrocosm;

public class MacrocosmImpl implements Macrocosm {

	public String build() {
		return "开始组装整体产品";
	}

	public void printInfo() {
		System.out.println(this.build());
	}

}

 

------>建造工厂类（角色:抽象对象创建类）： 

 

package org.bestupon.builder.factory;

import org.bestupon.builder.products.FirstProduct;
import org.bestupon.builder.products.ForthProduct;
import org.bestupon.builder.products.SecondProduct;
import org.bestupon.builder.products.ThirdProduct;
/**
 * 生产一系列用于组装一个产品的产品
 * @author bestupon
 *
 */
public interface BuilderFactory {
	public FirstProduct buildFirstProduct();
	public SecondProduct buildSecondProduct();
	public ThirdProduct builThirdProduct();
	public ForthProduct buildForthProduct();
}

 

 

----->建造工厂的实现类（角色：抽象对象创建的实现类）：

 

 

package org.bestupon.builder.factory.impl;

import org.bestupon.builder.factory.BuilderFactory;
import org.bestupon.builder.products.FirstProduct;
import org.bestupon.builder.products.ForthProduct;
import org.bestupon.builder.products.SecondProduct;
import org.bestupon.builder.products.ThirdProduct;
import org.bestupon.builder.products.impl.FirstProductImpl;
import org.bestupon.builder.products.impl.ForthProductImpl;
import org.bestupon.builder.products.impl.SecondProductImpl;
import org.bestupon.builder.products.impl.ThirdProductImpl;
/**
 * 负责创建产品的类
 * @author bestupon
 *
 */
public class MacrocosmFactory implements BuilderFactory {

	public ThirdProduct builThirdProduct() {
		return new ThirdProductImpl();
	}

	public FirstProduct buildFirstProduct() {
		return new FirstProductImpl();
	}

	public ForthProduct buildForthProduct() {
		return new ForthProductImpl();
	}

	public SecondProduct buildSecondProduct() {
		return new SecondProductImpl();
	}

}

 

 

----->实现组装产品的组装类（角色：组装类）注意：本类是具体的类，不是抽象类或者接口。

 

package org.bestupon.builder.assemble;

import org.bestupon.builder.factory.BuilderFactory;
import org.bestupon.builder.products.FirstProduct;
import org.bestupon.builder.products.ForthProduct;
import org.bestupon.builder.products.Macrocosm;
import org.bestupon.builder.products.SecondProduct;
import org.bestupon.builder.products.ThirdProduct;
import org.bestupon.builder.products.impl.MacrocosmImpl;
/**
 * 本类是为了不让客户端臃肿而设计的组装类。
 * 是解决抽象工厂模式的弊端，客户端臃肿问题而设计的。
 * @author bestupon
 *
 */
public class Assemble {
	private BuilderFactory factory;

	public Assemble(BuilderFactory factory) {
		this.factory = factory;
	}
	
	public Macrocosm buildMacrocosm(){
		/**
		 * 创建产品一
		 */
		FirstProduct firstProduct = factory.buildFirstProduct();
		firstProduct.build();
		firstProduct.printInfo();
		/**
		 * 产品二
		 */
		SecondProduct secondProduct = factory.buildSecondProduct();
		secondProduct.build();
		secondProduct.printInfo();
		/**
		 * 产品三
		 */
		ThirdProduct thirdProduct = factory.builThirdProduct();
		thirdProduct.build();
		thirdProduct.printInfo();
		/**
		 * 产品四
		 */
		ForthProduct forthProduct = factory.buildForthProduct();
		forthProduct.build();
		forthProduct.printInfo();
		
		return new MacrocosmImpl();
	}
	
}

 

 

----->客户端

 

package org.bestupon.builder.client;

import org.bestupon.builder.assemble.Assemble;
import org.bestupon.builder.factory.impl.MacrocosmFactory;
import org.bestupon.builder.products.Macrocosm;

public class Client {
	
	public static void main(String args []) {
		Assemble assemble = new Assemble(new MacrocosmFactory());
		Macrocosm macrocosm =  assemble.buildMacrocosm();
		macrocosm.printInfo();
	}
}

 

 

 3、优点：和抽象工厂模式相比较，客户端不用负责产品的组装，而是把组装的的任务交给了组装类去完成，客户端只是负责
 产品的调用。
 4、缺点： 如果产品之间的差异非常大的话，需要编写多个创建者类才能实现。代码量增加了。
 5、使用时机：需要同时创建出一系列相关的产品，但是这些产品可以构建成一个整体的产品，可以考虑使用
 创建者模式。
 1>需要生成的产品对象有复杂的内部结构。每一种内部成分本身可以是对象，
 也可以是一个对象的一个组成成分。
 2>需要生成的产品对象的属性相互依赖。
 3>在对象创建过程中会使用到系统中的其他的一些对象，这些对象在产品的创建
 过程中不易得到。

 

附件：包含了能直接运行的实例。