GoF之模板模式、建造者模式详解

模板方法模式（Template Pattern）
定义了一个算法的步骤，并允许子类别为一个或多个步骤提供其实践方式。让子类别在不改变算法架构的情况下，重新定义算法中的某些步骤。
优点：
1、封装不变部分，扩展可变部分。
2、提取公共代码，便于维护。
3、行为由父类控制，子类实现。
缺点：
每一个不同的实现都需要一个子类来实现，导致类的个数增加，使得系统更加庞大。

具体实现：创建一个抽象的游戏模板，包含游戏的通用的行为方法。其他游戏各自进行实现，再调用父类模板方法。
//创建一个抽象类，它的模板方法被设置为 final。
public abstract class Game {
abstract void initialize();
abstract void startPlay();
abstract void endPlay();
//模板
public final void play(){
//初始化游戏
initialize();
//开始游戏
startPlay();
//结束游戏
endPlay();
}
}

//创建扩展抽象类Game的实体类。
public class Cricket extends Game {
@Override
void endPlay() {
System.out.println(“CricketGame Finished!”);
}
@Override
void initialize() {
System.out.println(“CricketGame Initialized! Start playing.”);
}
@Override
void startPlay() {
System.out.println(“CricketGame Started. Enjoy the game!”);
}
}

public class Football extends Game {
@Override
void endPlay() {
System.out.println(“FootballGame Finished!”);
}
@Override
void initialize() {
System.out.println(“FootballGame Initialized! Start playing.”);
}
@Override
void startPlay() {
System.out.println(“FootballGame Started. Enjoy the game!”);
}
}

//使用Game的模板方法 play() 来演示游戏的定义方式。
public class TemplatePatternClient {
public static void main(String[] args) {
Game game = new Cricket();
game.play();
System.out.println();
game = newFootball();
game.play();
}
}
执行程序，输出结果：
Cricket Game Initialized! Start playing.
Cricket Game Started.Enjoy the game!
Cricket Game Finished!

    Football GameInitialized! Start playing.
    Football Game Started.Enjoy the game!
    Football GameFinished!

模板方法模式的主要思想：定义一个算法流程，将一些特定步骤的具体实现、延迟到子类。使得可以在不改变算法流程的情况下，通过不同的子类重定流程中的特定的步骤。

建造者（Builder Pattern）模式：
将一个复杂对象分解成多个相对简单的部分，然后根据不同需要分别创建它们，最后构建成该复杂对象。
优点：
1、建造者独立，易扩展。
2、便于控制细节风险。
缺点：
1、产品必须有共同点，范围有限制。
2、如内部变化复杂，会有很多的建造类，难以维护。
使用场景：
一些基本部件不会变，而其组合经常变化的时候。

具体实现：
//产品角色：包含多个组成部件的复杂对象，由具体建造者来创建其各个零部件。
class Product{
private String partA;
private String partB;
private String partC;
public void setPartA(String partA){
this.partA=partA;
}
public void setPartB(String partB){
this.partB=partB;
}
public void setPartC(String partC){
this.partC=partC;
}
public void show(){
//显示产品的特性
}
}

//抽象建造者：创建产品各个子部件的抽象方法的接口，通常还包含一个返回复杂产品的方法 getResult()。
abstract class Builder {
//创建产品对象
protected Product product=newProduct();
public abstract void buildPartA();
public abstract void buildPartB();
public abstract void buildPartC();
//返回产品对象
public Product getResult(){
return product;
}
}

//具体建造者：实现了抽象建造者接口，完成复杂产品的各个部件的具体创建方法。
public class ConcreteBuilder extends Builder {
public void buildPartA(){
product.setPartA(“建造 PartA”);
}
public void buildPartB(){
product.setPartA(“建造 PartB”);
}
public void buildPartC(){
product.setPartA(“建造 PartC”);
}
}

/指挥者：调用建造者对象中的部件构造与装配方法完成复杂对象的创建，
在指挥者中不涉及具体产品的信息。将客户端与创建过程解耦。/
class Director{
private Builder builder;
public Director(Builder builder){
this.builder=builder;
}
//产品构建与组装方法
public Product construct(){
builder.buildPartA();
builder.buildPartB();
builder.buildPartC();
return builder.getResult();
}
}

//客户类，调用指挥者进行对象的创建。
public class Client {
public static void main(String[] args) {
Builder builder=new ConcreteBuilder();
Director director=new Director(builder);
Product product=director.construct();
product.show();
}
}

建造者模式可以将部件和其组装过程分开，一步一步创建一个复杂的对象。用户只需要指定复杂对象的类型就可以得到该对象，而无须知道其内部的具体构造细节。

模板模式和建造者模式比较
建造者是使用组合方式实现不同的表示，而模板方法使用的是继承的方式。组合优于继承。建造者抽象的是构建过程，模板方法提取的是实现公共。

更多技术分享，微信关注“专注一行代码”

https://mp.weixin.qq.com/s/NCN0-c-VxOFjFZohSMFC8g