201803012121->深入浅出设计模式:模式总结

-设计模式


简单工厂模式
{
利用swtich开关
根据传入的数据进行分析，返回相对应的对象
Factory：
void method(string a)//传入所需数据
{
swtich(a)//分发数据返回对象
{
case "a":
return new A();
case "b":
return new B();
}
}
}

工厂方法模式
{
利用接口，实例化不同的对象
interface car{}

class BenZi : car{}

car c = new BenZi();
//todo
}

抽象工厂模式
{
是方法工厂模式的进一步提取，结合接口和纯虚基类

abstract class A
{
abstract sayHello SayHello1();
}

interface sayHello
{
void SayHello1();
}

class SayHello1 : sayHello
{
void SayHello1()
{
//todo
}
}

class B : A
{
abstract sayHello SayHello1()
{
return new SayHello1();//利用接口的不同实现，返回指定的对象，就是抽象工厂模式
}
}
}

懒汉单例模式，高并发
{
static T instance；

getInstance
{
if（instance==null）
{
lock
{
if（instance）
{
instance =new T（）；
}
}
}
}
}

创建者模式
{
提供一个创建者用于创建相应的对象

abstract void BaseClass
{
void method1();
void method2();
}

class Creator
{
CreateLogic(BaseClass bc)
{
bc.method1();
bc.method2();
}
}

在使用创建者模式的时候，只需要利用化一个创建者，然后调用创建逻辑，传入想要创建的逻辑实现对象，则可以得到想要的对象
}

原型模式
{
一开始需要将所有原型存入manager中，每一个原型都有一个clone方法，在需要的时候直接clone一个，不需要走初始化等步骤

dictionary<string,T1> dic;

dic.add("1",T1);

T1 =  dic["1"].clone();
}

适配器模式
{
提供一个适配器用于调用传入对象方法

adapter ： iadaptee
{
T t1 =new T（）；
void iadaptee
{
t1.go（）；
}
}
}

桥模式
{
将一个一个的子类存入一个父类中，在外部实例化相应子类对象，存入父类中，最后合成一个父类对象，巷一条一条木竹合成一条桥

class manager
{
bridge1 b1；
bridge2 b2；
}

//使用的时候直接外部传入需要接入的对象便可
Bridge1 ： bridge1{}

bridge1 b1 =new Bridge1();
bridge2 b2 =new Bridge2();

manager ma .b1 = b1;
ma.b2 = b2;
//todo...
}

组合模式
{
将一系列实现同一个接口的子类串在一起

interface i1{}

interface1 : i1 {}

interface2 : i1 {}

interface3 : i1
{
list<i1> l;
}
最后调用interface3的对象便可以得到一连串interface1，interface2接口对象
}

装饰模式
{
利用基类持有接口的引用

interface a{}

class A
{
a a1;
}
class B : A
{
void AddComponent()
{
a1.add(something);//b类对a类进行一次装饰
}
}
class C : AddComponent
{
void AddComponent()
{
a1.add(something);//c类对a类进行多一次装饰
}
}
}

门面模式
{
利用一个类封装其他类

然后调用指定类的方法就可以获取其他类的对象或者调用其他类的方法

class A
{
B b;
C c;
void method1()
{
b.test();
c.test();
}
}
}

享元模式
{
类似与unity中的对象池思想，初始化时存入相应对象，然后需要的时候在池中取出

dictionary<string,T1> dic;

void init()
{
dic.add("1",new T1());
}
void GetT1()
{
return dic["1"]==null）?new T1(): dic[]
}
}

代理模式
{
代理持有原对象的引用，外部调用代理的话就可以调用原对象的方法

interface i1{}

class c1 : i1
{
void do(){}
}

class c2 : i1
{
c1 c;
void do()
{
c.do();
}
}
}

责任链模式
{
通过实例化同一接口的一系列对象，将所有对象串起来

第一个对象不满足条件则将任务指派给下一个对象的引用，继而判断是否满足条件，周而循环

interface i1{}

class c1 : i1
{
i1 next;

void method()
{
if(true)
{
//todo
}
else
{
next.method();
}
}
}
}

解释器模式
{
对接口的不同实现达到解释的效果

interface i1
{
void interpret(stringbulider sb);
}

wordexpression : i1
{
string test;
wordexpression(string s)
{
test = s;
}
void interpret(stringbulider sb)
{
sb.append(dic["test"]);
//todo
}
}
emojiexpression : i1
{
void interpret(stringbulider sb)
{
//todo
}
}
//
}

迭代器模式
{
利用迭代的思想，将对象遍历的方法封装起来，简化外部调用

iterator t1
{
bool movenext();

object getcurrent();

void next();

void reset();
}
}

中介者模式
{
中介类实现接口，根据传入的对象调用接口的方法，进行不同的逻辑

class house{}

class renter :house{}

class landlord : house{}

class mediator
{
void method(house h);
}

class currentmediator : mediator
{
void method(house h)
{
swtich(h)//判断对象是否为其中一个，则执行其逻辑
{
case renter:
//todo
break;

case landlord:
//todo
break;
}
}
}
}

备忘录模式
{
将对象的重要信息存入用于备份的对象中，需要时就可以拿出来，将对象还原

class originate
{
int state；

memento getmemento（）//备份
{
return new memento（state）；
}
}
class memento //备份类
{
int state；
memento （int value）
{
state = value；
}
}
}

观察者模式
{
将要观察的对象一个个收入容器中管理，当外部发生变化时通知所有被观察的对象

class baseclass
{
list<iobserver> servers;

void method()
{
servers.foreach(p=>p.update(this));
}
}
interface iobserver
{
void update(baseclass);
}
}

策略模式
{
策略模式其实就是对接口的一系列实现，然后根据需要将接口实例化想要的对象，调用入边的方法

interface i1
{
void method();
}
public class c1 :i1
{
void method()
{
debug.log("1");
}
}
public class c2 : i1
{
void method()
{
debug.log("2");
}
}
class user
{
i1 = new c1();

void method()
{
i1.method();
}
}
}

状态模式
{
将对象的调用和状态分离开，实现逻辑间的解耦

interface state
{
void method(light l);
}
class turnoff : state
{
void method(light l)
{
l.s = new turnon();
}
}
class turnon : state
{
void method(light l)
{
l.s = new turnoff();
}
}
class light
{
state s;

void ChangeState()
{
s.method(this);
}
}
}

模板模式
{
模板模式只是利用继承，将重要的逻辑存入基类中，在需要拓展的地方发放一个钩子方法，子类重写钩子方法则可从外部实现功能

abstract class c1
{
void method()
{
test1();
test2();
}
void test1()
{
//todo
}
abstract void test2();//重要方法写成纯虚函数
}
class c2 : c1 
{
override void test2()
{
//todo
}
}
}

访问者模式
{
访问者模式就是类中留出一个处理不同访问者的逻辑方法，外部传入访问者对象，执行相应的逻辑

class c1
{
void method(ivisit v1)
{
//todo
}
}
class c2
{
void method(ivisit v1)//不同类中留出访问的方法，外部只需要传入访问者就可以执行相应逻辑
{
//todo
}
}
}