C#学习笔记④——.NET的OOP技术相关

11..Net面向对象编程
a.面向对象的含义：1）.字段和属性
                  字段：类中的变量（类内部用的存储数据）
                  属性：类提供给外部调用的类存储的数据 可以使用 对象.属性 设置或读取 一个值
                         get{reture xxx;}表示可读
                         set{xxx = value;}表示可写
                  2）.析构函数
                  .Net Framework使用析构函数清理对象
                  使用~前缀的类名（与构造函数的相同）来声明
                  public class MyClass
                  {
                      ~MyClass()
                      {
                          //函数体
                      }
                  }
                  3）.静态static 
                  静态构造函数：不能有访问修饰符，不能带任何参数静态构造函数不能直接调用，只能在
                            以下情况调用：
                            创建包含静态构造函数的类实例时
                            访问包含静态构造函数的类的静态成员时
                  静态类：只包含静态成员，不能实例化对象，不能有实例构造函数，可以有静态构造函数
b.OOP技术：1）.类可密封（seal）,密封的类不能用作基类
           2）.接口可以继承其他接口，与类不同的是，接口可继承多个基接口
           3）.接口的多态性：接口不能像类那样实例化对象，但可以建立接口类型的变量然后可以在支持
           该接口的对象上，使用该对象访问接口提供的方法和属性
           4）.对象间的关系：
           包含关系：一个类包含另一个类。
                     用一个成员字段包含对象实例，该实例可以是公共字段，
           集合关系：一个类用作另一个类多个实例的容器。集合包括索引、排序和重置大小等功能
                     通常有一个Item属性，它根据对象的索引返回该对象
                    Animal[] animals = new Animal[5];

12.C#中的类定义
a.访问修饰符：无或internal                  只能在当前项目中访问类
              public                        可以在任何地方访问类
              abstract或internal abstract   类只能在当前项目中访问，不能实例化，只能继承
              public abstract               类可以在任何地方访问，不能实例化，只能继承
              sealed或internal sealed       类只能在当前项目中访问，不能派生，只能实例化
              public sealed                 类可以在任何地方访问，不能派生，只能实例化
b.类、接口：类继承：
              public class MyClass : MyBase
              {
                  //类成员
              }
            接口的实现：
              public  class MyClass : IMyInterface , IMySecondInterface
              {
                  //类成员
              }
      不能在接口中使用关键字abstract和sealed，因为这两个修饰符在接口定义中  是没有意义的
      （他们不包含实现代码，所以不能直接实例化，且必须是可以继承的）
      接口没有继承System.Object.可以使用接口类型的变量来访问System.Object的成员
c.构造函数的执行循序：
              public class MyBaseClass
              {
                  public MyBaseClass()
                  {}
                  public MyBaseClass(int i)
                  {}
              }

              public class MyDerivedClass : MyBaseClass
              {
                  public MyDerivedClass()
                  {}
                  public MyDerivedClass(int i)
                  {}
                  public MyDerivedClass(int i, int j)
                  {}
              }
             MyDerivedClass类实例化构造函数执行循序：
             System.Object.Object()构造函数
             MyBaseClass.MyBaseClass()构造函数
             MyDerivedClass.MyDerivedClass()构造函数

             public class MyDerivedClass : MyBaseClass
              {
                  ...

                  public MyDerivedClass(int i, int j) : base(i)
                  {}
              }
             base关键字指定.NET实例化过程使用基类中有指定参数的构造函数
             也可使用该关键字指定基类构造函数的字面值
              public class MyDerivedClass : MyBaseClass
              {
                  public MyDerivedClass() : base(5)
                  {}
                  ...
              }
             
             this关键字，指定在调用指定的构造函数前，对当前类实例化使用非默认的构造函数
             public class MyDerivedClass : MyBaseClass
              {
                  public MyDerivedClass() : this(5, 6)
                  {}

                  ...

                  public MyDerivedClass(int i, int j) : base(i)
                  {}
              }
              构造函数执行序列：
              System.Object.Object()构造函数
              MyBaseClass.MyBaseClass(int i)构造函数
              MyDerivedClass.MyDerivedClass(int i, int j)构造函数
              MyDerivedClass.MyDerivedClass()构造函数

d.结构和类
      结构和类非常相似，但结构是值类型，类是引用类型
      namespace Test
      {
          class MyClass
          {
              public int val;
          }
          struct myStruct
          {
              public int val;
          }
          class Program
          {
              MyClass objectA = new MyClass();
              MyClass objectB = objectA;
              objectA.val = 10;
              objectB.val = 20;
              myStruct structA = new myStruct();
              myStruct structB = structA;
              structA.val = 30;
              structB.val = 40;
              Console.WriteLine("objectA.val = {0}", objectA.val);
              Console.WriteLine("objectB.val = {0}", objectB.val);
              Console.WriteLine("structA.val = {0}", structA.val);
              Console.WriteLine("structB.val = {0}", structB.val);
              Console.ReadKey();
          }
      }
    结果：objectA.val = 20， objectB.val = 20， structA.val = 30， structB.val = 40
e.浅度复制和深度复制
         利用受保护的方法System.Object.MemberwiseClone()可以进行浅度复制，也就是说对于含有引用类型字段
         的对象来说，进行浅度复制意味着复制的对象和源对象存在这相同的引用。如果源对象的引用变量的值发生改变，
         那么被复制的对象的成员值也会发生变化。
         有很多适合这都不是我们希望看到的结果， 所以有必要对对象进行深度复制，这可以通过ICloneable接口
         的Clone方法实现，它通过创建新对象的方法进行深度复制。在比较复杂的对象系统调用Clone()是一个递归
         的过程，这次复制的对象和源对象是独立的。

         浅度复制对引用类型只复制引用，及复制后源引用与目标引用的引用类型是指向都一个对象，操作其中一个，
         另外一个也会受影响；深度复制则源引用和目标引用对 象的是两个不同的对象，操作互不影响；浅度复制是
         直接完全把栈的内容拷贝一份而已，而深度复制把对应的堆内容也拷贝了一份；浅度复制可以直接
         调用 System.Object.MemberwiseClone()这个受保护的方法就可以了；而深度引用根据C＃的规范实现ICloneable
         接口即可。

         首先给出第一个使用System.Object.MemberwiseClone()实现浅度复制的实例，在Cloner中，
         我们只定义了值类型的成员变量Val：
         public class Cloner {
             public int Val;
             public Cloner(int newVal) {
                 Val = newVal;
             }
     
             public object GetCopy() {
                 return MemberwiseClone();
             }
         }
         然后添加测试代码如下：
         static void Main() {
            Cloner mySource = new Cloner(5);
            Cloner myTarget = (Cloner)mySource.GetCopy();
            Console.WriteLine("mySource.Val = {0}", mySource.Val);
            Console.WriteLine("myTarget.Val = {0}", myTarget.Val);
            mySource.Val = 2;
            Console.WriteLine("mySource.Val = {0}", mySource.Val);
            Console.WriteLine("myTarget.Val = {0}", myTarget.Val);
            Console.ReadKey();
        }
        程序的输出结果如下：mySource.Val = 5
                            myTarget.Val = 5
                            mySource.Val = 2
                            myTarget.Val = 5
        我们发现，这种简单的值类型域的复制，即使改变源对象的值也不会影响复制对象的值，也就是说我们创建了
        一个新的对象实例，下面我们在来看一个包含引用类型的实例，实例代码和测试代码如下：
        using System;
        using System.Collections.Generic;
        using System.Linq;
        using System.Windows.Forms;
         
        namespace Test5 {
            static class Program {
                public class Content {
                    public int Val;
                }
         
                public class Cloner {
                    public Content MyContent = new Content();
                    public Cloner(int newVal) {
                        MyContent.Val = newVal;
                    }
         
                    public object GetCopy() {
                        return MemberwiseClone();
                    }
                }
                /// <summary>
                /// 应用程序的主入口点。
                /// </summary>
                [STAThread]
                static void Main() {
                    Cloner mySource = new Cloner(5);
                    Cloner myTarget = (Cloner)mySource.GetCopy();
                    Console.WriteLine("mySource.MyContent.Val = {0}", mySource.MyContent.Val);
                    Console.WriteLine("myTarget.MyContent.Val = {0}", myTarget.MyContent.Val);
                    mySource.MyContent.Val = 2;
                    Console.WriteLine("mySource.MyContent.Val = {0}", mySource.MyContent.Val);
                    Console.WriteLine("myTarget.MyContent.Val = {0}", myTarget.MyContent.Val);
                    Console.ReadKey();
                }
            }
        }
        程序的执行结果如下：mySource.Val = 5
                            myTarget.Val = 5
                            mySource.Val = 2
                            myTarget.Val = 2
        从结果中你可以发现，当改变源对象mySource.MyContent.Val的引用类型域的值后通过阴影复制得到的对象
        myTarget的引用类型域的值同时发生了 改变。这是因为使用MemberwiseClone()只能实现浅度复制，
        mySource.MyContent引用了与myTarget.MyContent相同的对象实例。为了实现彻底复制，即复制对象与源对
        象相互独立、互不影响，需要执行深度复制。修改上面的 GetCopy()方法也可以进行深度复制，但最好使
        用.NET Framework的标准方式。为此，实现ICloneable接口，该接口有一个方法Clone()，这个方法不带参数，
        返回一个对象类型，其签名和上 面使用的GetCopy()方法相同。下面给出实际的源代码和测试代码：
        using System;
        using System.Collections.Generic;
        using System.Linq;
        using System.Windows.Forms;
         
        namespace Test5 {
            static class Program {
                public class Content {
                    public int Val;
                }
         
                public class Cloner : ICloneable {
                    public Content MyContent = new Content();
                    public Cloner(int newVal) {
                        MyContent.Val = newVal;
                    }
         
                    #region ICloneable 成员
         
                    public object Clone() {
                        Cloner clonedCloner = new Cloner(MyContent.Val);
                        return clonedCloner;
                    }
         
                    #endregion
                }
                /// <summary>
                /// 应用程序的主入口点。
                /// </summary>
                [STAThread]
                static void Main() {
                    Cloner mySource = new Cloner(5);
                    Cloner myTarget = (Cloner)mySource.Clone();
                    Console.WriteLine("mySource.MyContent.Val = {0}", mySource.MyContent.Val);
                    Console.WriteLine("myTarget.MyContent.Val = {0}", myTarget.MyContent.Val);
                    mySource.MyContent.Val = 2;
                    Console.WriteLine("mySource.MyContent.Val = {0}", mySource.MyContent.Val);
                    Console.WriteLine("myTarget.MyContent.Val = {0}", myTarget.MyContent.Val);
                    Console.ReadKey();
                }
            }
        }
        程序的运行结果如下：mySource.Val = 5
                            myTarget.Val = 5
                            mySource.Val = 2
                            myTarget.Val = 5
        从结果你可以看出，通过深度复制，两个对象已经没有任何关系了，对第一个对象的改变没有影响到第二个
        对象。这里使用的是包含在源Cloner对象(MyContent)中的Content对象的Val字段去创建一个新的Cloner对象。
        这个域是一个值类型所以不需要进行深度复制。通过ICloneable.Clone方法实现除MemberwiseClone所提供
        的克隆之外的克隆。