cocos ceator笔记（7）

1.单例模式

//创建单例方法1  代码运行的时候就生成对象
class SoundManager{
	static Instance = new SoundManager();//设置一个静态对象，对象属于类
	private constructor(){}
}
//用声音管理类
SoundManager.Instance

//创建单例方法2  用的时候才会创建对象
class SoundManager{
	private static instance : SoundManager;//设置一个静态对象，对象属于类
	private constructor(){}
	static Instance(){
		//当前单例是否产生
		//懒加载
		if(!SoundManager.instance){
			SoundManager.instance = new SoundManger();
		}
		return SoundManger.instance;
	}
}
	
//用声音管理类
SoundManager.Instance();

2.代理模式

interface ICalc{
	calc(num1,num2):number;
}

class Npc1 implements ICalc{
	calc(num1,num2){
		return num1+num2;
	}
}
//不同的代理 相同协议不同的作用
class Npc2 implements ICalc{
	calc(num1,num2){
		return num1 - num2;
	}
}

class Person{
	//代理
	delegate:ICalc;//遵循协议就可以成为代理
	//计算数字
	GutNum(num1,num2){
		//拿到num1和2计算后的结果
		let num = this.delegate.calc(num1,num2);
		document.write(num +"");
	}
]

let person = new Person();
//设定一个代理
person.delegate = new Npc1();
person.GetNum(4,3);//输出7
perosn.GetNum(4,3);//输出1

3.观察者模式

一个对象被其他对象监听，只要该对象改变，就通知所有监听他的对象

interface IObserver{
	nameChanged(newName);
}

class Person{
	private _name:string;
	//所有的观察者,创建一个观察者数组
	observers:Array<IObserver> = new Array<IOberserve>();
	set name(value){
		this._name = value;
		//发生变化
		//遍历观察者数组，给所有观察者发消息
		for(let observe of this.observes){
			observe.nameChanged(this.name);
		}
	}
	get name(){
		return this._name;
	}
}
class Test implements IObserver{
	nameChanged(newName){
		document.write("监听到变化，名称变为"+ newName);
	}
}
let person = new Person();
//设置为监听对象
person.observers.push(test);//把test加入监听数组中
person.name = "hhh";

输出结果：

4.工厂模式

不用管他内部是怎么工作的，传入对应数据，会传出对应的数据

enum CarType{
	Bmw,
	Audi,
	Benz
}

class Car{
	name:string;
	//工厂方法
	static Create(carType :CarType):Car{
		let car:Car;
		switch(cartype){
			case Cartype Audi():
				car = new Audi;
				break;
			case Cartype Benz():
				car = new Benz;
				break;
			case Cartype Bmw();
				car = new Bmw;
				break;
		}
		return car;
	}
}

class Bmw extends Car{ }
class Benz extends Car{ }
class Audi extends Car{ }

let bmw = Car.Create(CarType.Benz);

5.链表

数组是连续型的，链表是离散型

class Person{
	name:string;
	next:Person; 

	constructor(name){
		this.name = name;
	}
}
let person = new Person("李逍遥");
person.next = new Person("王小虎");
person.next.next = new Person("赵灵儿");

//删除
person.next = person.next.next;//把李逍遥后变为赵灵儿

//添加
let tmpPerson = new Person("赵四");
person.next = tmpPerson;

while(person){
	document.write(person.name);
	//让节点后移
	person = person.next
}