（二）设计模式——构建器，原型模式

构建器(builder)

---

描述：

将一个复杂对象的构建与其表示相分离，使得同样的构建过程(稳定)可以创建不同的表示(变化)。

builder 模式主要用于“分步骤构建一个复杂的对象”。在这其中 “分步骤”是一个稳定的算法，而复杂对象的各个部分则经常变化。

场景：

某游戏软件中人物角色包括多种类型，不同类型的人物角色，其性别、脸型、服装、发型等外部特征有所差异，使用建造者模式创建人物角色对象，请根据类图编程实现该系统,并写出相应Java代码

 

 

java代码

package org.crudboy;

/** 人物类 **/
class Actor {
    private String type;
    private String sex;
    private String face;
    private String costume;
    private String hairstyle;

    public void setType(String type) {
        this.type=type;
    }
    public void setSex(String sex) {
        this.sex=sex;
    }
    public void setFace(String face) {
        this.face=face;
    }
    public void setCostume(String costume) {
        this.costume=costume;
    }
    public void setHairstyle(String hairstyle) {
        this.hairstyle=hairstyle;
    }

    public String toString() {
        return "Actor{" +
                "type='" + type + '\'' +
                ", sex='" + sex + '\'' +
                ", face='" + face + '\'' +
                ", costume='" + costume + '\'' +
                ", hairstyle='" + hairstyle + '\'' +
                '}';
    }
}

abstract class ActorBuilder {
    protected Actor actor = new Actor();
    public abstract void buildType();
    public abstract void buildSex();
    public abstract void buildFace();
    public abstract void buildCostume();
    public abstract void buildHairstyle();
    public Actor createActor() {
        return actor;
    }
}

class HeroBuilder extends ActorBuilder {
    public void buildType() {
        actor.setType("英雄");
    }
    public void buildSex() {
        actor.setSex("男");
    }
    public void buildFace() {
        actor.setFace("英俊");
    }
    public void buildCostume() {
        actor.setCostume("盔甲");
    }
    public void buildHairstyle() {
        actor.setHairstyle("飘逸");
    }
}

class AngelBuilder extends ActorBuilder {
    public void buildType() {
        actor.setType("天使");
    }
    public void buildSex() {
        actor.setSex("女");
    }
    public void buildFace() {
        actor.setFace("漂亮");
    }
    public void buildCostume() {
        actor.setCostume("白裙");
    }
    public void buildHairstyle() {
        actor.setHairstyle("披肩长发");
    }
}

class GhostBuilder extends ActorBuilder {
    public void buildType() {
        actor.setType("魔鬼");
    }
    public void buildSex() {
        actor.setSex("妖");
    }
    public void buildFace() {
        actor.setFace("丑陋");
    }
    public void buildCostume() {
        actor.setCostume("黑衣");
    }
    public void buildHairstyle() {
        actor.setHairstyle("光头");
    }
}

class ActorController {
    static public Actor construct(ActorBuilder ab) {
        ab.buildType();
        ab.buildSex();
        ab.buildFace();
        ab.buildCostume();
        ab.buildHairstyle();
        return ab.createActor();
    }
}

public class Builder {
    public static void main(String[] args) {
        Actor actor = ActorController.construct(new AngelBuilder());
        System.out.println(actor);
    }
}

 

看完了代码，那么如何理解”相同的构建过程(稳定)可以创建不同的表示(变化)“
呢？

在抽象的Builder类中指定了构造对象的各个步骤，而在Controller类中指定步骤执行顺序，后面也不会再做改变（稳定）。

而每个步骤的具体实现则可由具体实现类来决定（变换）。

看起来是不是有点像模板方法（template method)？我个人理解是构建器模式侧重点于对象的创建过程，而模板方法则比较广泛。

 

原型（prototype)

---

描述：

用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象

场景：

在某OA系统中，用户可以创建工作周报，由于某些岗位每周工作存在重复性，因此可以通过复制原有工作周报并进行局部修改来快速创建工作周报，现使用原型模式来实现该功能，请根据类图编程实现该系统,并写出相应Java代码。

 

 

java代码
 

package org.crudboy;

class WeeklyLog implements Cloneable
{
    private String name;
    private String date;
    private String content;

    public void setName(String name) {
        this.name = name;
    }
    public void setDate(String date) {
        this.date = date;
    }
    public void setContent(String content) {
        this.content = content;
    }

    @Override
    public String toString() {
        return "WeeklyLog{" +
                "name='" + name + '\'' +
                ", date='" + date + '\'' +
                ", content='" + content + '\'' +
                '}';
    }

    public WeeklyLog clone() {
        try {
            WeeklyLog clone = (WeeklyLog) super.clone();
            return clone;
        } catch (CloneNotSupportedException e) {
            throw new AssertionError();
        }
    }
}

public class Prototype {
    public static void main(String[] args) {
        WeeklyLog logOfWeek1 = new WeeklyLog();
        logOfWeek1.setName("wincing");
        logOfWeek1.setDate("2022-week1");
        logOfWeek1.setContent("do work");
        System.out.println(logOfWeek1);

        WeeklyLog logOfWeek2 = logOfWeek1.clone();
        logOfWeek2.setDate("2022-week2");
        System.out.println(logOfWeek2);
    }
}

原型模式比较简单，我们日常写代码就会有这种场景：对于某段shit mountain，我们会用CV大法并在原基础上修改一些参数之类。其实这正是prototype的思想。