三十一.设计模式总结-创建型模式

设计模式总结

依赖倒转原则：抽象不应该依赖细节，细节应该依赖于抽象

单一职责：

开放封闭原则：

里氏代换：

合成聚合复用：

迪米特：

一．创建型模式

1，简单工厂，工厂，抽象工厂            区别

简单工厂：工厂根据传入的字段，在switch里判断并返回一个相应的实例。

        优点：将判断选择放入工厂中，客户端不必判断

        缺点：不符合开放-封闭原则的精神

        总结：操作方法稳定时，要除去客户端依赖时使用

可以结合反射使用，或者结合策略模式使用

Class Factory

{

        Public static 基类 Set子类（string str）

        {     基类 f=null;

               Switch(str)

               {case “” f=new 子类1（）；break;

……}

               Return f;

}

}

       工厂模式：每一种操作类，就有一个继承工厂接口的类，返回相应的操作。

              优点：没有判断语句，符合开放-封闭原则

              缺点：客户端必须实例化相应的操作工厂，增加了依赖

              总结：有与客户端的依赖，但子类个数不稳定时使用

              InterfaceIFactory(){基类 create子类（）；}

              Class子类1Factory:IFactory

              {

              Public基类 create子类（）{return new 子类1（）；}

}

Class 子类1Factory:IFactory

              {

              Public基类 create子类（）{return new 子类1（）；}

}

       抽象工厂：原型于工厂模式，但是他能提供一组相应的操作类

              优点：同工厂模式，但能提供一组相应的类。

              缺点：工厂部分更加复杂，变动更加困难

              总结：利用工厂模式，提供一组组相应的类，无需指定他们具体的类。

                       常用于数据库更换等类似的场景。

可以结合简单工厂改进抽象工厂，将判断工厂类型放到switch中

              interface  IFactory//抽象工厂接口，包含所有产品创建的抽象方法

           {

       IUser CreateUser();

       IAdmin CreateAdmin();

           }

           class SqlServerFactory : IFactory//具体工厂

           {

              public IUserCreateUser(){return new SqlServerUser();}

       public IAdmin CreateAdmin(){return new SqlServerAdmin();}

           }

           class AccessFactory : IFactory

           {

       public IUser CreateUser(){return new AccessUser();}

       public IAdmin CreateAdmin(){return new AccessAdmin();}

           }

2，单例模式

保证一个类仅有一个实例，并提供一个访问它的全局访问点，类自身负责保证保存它的唯一实例。

优点：保证只有一个实例，保证数据一直和减少空间占用

缺点：在多线程中应用时要注意

总结：私有化构造函数，使其只能自身实例化，保证唯一性

Class child

{

private static child c;

       private child() { }

       public static child GetChild()

       {

           if (c == null) {c = new child();}

           return c;

       }

}

多线程下：加锁或双重锁

private static readonly object syncRoot = new object();//锁

public staticchild GetChild()

{     //if(c==null){双重锁

       Lock(syncRoot){

           if (c == null) {c = new child();}

           return c;

              }

    }

       或公共静态类(不推荐)

       Sealed class child//密封的

{ private static readonly child c=new child();//第一次引用类的任何成员时创建实例。

公共语言运行库负责处理变量初始化

       private child() { }

       public static child GetChild()

       {

           returnc;

       }

3，建造者模式

       将一个复杂对象的构建与它的表示分离，算法独立于组成及装配方式

       优点：由指挥类调用传入的建造者类的相关方法。高内聚内部建造过程

       总结：用于创建一些复杂的对像，内部创建顺序稳定但复杂变化的。

       classDirector//控制类

    {

       private F f;

       public Director(F f)

       {this.f = f; }

       public void createF()

       {f.f1();f.f2();f.f3();}

    }

   abstract class F//建造者抽象类

    {

       public abstract void f1();

       public abstract void f2();

       public abstract void f3();

    }

4，原型模式

       用原型实例指定创建对象的种类，并通过拷贝这些原型创建新的对象

       优点：在A a=new A();A b=a;是传引用而不是传值引用。原型模式可以克服这一问题。

       缺点：拷贝，深拷贝，拷贝程度非常麻烦

       总结：实现浅克隆，复制值类型，复制引用，但不复制引用对象。使用时要注意。

              publicoverride Prototype Clone()

       {

           return (Prototype)this.MemberwiseClone();

       }

       使用：

       ConcretePrototypelp1 = new ConcretePrototypel("i");

   ConcretePrototypel c1 = (ConcretePrototypel)p1.Clone();