软件构造-可复用性-Template模式

问题：不同的客户端具有相同的算法步骤，但是每个步骤的具体实现不同。
Template模式：在父类中定义通用的逻辑和各步骤的抽象方法声明，在子类中进行各步骤的具体实现。

图示如下：

TemplateAbstraction抽象类：父类，定义通用的逻辑和各步骤的抽象方法声明；
ImplementationA类：子类，具体实现各步骤；
ImplementationB类：子类，具体实现各步骤；
Client类：客户端。

举例：

TemplateAbstraction抽象类：

public abstract class CarBuilder { // TemplateAbstraction抽象类
	
	protected abstract void BuildSkeleton(); // 抽象步骤1
	protected abstract void InstallEngine(); // 抽象步骤2
	protected abstract void InstallDoor(); // 抽象步骤3
	
	public void BuildCar() { // 通用逻辑		
		BuildSkeleton();
		InstallEngine();
		InstallDoor();
	}

}

ImplementationA类：

public class PorcheBuilder extends CarBuilder { // ImplementationA类

	@Override
	protected void BuildSkeleton() {
		System.out.println("Building Porche Skeleton");
	}

	@Override
	protected void InstallEngine() {
		System.out.println("Installing Porche Engine");
	}

	@Override
	protected void InstallDoor() {
		System.out.println("Installing Porche Door");
	}

}

ImplementationB类：

public class BeetleBuilder extends CarBuilder { // ImplementationB类

	@Override
	protected void BuildSkeleton() {
		System.out.println("Building Beetle Skeleton");
	}

	@Override
	protected void InstallEngine() {
		System.out.println("Installing Beetle Engine");
	}

	@Override
	protected void InstallDoor() {
		System.out.println("Installing Beetle Door");
	}

}

Client类：

public class Client { // Client

	public static void main(String[] args) {
		CarBuilder carBuilder = new PorcheBuilder();
		carBuilder.BuildCar();
		
		System.out.println();
		
		carBuilder = new BeetleBuilder();
		carBuilder.BuildCar();
	}

}

结果：
Building Porche Skeleton
Installing Porche Engine
Installing Porche Door

Building Beetle Skeleton
Installing Beetle Engine
Installing Beetle Door