设计模式-Builder模式

最新推荐文章于 2024-05-02 18:33:48 发布

原创最新推荐文章于 2024-05-02 18:33:48 发布 · 1.3k 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#Java #设计模式 #Builder模式 #UML类图

设计模式专栏收录该内容

28 篇文章

订阅专栏

本文详细介绍了Builder设计模式，包括模式定义、使用场景、UML类图解析以及具体实现，帮助读者全面掌握如何在Java中应用Builder模式进行对象构建。

1.Builder模式介绍

Bulder模式是一步步创建一个复杂对象的创建模型，它允许用户在不知道内部构建细节
的情况下可以更精细地控制对象的构造流程该模式为将构建复杂对象的过程和它的部件
解耦，使得构建过程和部件的表示隔离开来。

2.Builder模式的定义

将一个负责对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示

3.Builder模式的使用场景

3.1 相同的方法，不同的执行顺序，产生不同的事件结果
3.2 多个部件或零件，都可以装配到一个对象中，但是产生的运行结果又不相同
3.3 产品类非常复杂，或者产品类中的调用顺序不同产生了得作用，这个时候需要使用
Builder模式
3.4 当初始化一个对象特别的复杂，如参数多，且很多参数都具有默认值时

4.UML类图

5.实现

例如车的组装过程比较复杂，并且组装顺序是不固定的，下面我们以车的组装为例子简化
构建轮胎、车体形状、牌子等3个部分然后通过Director和具体的Builder类来构建车。
1.

<span style="font-size:14px;">	/**
	 * 车的抽象类，即Product角色
	 * Created by Teaphy
	 * 2016/3/12.
	 */
	public abstract class Car {
		String tire; // 轮胎
		String cabin;  // 车体
		String brand; // 车牌

		protected Car() {

		}

		// 设置轮胎
		public void setTire(String tire) {
			this.tire = tire;
		}
		// 设置车体
		public void setCabin(String cabin) {
			this.cabin = cabin;
		}

		// 设置车牌
		public abstract void setBrand();

		@Override
		public String toString() {
			return "Car{" +
					"tire='" + tire + '\'' +
					", cabin='" + cabin + '\'' +
					", brand='" + brand + '\'' +
					'}';
		}
	}</span>

<span style="font-size:14px;">	/**
	 * 具体的Car类 BMWCar
	 * Created by Teaphy
	 * 2016/3/12.
	 */
	public class BMWCar extends Car {

		protected BMWCar() {

		}

		public void setBrand() {
			brand = "BMW";
		}
	}</span>

<span style="font-size:14px;">	/**
	 * 抽象Builder类
	 * Created by Teaphy
	 * 2016/3/12.
	 */
	public abstract class Builder {
		// 设置轮胎
		public abstract void buildTire(String tire);

		// 设置车身
		public abstract void buildCabin(String cabin);

		// 设置牌子
		public abstract void buildBrand();

		// 创建Car
		public abstract Car create();
	}</span>

	/** 
	 * 具体的Builder类  BWMCarBuilder
	 * Created by Teaphy
	 * 2016/3/12.
	 */
	public class BWMCarBuilder extends Builder {

		private Car mBmwCar = new BMWCar();

		public void buildTire(String tire) {
			mBmwCar.setTire(tire);
		}

		public void buildCabin(String cabin) {
			mBmwCar.setCabin(cabin);
		}

		public void buildBrand() {
			mBmwCar.setBrand();
		}

		public Car create() {
			return mBmwCar;
		}
	}

	/**
	 * Director类 负责构造Car
	 * Created by Teaphy
	 * 2016/3/12.
	 */
	public class Director {
		private Builder mBuilder = null;

		public Director(Builder mBuilder) {
			this.mBuilder = mBuilder;
		}

		public void construct(String tire, String cabin) {
			mBuilder.buildTire(tire);
			mBuilder.buildCabin(cabin);
			mBuilder.buildBrand();
		}
	}

6.测试类

	public class TestBuilder {
		public static void main(String[] args) {
			// 构建器
			Builder builder = new BWMCarBuilder();
			Director mDirector = new Director(builder);
			// 封装构建过程
			mDirector.construct("米其林", "流线型");
			// 构建Car
			Car car = builder.create();

			System.out.println(car.toString());
	}

7.
输出结果：Car{tire='米其林', cabin='流线型', brand='BMW'}

在上述示例中，通过Director类来构建BMWCar对象，而Director封装了构建负责对象的过程，对外隐藏了构建细节。Builder和Director一起将一个复杂的对象与它的表示分离，使得同样的构建创建不同的对象。
在实际开发过程中，Director角色经常被忽略，直接是用Builder来进行对对象封装构建，这个Builder通常为链式调用，它的关键点在于每个setter方法都返回自身，也就是return this;这样使得setter方法可以链式调用

<span style="font-size:14px;">	A.
	/**
	 * 抽象Builder类
	 * Created by Teaphy
	 * 2016/3/12.
	 */
	public abstract class _Builder {
		// 设置轮胎
		public abstract _Builder buildTire(String tire);

		// 设置车身
		public abstract _Builder buildCabin(String cabin);

		// 设置牌子
		public abstract _Builder buildBrand();

		// 创建Car
		public abstract Car create();
	}

	B.
	/**
	 * 具体的Builder类  BWMCarBuilder
	 * Created by Teaphy
	 * 2016/3/12.
	 */
	public class BuickBuilder extends _Builder {

		private BuickCar mBuickCar = new BuickCar();

		public _Builder buildTire(String tire) {
			mBuickCar.setTire(tire);
			return this;
		}

		public _Builder buildCabin(String cabin) {
			mBuickCar.setCabin(cabin);
			return this;
		}

		public _Builder buildBrand() {
			mBuickCar.setBrand();
			return this;
		}

		public Car create() {
			return mBuickCar;
		}
	}
	
	C. 测试类
	public class TestBuilder {
		public static void main(String[] args) {

			// 构建器
			_Builder _Builder = new BuickBuilder();
			// 构建
			// 构建时，将构建顺序颠倒，
			_Builder
					.buildBrand()
					.buildCabin("流线型")
					.buildTire("玛吉斯");
			System.out.println(_Builder.create().toString());
		}
	}
	
	D.
	
	输出结果：Car{tire='玛吉斯', cabin='流线型', brand='Buick'}</span>