模式学习笔记一(创建型模式一)

 一 为什么需要创建型模式
             创建型模式可以让系统将对象的创建和组合与对象的表示分隔开来,用户依赖于接口,而不是实际的对象,从而降低了系统的偶合度,增加了系统的可扩展性和稳定性.

二  对基本的几种创建型模式的学习和理解
         
        2.1 Abstract Factory (抽象工厂模式)
               Abstract Factory Pattern  的主要的功能是提供了一个创建一个系列的,需要组合或者是协同工作的产品的接口.
               
              抽象模式适合使用的条件
              在系统中有多系列相关产品,(举例 : 在系统中不同风格的控件 ---最通常的例子)
              在每次系统调用时,系统选择这些系列中的一种,而不是各种系列混合使用的情况
              

           具体的实现的代码事例(C#)
           

客户依赖的部分#region  客户依赖的部分
           pulic abstract  class abstractProductA
              {
                     public string Name
                     {get;set;}
                     public void printName()
                        {-----}
                     public virtual void ActionA(){};
                  // the contain Attributes And Functions In AbstractProductA
             }
             pulic abstract  class  abstractProductB
              {
                     public string Name
                     {get;set;}

                     public void printName()
                        {-----}
                      public virtual void ActionB(){};
                  // the contain Attributes And Functions In AbstractProductB
             }


             public abstract class  abstractFactory
            {
                  
               public abstract abstractProductA CreateProductA();
               public abstract abstractProductB   CreateProductB();
                  
           }
           
           #endregion

 

实际用户使用的产品对象#region 实际用户使用的产品对象

            internal class SysProductA:abstractProductA
            {
                     internal override void ActionA()
                     {}
            }

            internal class SysProductB:abstractProductB
            {
                     internal override void ActionB()
                     {}
            }

            internal  class SysFactory:abstractFactory
            {
                   internal override abstractProductA CreateProductA()
                              {
                                       return  new SysProductA();
                               }

                   internal override abstractProductB CreateProductB()
                              {
                                       return  new SysProductB();
                               }
            }
#endregion

                 2.1.1 Abstract Factory pattern 扩展
                 在Abstract Factory Pattern 模式中 ,我们往往会发现对于Factory 类来将在一个系统中往往只需要使用一个实例就可以拉
        这样我们可以将 Singleton和Factory 类组合在一起使用





 2.2   Singleton (单一模式)
              Singleton Pattern  保证在整个系统中单个类只有一个实例,并且还提供了一个公共的接口供用户调用.
             
              单一模式使用的条件.
               类在系统中运行时,只需要一个实例.
               其次类可能需要通过类的继承来扩展.
               
               在实现单一模式的时候,如果我们不需要扩展的情况下我们是可以通过类的静态的方法和属性来对单一的条件进行实现.
         但是 这样的话 我们会对实现单一模式的类实行强偶合,在需要对类进行扩展的时候,就可能会改动客户调用并且使用的那
         部分代码,因为静态的属性和方法是不能被继承的.    
              在通过对对象实现的方式下面 ,我们可以扩展类的功能,并且在不改动原有的客户代码的基础之上. 
             这就是用 类的实例和类的静态方式实现单一的不同点 

             单一模式的代码实现
                
             public class  SingleClass
             {

                  private SingleClass()
                     {}
                  private static _Instance=null;

                  public static SingleClass Current
                  {
                           get{ 
                                 if (_Instance==null)
                                 _Instance=new SingleClass();
                                return _Instance
                              }
                  }
             }



            对于类的扩展可以通过传参数的方式来选择继承的子类,并初试化相对应的子类的实例
            也可以选择和原型类似的方式来实现．
  
 2.3   ProtoType (原型模式)
         ProtoType Pattern 是用已经生成的对象事例来代表需要生成的对象,并在通过对原型的实例的Clone来生成新的对象
        
        ProtoType Pattern的使用的条件
       1 . 在系统中需要大量生成初始化信息有限的对象
       2.  需要生成的对象需要在运行时动态的改变(接口不变,实际运行的对象发生改变)
       
      下面的例子就是用原型模式生成砖头和瓦片

/**//// <summary>
    /// Class1 的摘要说明。
    /// </summary>
    class Client
    {
        /**//// <summary>
        /// 应用程序的主入口点。
        /// </summary>
        [STAThread]
        static void Main(string[] args)
        {
         brick newbrick=StuffFactory.Instance.CreateBrick();
         newbrick.Show();

        }
    }

    the public interfaces#region the public interfaces 
    /**//// <summary>
    /// the interface of brick
    /// </summary>
    public abstract class brick
    {        
        protected string _color=string.Empty ;
        protected double _length=25.4d;
        /**//// <summary>
        /// The Brick's Color 
        /// </summary>
        public string color
        {
            get{return this._color ;}
        }

        /**//// <summary>
        /// The Brick's Length
        /// </summary>
        public double Length
        {
            get{return this._length ;}
        }

        /**//// <summary>
        ///Show the Brick's  Style 
        /// </summary>
        public abstract void Show();

        /**//// <summary>
        /// the way of Clone
        /// </summary>
        /// <returns> the new object of brick</returns>
        internal abstract  brick Clone();
    }
    
    /**//// <summary>
    /// the interface of tile
    /// </summary>
    public abstract class tile
    {
        protected string _color=string.Empty ;
        protected double _height=25.4d;
        /**//// <summary>
        /// The tile's Color 
        /// </summary>
        public string color
        {
            get{return this._color ;}
        }

        /**//// <summary>
        /// The tile's Height
        /// </summary>
        public double Height
        {
            get{
                return this._height ;}
        }

        /**//// <summary>
        ///Show the tile's  Style 
        /// </summary>
        public abstract void Show();

        /**//// <summary>
        /// the abstract way of Clone
        /// </summary>
        /// <returns> the new object of tile</returns>
        internal abstract  tile Clone();

    }


    /**//// <summary>
    /// the factory which to created the Brick And 
    /// </summary>
    public class StuffFactory
    {
        private brick _InstanceBrick=new BrickClass();
        private tile  _InstanceTile=new TileClass();
        private static StuffFactory _InstanceSelf=null;
        
        private StuffFactory()
        {
        }
        
        public static StuffFactory Instance
        {
            get{
                if (StuffFactory._InstanceSelf==null)
                _InstanceSelf=new StuffFactory();
                return _InstanceSelf;}
        }
        
        /**//// <summary>
        /// the way which Create the Brick;
        /// </summary>
        /// <returns></returns>
        public brick CreateBrick()
        {
            return _InstanceBrick.Clone();
        }

        /**//// <summary>
        /// THe Way Which  Create the tile
        /// </summary>
        /// <returns></returns>
        public tile CreateTile()
        {
            return this._InstanceTile.Clone();
        }
    
    }

    #endregion

    The True Active Classes#region The True Active Classes

    /**//// <summary>
    /// The True Active Object
    /// </summary>
    internal class BrickClass :brick
    {
        
        public  override void Show()
        {
            //Active To Show Brick
        }

        internal override brick Clone()
        {
            BrickClass newBrick =new BrickClass();
            this._length  =24.5d;
            this._color ="Blue";
            return new  BrickClass();
        }
    }
 
    /**//// <summary>
    /// the True Active Object
    /// </summary>
    internal class TileClass:tile
    {
        internal override tile Clone()
        {
            TileClass newTile=new TileClass();
            this._color ="Yello";
            this._height =25.4d;
            return newTile;
        }
        public override void Show()
        {
            // Active To Display the Tile
        }


    
    }
    
    #endregion

  2.4  Builder  (生成器模式)
         Builder  Pattern  主要是将复杂的对象和生成的流程分割开来 ,这样的话,可以使用同一样的生成流程来生成复杂的对象.

        Builder Pattern 的使用的条件
       需要建立的对象的结构是复杂的 ,里面的内容是动态生成的,需要生成器模式
      举例  创建学校 这个对象 我们需要添加 老师和学生的信息,  而老师和学生的信息是动态的,不确定的,我们可以 用生成器模式来解决这个问题 
      例子代码   

    /**//// <summary>
    /// the class odf builder 
    /// </summary>
    public class Builder
    {
        private School _Instance = null;
        
        public Builder()
        {
    
        }

        /**//// <summary>
        /// begin to create the school object
        /// </summary>
        public void  CreateOneSchool()
        {
            this._Instance =new School();
        }


        /**//// <summary>
        /// Add one student into School
        /// </summary>
        /// <param name="std"></param>
        public void AddStudent(student std)
        {
            this._Instance.AddStudent(std);
        }

        /**//// <summary>
        /// Add one teacher into shco;
        /// </summary>
        /// <param name="tea"></param>
        public void AddTeacher(Teacher tea)
        {
            this._Instance.AddTeacher(tea);

        }

        /**//// <summary>
        /// return School and clear the object in the Builder
        /// </summary>
        /// <returns></returns>
        public School GetSchool()
        {
            School returnSchool =this._Instance;
            this._Instance =null;
            return returnSchool;
        }
    }


    /**//// <summary>
    /// the class of Shcool
    /// </summary>
    public class School
    {
        internal ArrayList _students = new ArrayList();
        internal ArrayList _Teachers =new ArrayList();
        
        /**//// <summary>
        /// Add the Student in the param
        /// </summary>
        /// <param name="std">the param which need to added</param>
        internal void AddStudent(student std)
        {
            this._students.Add(std);
        }

        /**//// <summary>
        /// Add the Teacher in the param 
        /// </summary>
        /// <param name="tea"> the param which need to added</param>
        internal void AddTeacher(Teacher tea)
        {
            this._Teachers.Add(tea);

        }
        
        /**//// <summary>
        /// get the student by index
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public student GetStudent(int index)
        {
            return (student)this._students[index];
        
        }

        /**//// <summary>
        /// get Teacher by Index
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public Teacher GetTeacher(int index)
        {
        
            return (Teacher) this._Teachers[index];
        }
    }

    /**//// <summary>
    /// the class of student
    /// </summary>
    public class student
    {
        private string _Name=string.Empty ;
        internal student(string Name)    
        {
            _Name=Name;
        }

        public string Name
        {
            get{return this._Name ;}
        }
    }

    /**//// <summary>
    /// the class of Teacher
    /// </summary>
    public class Teacher
    {
        private string _Name=string.Empty ;
        internal Teacher(string Name)    
        {
            _Name=Name;
        }

        public string Name
        {
            get{return this._Name ;}
        }

    }