四种常用模式（笔记）

四种常用模式（笔记）

单例模式

只能生成一个对象的类，常用于管理类，存储数据等，让所有需要使用的场景可以共同使用同一个对象。

实现方法：1、将构造方法私有化，在类中定义一个静态对象，该静态对象就是该类唯一的一个对象，且在定义时直接创建。

class SoundManager{
	static Instance = new SoundManager();
	private constructor(){
	
	}
}
SoundManager.Instance//外部调用

2、将单例对象和方法分开写，只有在使用的时候才会创建这个单例对象。

class SoundManager{
	private static instance = null;
	private constructor(){
	
	}
	static Instance(){
        //当前单例是否产生，懒加载
		if(!SoundManager.instance){
            SoundManager.instance = new SoundManager();
        }
         return SoundManager.instance;
	}
}
SoundManager.Instance()//外部调用

代理模式

简单理解：做同一件事情，但让不同的代理对象去执行会得到不同的结果。

简单的实现方法：先定义一个接口，再在不同的类中实现。

//类似于网络协议
interface ICalc{
	calc(num1:number,num2:number):number;
}
//具体的协议的内容
class Npc1 implements ICalc{
    calc(num1:number,num2:number):number{
        return num1+num2;
    }
}
class Npc2 implements ICalc{
    calc(num1:number,num2:number):number{
        return num1-num2;
    }
}
class Person{
    //代理
    delegate:ICalc;
    //两数运算方法
    getNum(num1:number,num2:number){
       return this.delegate.calc(num1,num2);
    }
}
//外部的使用
let p = new Person();
p.delegate = new Npc1();
console.log(p.getNum(4,3));

观察者模式

多个类监听一个类，当被监听的这个类发生改变时，就做出各自不同的反应。

interface IObserver{
    nameChanged(newName);
}
class Person{
    private _name:string;
    //存放所有的观察者
    observers:Array<IObserver> = new Array<IObserver>();
    set name(value){
        this._name = value;
        //名字发生改变，遍历观察者，并向观察者类发送数据
        for(let i of this.observers){
            i.nameChanged(this._name);
        }
    }
    get name(){
        return this._name;
    }
}
class Test implements IObserver{
    nameChanged(newName){
        console.log("监听改变，变为"+newName);
    }
}
let p = new Person();
let test = new Test();
p.observers.push(test);
p.name = "hello";

工厂模式

提出一个需求，然后通过类似流水线的方式生产出对应的东西。

简单实现

enum CarType{
    bwm,
    benz
}
class Car{
    name:string;
    static create(carType:CarType){
        let car:Car;
        switch(carType){
            case CarType.bwm:
                car = new Bwm();
                break;
            case CarType.benz:
                car = new Benz();
                break;
        }
    }
}
class Bwm extends Car{ }
class Benz extends Car{ }
let benz1 = Car.create(CarType.benz);