设计模式入门笔记 01 Creational Pattern

CS基础设计模式

CS基础

Publish Date: 2021-12-08

Update Date: 2021-12-08

简单点说，设计模式就是一种解决特定问题的组织代码的方式，这种方式经过多次的验证，可以有效提高项目的可维护程度，让代码结构更加清晰。

因为是非科班菜鸡，没仔细学过，所以以cousera的design pattern为基础进行入门学习。本篇blog总结一下creational pattern相关的两种设计模式

Singleton Pattern

就是常说的单例，有的时候需要一个class只能创建一个实例（比如我们用一个class表示游戏菜单，那肯定不希望这个class能创建多个object，否则会造成冲突）。

代码

class Singleton {
    constructor() {
        
    }

    static getInstance() {
        if(!this.instance) {
            this.instance = new Singleton();
        }
        return this.instance;
    }
}

//其实用js实现singleton会有一些问题，比如constructor不能设置为private

实现singleton有这么几个要点：

私有化constructor防止直接创建对象（用java/c++会比较清晰）
class内部设置一个private static变量，用来引用未来创建的对象，同时private防止对象被直接篡改，更安全
提供一个公共的访问函数（public getInstance），这是访问class实例的唯一方法

Singleton Pattern解决了什么问题？

其实课程说的比较清楚了

对于一些特殊的class，我们希望它只能创建一个obejct，否则多人参与项目时很可能造成冲突
对象只有在真正被需要时才会被创建，如果之前对象不存在，只有调用getInstance时才会进行创建操作

Factory Method Pattern

Factory Method Pattern就是提供一个批量创建object的factory，比如我们需要创建很多同类型的object，这个时候就需要工厂模式

代码

class AbstractShapeFactory{
    constructor(){
        if (new.target === AbstractShapeFactory) {
            throw new Error('不能实例化抽象类')
        }
    }

    getShape(){
        throw new Error('抽象工厂方法(getShape)不允许直接调用')
    }
}

class AbstractShape{
    constructor(name, color){
        if (new.target === AbstractShape) {
            throw new Error('不能实例化抽象类')
        }

        this.name = name
        this.color = color
    }
}

class Circle extends AbstractShape{
    constructor(name, color){
        super(name, color)
    }
}

class Rectangle extends AbstractShape{
    constructor(name, color){
        super(name, color)
    }
}

class CircleFactory extends AbstractShapeFactory{
    constructor(){
        super()
    }

    getShape(){
        return new Circle('circle', 'red')
    }
}

class RectangleFactory extends AbstractShapeFactory{
    constructor(){
        super()
    }

    getShape(name, color){
        return new Rectangle(name, color)
    }
}

class OrderShapeShop{
    constructor(){
        this.rectangleFactory = new RectangleFactory()
        this.circleFactory = new CircleFactory()
    }

    orderShape(type){
        if(type === 'circle'){
            return this.rectangleFactory.getShape('rectangle', 'blue')
        }else if(type === 'rectangle'){
            return this.circleFactory.getShape('circle', 'red')
        }
    }
}

这里用两个factory进行模拟，class OrderShapeShop就是client。

其实factory可以结合之前的singleton pattern，毕竟factory没必要有多个

Factory Method Pattern带来了什么好处

降低耦合度，class OrderShapeShop并不参与object的创建过程，他只是获取对象，就算增加新的factory代价也很小
面向接口编程（js不太能体现出这个优势）而不是面向实现，可以用一个Shape interface变量接受factory创建出的对象，就算增加新的factory也不会影响原有的代码