创建型设计模式（上）

单例模式：

　　1、定义：单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例，这个类称为单例类

　　2、实现过程要点：

　　　　(1)单例类的构造函数为私有

　　　　(2)提供一个自身的静态私有成员变量

　　　　(3)提供一个公有的静态工厂方法

　　3、优点：

　　　　(1)提供了对唯一实例的受控访问

　　　　(2)由于在系统内存中只存在一个对象，因此可以节约系统资源

　　　　(3)允许可变数目的实例。我们可以基于单例模式进行扩展，使用与单例控制相似的方法来获得指定个数的对象实例

　　4、缺点：

　　　　(1)单例模式中没有抽象层，因此单例类的扩展有很大的困难

　　　　(2)单例类的职责过重，在一定程度上违背了“单一职责原则”

　　　　(3)滥用单例将带来一些负面问题；如采用垃圾自动回收机制的语言，实例化的对象若长期未被使用，

　　　　  则会被清除掉，下次要再使用该类则需重新实例化，而导致原来的状态没有了

　　5、适用环境：

　　　　(1)系统只需要一个实例对象

　　　　(2)客户调用类的单个实例只允许使用一个公共访问点，除了该公共访问点，不能通过其他途径访问该实例

class Singleton1 {
  private static instance: Singleton1 = new Singleton1();  // 静态私有成员变量
  private constructor() {}  // 私有构造函数，防止外部调用它生成其他实例
  // 公有静态工厂方法
  static getInstance(): Singleton1 {
    return Singleton1.instance;
  }
}

const singleton_one: Singleton1 = Singleton1.getInstance();
const singleton_two: Singleton1 = Singleton1.getInstance();
console.log(singleton_one === singleton_two); // true

构建者模式：

　　1、定义：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示

　　2、模式结构：

　　　　(1)抽象建造者 Builder　　(2)具体建造者 ConcreteBuilder

　　　　(3)指挥者 Director　　  (4)产品角色 Product

　　3、优点：

　　　　(1)客户端不必知道产品内部组成细节，将产品本身与产品的创建过程解耦

　　　　(2)每一个具体建造者都相对独立，与其他具体建造者无关，用户使用不同的具体建造者即可得到不同的产品对象

　　　　(3)可以更加精细地控制产品的创建过程

　　　　(4)增加新的具体建造者无须修改原有类的代码，指挥者类对抽象建造者类编程，系统扩展方便，符合“开闭原则”

　　4、缺点：

　　　　(1)建造者模式所创建的产品一般具有较多的共同点，其组成部分相似，

如果产品之间的差异性很大，则不适合使用建造者模式，因此其使用范围受到一定的限制

　　　　(2)如果产品的内部变化复杂，可能会导致需要定义很多具体建造者类来实现这种变化，导致系统变得很庞大

　　5、适用场景：

　　　　(1)需要生成的产品对象有复杂的内部结构，这些产品对象通常包含多个成员属性

　　　　(2)需要生成的产品对象的属性相互依赖，需要指定其生成顺序

　　　　(3)对象的创建过程独立于创建该对象的类

　　　　(4)隔离复杂对象的创建和使用，并使得相同的创建过程可以创建不同的产品

// 产品角色
class Computer {
    private cpu: string;
    private mainBoard: string;
    private memory: string;
    private hardDisk: string;

    setCpu(cpu: string): void {
        this.cpu = cpu;
    }
    setMainBoard(mainBoard: string): void {
        this.mainBoard = mainBoard;
    }
    setMemory(memory: string): void {
        this.memory = memory;
    }
    setHardDisk(hardDisk: string):void {
        this.hardDisk = hardDisk;
    }

    getCpu(): string {
        return this.cpu;
    }
    getMainBoard(): string {
        return this.mainBoard;
    }
    getMemory(): string {
        return this.memory;
    }
    getHardDisk(): string {
        return this.hardDisk;
    }
}

// 抽象建造者
interface Builder {
    createCpu(cpu: string): void;
    createMainBoard(mainBoard: string): void;
    createMemory(memory: string): void;
    createHardDisk(hardDisk: string): void;

    createComputer(): Computer;
}

// 具体建造者
class ConcreteBuilder implements Builder {
    private computer: Computer = new Computer();

    createCpu(cpu: string): void {
        this.computer.setCpu(cpu);
    }
    createMainBoard(mainBoard: string): void {
        this.computer.setMainBoard(mainBoard);
    }
    createMemory(memory: string): void {
        this.computer.setMemory(memory);
    }
    createHardDisk(hardDisk: string): void {
        this.computer.setHardDisk(hardDisk);
    }

    createComputer(): Computer {
        return this.computer;
    }
}

// 指挥者
class Director {
    private builder: Builder;
    constructor(builder: Builder) {
        this.builder = builder;
    }
    createComputer(cpu: string, mainBoard: string, memory: string, hardDisk: string): Computer {
        this.builder.createCpu(cpu);
        this.builder.createMainBoard(mainBoard);
        this.builder.createMemory(memory);
        this.builder.createHardDisk(hardDisk);

        return this.builder.createComputer();
    }
}

let builder: Builder = new ConcreteBuilder();
let director: Director = new Director(builder);
let computer: Computer = director.createComputer("i7", "Lenovo", "8G", "1T");
console.log(computer.getCpu()); // i7
console.log(computer.getMainBoard());   // Lenovo
console.log(computer.getMemory());  // 8G
console.log(computer.getHardDisk());    // 1T

原型模式：

　　1、定义：用原型实例指定创建对象的种类，并且通过复用这些原型创建新的对象

　　2、要点：

　　　　(1)通过克隆来创建新的对象实例

　　　　(2)为克隆出来的新的对象实例复制原型实例属性的值

　　3、优点：

　　　　(1)可以在运行时动态根据原型生成新的种类的对象

　　　　(2)对客户端隐藏具体的实现类型

　　4、缺点：

　　　　每个原型的子类都必须实现 clone 的操作，尤其是包含引用类型的对象时，克隆会比较麻烦

　　5、适用场景：

　　　　(1)需要一个类的大量对象的时候，使用原型模式是最佳选择，

　　　　  因为原型模式是在内存中对这个对象进行拷贝，要比直接new这个对象性能要好很多

　　　　(2)如果一个对象的初始化需要很多其他对象的数据准备或其他资源的繁琐计算，那么可以使用原型模式

　　　　(3)当需要一个对象的大量公共信息，少量字段进行个性化设置的时候，

　　　　  也可以使用原型模式拷贝出现有对象的副本进行加工处理

// Prototype
interface Clonable<T> {
    clone(): T;
}
// ConcretePrototype
class Origin implements Clonable<Origin> {
    name: string;

    clone(): Origin {
        let target: Origin = new Origin();
        target.name = this.name;
        return target;
    }
}

let orign: Origin = new Origin();
orign.name = "Lemon";
let cloneObj: Origin = orign.clone();
console.log(cloneObj.name); // Lemon

原文地址：https://www.cnblogs.com/lemonyam/p/11617344.html