设计模式复习、实践和总结（一）

最近投简历的时候发现有些公司要求会设计模式，当看到设计模式的时候，瞬间懵逼了，什么是设计模式？
当上网看了下设计模式的介绍时。。。发现自己竟然学过设计模式。。。偶尔也用过设计模式，现在重新复习和总结一下设计模式，以留备用。。。。。

[这里只是自己的理解和实践，具体的可以参考](http://www.cnblogs.com/zhili/category/496417.html)

设计模式主要分为三种类型：创建型、结构性和行为型。
1．创建型模式

对象的创建会消耗掉系统的很多资源，所以单独对对象的创建进行研究，从而能够高效地创建对象就是创建型模式要探讨的问题：

其中简单工厂模式不是GoF总结出来的23种设计模式之一。
单例模式（Singleton）；
简单工厂模式（Simple Factory）；
工厂方法模式（Factory Method）；
抽象工厂模式（Abstract Factory）；
创建者模式（Builder）；
原型模式（Prototype）；
2．结构型模式

如何设计对象的结构、继承和依赖关系会影响到后续程序的维护性、代码的健壮性、耦合性等：

外观模式（Facade）；
适配器模式（Adapter）；
代理模式（Proxy）；
装饰模式（Decorator）；
桥模式（Bridge）；
组合模式（Composite）；
享元模式（Flyweight）。
3．行为型模式

如果对象的行为设计的好，那么对象的行为就会更清晰，它们之间的协作效率就会提高：

模板方法模式（Template Method）；
观察者模式（Observer）；
状态模式（State）；
策略模式（Strategy）；
职责链模式（Chain of Responsibility）；
命令模式（Command）；
访问者模式（Visitor）；
调停者模式（Mediator）；
备忘录模式（Memento）；
迭代器模式（Iterator）；
解释器模式（Interpreter）。
一、单例模式

保证一个类只有一个实例：
（1）定义一个静态变量来保存类的实例
    private static Study instance;
（2）定义私有构造函数，使外界不能创建该类的实例
    private Study
    {
    }
（3）提供提供一个访问它的全局访问点
    public static Study GetInstance()
    {
        if(instance == null)
        {
            instance =new Study();
        }
        return instance;
    }
多线程只需再定义一个标识确保线程同步
    private static readonly object locker =new object();
在（3）中进行加锁操作 
    public static Study GetInstance()
    {
    //第一个线程运行到这里会对locker对象进行"加锁"
    //第二个线程运行到这里检测到locker为"加锁"状态
    //就会挂起等待第一个线程解锁
    //线程运行完就会对locker进行解锁
        if(instance == null)
        {
            lock（locker）
            {
                if(instance == null)
                {
                    instance =new Study();
                }
            }

        }
        return instance;
    }

二、简单工厂

定义一个工厂类，根据需要加工产品来决定建立各种类的实例
如建立一个学习计划工厂类，先建立各种学习的类如：java、c、c# 、c++ 等，然后再根据学生的选择具体建立各种类的实例。
public abstract class StudyPlan
{
    public abstract void Learn();
}
public class StudyJava:StudyPlan
{
    public override void Learn()
    {
        //学习Java目标
    }
}
public class StudyC:StudyPlan
{
    public override void Learn()
    {
        //学习C目标
    }
}

public class StudyFactory
{
    public  StudyPlan MakePlan(string type)
    {
        StudyPlan studyPlan =null;
        if(type =="java")
        {
            studyPlan = new StudyJava();
        }
        else if(type =="c")
        {
            studyPlan = new StudyC();
        }
        else if(...)
        {
            //....
        }
        return studyPlan;
    }
}
void main()
{
    //创建学习工厂、制定学习java的学习计划、开始学习
    StudyFactory s1 =new StudyFactory();
    StudyPlan plan =s1.MakePlan("Java");
    plan.Learn();
    //制定学习c的计划、开始学习
    StudyPlan plan2 =s1.MakePlan("C");
    plan2.Learn();
}
简单工厂，在工厂类中一次性将所有具体产品全部实现，通过用户选择进行该产品的实例化。

三、工厂方法

把具体产品（学习计划）的实现推迟到子类中
分别建立c、c++、c#、java等学习工厂，每个工厂实现具体的学习计划。
public abstract class StudyPlan
{
    public abstract void Learn();
}
public class StudyC:StudyPlan
{
    public override void Learn()
    {
        //学习C目标
    }
}
public abstract class StudyFactory
{
    public abstract StudyPlan MakeStudyPlan();
}
puvlic class StudyCFactory:StudyFactory
{
    public override StudyPlan MakeStudyPlan()
    {
        StudyPlan plan = new StudyC();
        return plan;
    }
}
void Main()
{
    //创建c 学习工厂、制定C学习计划、开始学习
    StudyCFactory s1 = new StudyCFactory();
    StudyPlan cPlan=s1.MakeStudyPlan();
    cPlan.Learn();
    //java类同c类，已省略
    //创建java学习工厂、制定java学习计划、开始学习
    StudyCFactory s2 = new StudyJavaFactory();
    StudyPlan javaPlan=s2.MakeStudyPlan();
    javaPlan.Learn();
}

四、抽象方法

像c、java的学习也包括新手入门、中级进阶等。这里就要制定不同的学习计划。
C工厂制定 C的新手入门、中级进阶计划，java工厂就要制作Java的新手入门、中级进阶计划。
public abstract class StudyFactory
{
    public abstract StudyPlan MakeEasyPlan();
    public abstract StudyPlan MakeMiddlePlan();
}
public class StudyCFactory :StudyFactory
{
    public override StudyPlan MakeEasyPlan()
    {
        StudyPlan  p1=new CEasyStudyplan();
        return  p1;
    }
    public override StudyPlan MakeMiddlePlan()
    {
        StudyPlan  p2=new CMiddleStudyplan();
        return  p2;
    }
}
public abstract class StudyPlan
{
    public abstract void Learn();
}
public class CEasyStudyplan :StudyPlan
{
    public override void Learn()
    {
        //学习简单C
    }
}
    public class CMiddleStudyplan:StudyPlan
{
    public override void Learn()
    {
        //学习中级C
    }
}

void main()
{
    StudyCFactory CStudy =new StudyCFactory();
    StudyPlan easyCPlan=CStudy.MakeEasyPlan();
    easyCPlan.learn();
    StudyPlan middleCPlan = CStudy.MakeMiddlePlan();
    middleCPlan.Learn();
    //java 的同理 这里就省略了。。。。
}