2023-02-24 学习记录--TS-邂逅TS（三）—— 设计模式

TS-邂逅TS（三）—— 设计模式

不积跬步，无以至千里；不积小流，无以成江海。💪🏻

一、单例模式 ⭐️

单例模式：保证一个类只能被实例化一次，从而只能产生一个对象。

1、方法一、饿汉模式（预加载）

使用 🎈：类加载时就实例化；
缺点 🐟：由于定义类时就实例化，但假如有些类不需要用到对象，就没必要在类里实例化一下了。

class SoundManager {
    /** 使用 🎈：类加载时就实例化 */
    // 前面加个static，变成静态属性，可以直接通过类来调用该属性
    // 实例化对象 new一下
    static Instance = new SoundManager();

    // 成员属性
    name: string = "小萝卜儿";
    
    // 在constructor前面加个private，变成私有的，不允许在子类和外部实例化对象（new一下）
    private constructor(){}
}

// 通过类调用静态属性，获取到对象
const soundManager = SoundManager.Instance;
// 获取到对象里的成员属性name
const gotName = soundManager.name;
console.log(gotName); // 小萝卜儿

2、方法二、懒汉模式（懒加载）【更推荐 🦄】

使用 🎈：用懒加载形式实现单例模式。

class SoundManager {
    // 前面加个static，变成静态属性，可以直接通过类来调用该属性
    // 前面加个private，变成私有的，不允许在子类和外部访问该属性
    private static instance: SoundManager;
    
    // 成员属性
    name: string = "小萝卜儿";
    
    // 在constructor前面加个private，变成私有的，不允许在子类和外部实例化对象（new一下）
    private constructor(){}

    /** 使用 🎈：用懒加载形式实现单例模式 */
    // 前面加个static，变成静态方法，可以直接通过类来调用该方法
    static Instance() {
        // 判断当前单例是否产生
        // 懒加载：需要用到对象时，再实例化对象
        if(!SoundManager.instance) {
            // 实例化对象 new一下
            SoundManager.instance = new SoundManager();
        }
        return SoundManager.instance;
    }
}

// 通过类调用静态方法，获取到对象
const soundManager = SoundManager.Instance();
// 获取到对象里的成员属性name
const gotName = soundManager.name;
console.log(gotName); // 小萝卜儿

二、代理模式 ⭐️

// 定义一个计算接口
interface ICalc {
    // 注意这里的方法要写成不被实现的
    calc(num1: number, num2: number): number;
}

// 被代理人1
class Npc1 implements ICalc {
    // 必须实现接口里的方法
    calc(num1: number, num2: number) {
        return num1 + num2;
    }
}

// 被代理人2
class Npc2 implements ICalc {
    // 必须实现接口里的方法
    calc(num1: number, num2: number) {
        return num1 - num2;
    }
}

// 代理人
class Person {
    // 代理 默认给被代理人1
    delegate: ICalc = new Npc1;
    
    // 成员方法 计算数字
    GetNum(num1: number, num2: number) {
        // 拿到num1和2计算后的结果
        const num = this.delegate.calc(num1,num2);
        console.log(num);
    }
}

// 实例化对象 new一下
let person = new Person();
// 情况1、设定一个代理，代理给被代理人1
// person.delegate = new Npc1(); // 默认是给的被代理人1
person.GetNum(3, 4); // 7
// 情况2、设定一个代理，代理给被代理人2
person.delegate = new Npc2(); // 代理给被代理人2
person.GetNum(7, 4); // 3

三、观察者模式 ⭐️

// 举例：监听一个名字的变化

// 接口 IObserver
interface IObserver {
    // 注意这里的方法要写成不被实现的
    nameChanged(newName: any): any;
}

// 类 Person
class Person {
    // 前面加个private，变成私有的，不允许在子类和外部访问该属性
    private _name: string = "默认名";
    // 所有的观察者
    observers: Array<IObserver> = new Array<IObserver>();

    // 属性寄存器 set（赋值）、get（取值）
    // 赋值
    set name(value) {
        this._name = value;
        // 发生变化
        // 遍历观察者数组，给所有的观察者发消息
        for(let observer of this.observers) {
            observer.nameChanged(this._name);
        }
    }
    // 取值
    get name() {
        return this._name;
    }
}

// 类 Test
class Test implements IObserver {
    // 必须实现接口里的方法
    nameChanged(newName: any) {
        console.log("监听到变化，名字变为" + newName);
    }
}

let person = new Person();
let test = new Test();
// 设置为监听对象
person.observers.push(test);
person.name = "小猪佩奇"; // 监听到变化，名字变为小猪佩奇

四、工厂模式 ⭐️

作用 🌈：方便创建对象。

// 举例：现在有三种车的类型：宝马、奥迪、奔驰

// 枚举 汽车类型
enum CarType {
    Bmw,
    Audi,
    Benz
}

// 父类 Car
class Car {
    // 成员属性
    name: string = "特斯拉";
    // 工厂方法 创建对象
    // 前面加个static，变成静态属性，可以直接通过类来调用该属性
    static Create(carType: CarType): Car {
        let car: Car;
        switch (carType) {
            case CarType.Bmw:
                // 实例化对象 new一下
                car = new Bmw();
                break;
            case CarType.Audi:
                // 实例化对象 new一下
                car = new Audi();
                break;
            case CarType.Benz:
                // 实例化对象 new一下
                car = new Benz();
                break;
        }
        return car;
    }
}

// 子类 Bmw、Benz、Audi
class Bmw extends Car { }
class Benz extends Car { }
class Audi extends Car { }

// 获取到宝马对象
let bmw = Car.Create(CarType.Bmw);
// 获取到奔驰对象
let benz = Car.Create(CarType.Benz);
// 获取到奥迪对象
let audi = Car.Create(CarType.Audi);

上一篇：TS-邂逅TS（二）

今日份TS学习到此结束啦 拜了个拜~