简单工厂模式：
原来是，
function A(){console.log("A")}
function B(){console.log("B")}
function C(){console.log("C")}
现在是，
var a=factory("A");
a();输出A
var b=factory("B");
b();输出B
策略模式：
原来是，
function A(){console.log("A")}
function B(){console.log("B")}
function C(){console.log("C")}
要想输出A,就A()，输出B，C类似。
现在是，
function context(){}
context(A);context();输出A
context(B);context();输出B
context(C);context();输出C
开发-封闭原则
就是函数的扩展是开发的，对函数的修改是封闭的。
需求一定会变化，但我们不能预测其变化。所以等到变化一发生我们就采取行动。对那个变化进行抽象。举个例子，本来是叫你写个加法程序，你写了个类实现加法功能。后来要你加个减法功能，你重构这个类，增加一个抽象的运算类，加法类继承运算类，减法类也继承运算类。以后相似的除法，乘法都继承这个类，而不用修改原先的类。
依赖倒转原则
高阶函数不依赖低阶函数，高阶函数和低阶函数都依赖于中间的接口 。
装饰模式：
原来是
function A(){}
function B(){}
function C(){}
C(B(A("abc")));
现在是，
C.setComponet(B);
B.setComponet(A);
C("abc");
职责链模式：
原来是，
function A(){}
function B(){}
function C(){}
C(B(A("abc")));
现在是，
A.setSuccessor(B);
B.setSuccessor(C);
A("abc");
代理模式：
原来是，
function A(){console.log("A")}
A();
现在是，
function proxy(){}
proxy()就输出字符串A。
这个与原来的区别是，proxy这个函数包含了对A函数的处理，也就是说可以对A函数进行更多的处理。
工厂方法模式：
原来是，
var a=factory("A");
a();输出A
var b=factory("B");
b();输出B
现在是，
var factory = IFactory();
var myFunction_a = factory.create_a();
myFunction_a();输出字符串A。
区别是，
简单工程根据传入的参数，来返回不同的方法；工厂方法则是不用参数，用自己的不同成员，来返回不同的方法。
原型模式：
原来是，
var a = new function_object();
var b = new fanction_object();
现在是，
var a = new function_object();
var b = a.Clone();
区别是，
少了初始化开销。还涉及到值复制，引用复制问题。光复制引用有时不合需求，所以出现把引用的对象也复制过来。
模板方法模式：
原来是，
{
public void TestQuestion1()
{
Console.WriteLine(" 杨过得到，后来给了郭靖，炼成倚天剑、屠龙刀的玄铁可能是[ ] a.球磨铸铁 b.马口铁 c.高速合金钢 d.碳素纤维 ");
Console.WriteLine("答案：" + Answer1());
}
public void TestQuestion2()
{
Console.WriteLine(" 杨过、程英、陆无双铲除了情花，造成[ ] a.使这种植物不再害人 b.使一种珍稀物种灭绝 c.破坏了那个生物圈的生态平衡 d.造成该地区沙漠化 ");
Console.WriteLine("答案：" + Answer2());
}
public void TestQuestion3()
{
Console.WriteLine(" 蓝凤凰的致使华山师徒、桃谷六仙呕吐不止,如果你是大夫,会给他们开什么药[ ] a.阿司匹林 b.牛黄解毒片 c.氟哌酸 d.让他们喝大量的生牛奶 e.以上全不对 ");
Console.WriteLine("答案：" + Answer3());
}
protected virtual string Answer1()
{
return "";
}
protected virtual string Answer2()
{
return "";
}
protected virtual string Answer3()
{
return "";
}
}
//学生甲抄的试卷
class TestPaperA : TestPaper
{
protected override string Answer1()
{
return "b";
}
protected override string Answer2()
{
return "c";
}
protected override string Answer3()
{
return "a";
}
}
//学生乙抄的试卷
class TestPaperB : TestPaper
{
protected override string Answer1()
{
return "c";
}
protected override string Answer2()
{
return "a";
}
protected override string Answer3()
{
return "a";
}
}
外观模式：
原来是，
a();
b();
c();
现在是，
function facade(){
a();
b();
c()
}
facade();
建造者模式：
原来是，
var thin = draw();
thin.a1();
thin.a2();
thin.a3();
现在是，
var thin = draw("thin");
区别是，
a1,a2,a3这个执行顺序是固定，但a1,a2,a3里面的执行内容时刻在变。
观察者模式：
通知者类，观察者类，
通知者s.添加观察者(生成一个观察者(s,"X"));
通知者s.添加观察者(生成一个观察者(s,"Y"));
通知者s.通知内容 = "ABC";
通知者s.通知();
执行结果就是，
观察者x的新状态是abc
观察者y的新状态是abc