一：类
 
   1. 类的定义：
          类是对一组具有相同属性和行为的对象的抽象；
   2. 类的构成：
         1) 声明类：类的默认修饰符为internal
                  public/internal  clss 类名
    {
    }

2) 构造函数：
               带参数的构造函数：
               私有构造函数：
               静态构造函数；
                   用于初始化任何静态数据，或用于执行仅需执行一次的特定操作。在创建第一个实例或引用任何静态成员之前，将自动调                   用静态构造函数。

class Chen
                   {
                      static Chen()   --------->1.没有修饰符，没有参数
                       {                         2.创建实例或引用静态成员之前，自动调用
                       }                         3.无法直接调用
                      Chen()
                      {
                      }
                   }

3) 析构函数：

4) 构建成员：
                  成员变量：
                  方法：
                  事件：
                  委托：
                  索引器：
                  其他类：

二：接口：
      interface IChen
      {
         print();
      }
      class A : IChen
      {
         print方法实现；
      }
      class B： IChen
      {
         print方法实现；
      }
      在Main窗体中，点击不同按钮，要调用不同类的print方法；
      创建接口变量：IChen Iprint；
      if(btn1)
      {
          Iprint = objA；  //如果是这样，将该接口变量指向该对象实例
      }
      else if (btn2)
      {
          Iprint = objB；    //如果是这样，将该接口变量指向该对象实例
      }
      Main窗体中的print方法：
      if(this.Iprint!=null)
      {
  this.Iprint.print();   //调用接口的方法 ,  因为此时该接口变量已经动态指向了不同的对象
      }

三：类和接口：

接口                                                                   类
 
 1.接口本身：不能直接实例化（引用实现该接口的类的对象）                         直接实例化
             多继承，一个接口可以继承自多个接口                                 单继承，一个类只可以继承自一个基类
             不提供实现 它有类来实现                                            实现类要实现接口的每个方面
 2.接口成员：可以包括方法 事件 索引器 属性                                      同
             接口成员要全部是公共访问级别                                       多种访问级别
             不能在后续版本中添加新成员

接口和抽象类的选择：
   同：
      都支持协定和实现的分离；都是实现抽象机制的方法；
      不能进行实例化
   异：
      接口不能提供成员的实现细节；抽象类可以；
      接口不能在后续添加新成员；抽象类可以添加新成员实现更多功能；

如何选择：
   1) 优先选择抽象类，因为它可以在后续添加新成员可；
   2) 如果类要实现多个协定 也就是多继承，定义接口；
   3) 值类型要求多态行为，定义接口；
   4) 协定适合于多种类型，定义接口；

四：类型设计：
   1. 类
       1) 抽象类：
            不要在抽象类中定义公共的public 和受保护的内部protected internal构造函数；应定义成protected或private；
       2) 静态类：
       4) 抽象类和接口：如上
       5) 类和结构：如下

2. 结构
        设计准则：逻辑上表示单个值；实例大小小于16字节；不可变；不别频繁装箱；
   3. 接口
          避免定义空接口（标记接口）
   4. 枚举
  
   5. 委托：

委托是一种对象类型，表示对方法的引用而不是对方法名称的引用。使用委托的意义在于在运行时动态的调用方法；
调用或执行一个委托，将执行该委托所引用的方法；
委托要求它所引用的方法和它有同样的返回值和参数类型；

public class MyDelegate
{

// 1.定义委托
public delegate int Call(int num1,int num2);

class Math
{
   // 2. 方法的实现，它和所定义的委托有同样的返回值，以及相同类型的参数
   public int add(int a1,int a2)
   {
      return a1+a2;
   }

public int divide(int b1,int b2)
   {
      return b1-b2;
   }
}

class TestDelegate
{
   static void Main()
   {
      int result;

Call objCall;  3. //定义一个委托类型的空对象
      Math objMath= new Math();
    
      objCall = new Call(objMath.add);  //4. 实例化该委托对象 使其引用某个具体的方法，将方法做为参数传递；

result=objCall(10,20);  //5.调用委托，实际上是使用委托对方法进行实例化，
                              //这里不是调用委托的实现，因为他没有实现，调用的是与委托关联的方法的实现；

Console.WriteLine("the result is :",result);

}
}

}

5. 嵌套类型：
         嵌套类型可以访问声明类型中的所有其他成员

封装：
      封装最大的益处就是，当一个实体放生变动，不波及其他实体；
     
继承：

方法重写：

base 关键字：
   用于从子类中访问基类成员； 如java中的super
   使用base关键字只能访问基类的构造函数 实例方法或实例属性 ，不能访问基类的静态方法。

override 关键字：
    用于重写基类中的virtual abstract 方法；但重写的方法和基类中的方法有同样的访问级别

new关键字：
   用于隐藏基类方法；
   1.  使用 new 关键字时，调用的是新的类成员而不是已被替换的基类成员。这些基类成员称为隐藏成员。
   2.  如果将派生类的实例强制转换为基类的实例，就仍然可以调用隐藏类成员

virtual关键字：
    将方法定义为多态，也就是对可修改的方法的声明；在子类中使用override关键字实现；

abstract关键字：
    将方法定义为抽象，由子类具体实现；

override 和 new 对方法的版本控制：
    当子类和基类具有相同的方法名称：

首先基类中的方法要有virtual关键字；

如果子类方法不带这两个方法：会默认添加new 子类对象调用的是基类的方法；
       如果子类方法带override：则子类对象调用该方法；
       如果子类方法带new：则会子类对象调用基类中的方法；
       如果子类方法中使用base：和使用new是同样效果；
         public void Fun()
        {
            base.Fun();
            //Console.WriteLine("这是子类B");
        }

多态：
     一个类可以用作多种类型：可以用作它自己的类型、任何基类型，或者在实现接口时用作任何接口类型。这称为多态性。C# 中的每种类型都是多态的.

方法重载：
        在同一类型中定义多个具有相同名称，不同参数列表(参数个数不同，参数的顺序不同),返回值可同可不同的方法；