这是本文档旧的修订版！

# 概念

使用在类与方法上、使用占位符T 来代表某种类型，编译期间决定其具体类型

类名称后面加 <T> 代表该类就是泛型类、不一定是T <M> <Myt> ……

泛型在实例化时、或使用时占位符T会被特化成指定的类型

为什么要加<T> 变成泛型类？

<T>:是类型占位符、表示还没决定具体是什么类型、先把这个位置占了、

如下例子：

当不确定类里面 是int[]类型数组 或者string[]类型数组 疑惑别的数组

# 泛型类： ```

      class zhan<T>
      {   //看做栈内存空间
          private T[] zhan_Cpu = new T[300] ;
          //将数据存入栈的方法
          public void set(T valu , int index)
          {
              zhan_Cpu[index] = valu; //数据入栈
          }

          //将数据取出栈的方法
          public T get(int index)
          {
              return zhan_Cpu[index];//数据取出
          }
      }

使用： static void Main(string[] args) { 对泛型类zhan的特化、特化为int类型的类

          zhan<int> int_data = new zhan<int>();
          // 此时int_data对象 内的数组zhan_Cpu读写都是int类型

          zhan<string> str_data = new zhan<string>() ;
          // 此时str_data对象 内的数组zhan_Cpu读写都是string类型

          zhan<double> doub_data = new zhan<double>() ;
          // 此时doub_data对象 内的数组zhan_Cpu读写都是double类型

      }

```

# 泛型格式：

格式无返回值： ```

           void fangfa<T> ( T a  ,  T b)
          {

          }

```

格式有返回值： ```

      public  T fangfa1<T>(T a, T b)
      {
          return a + b; //报错运算符不能用于两个T类型的操作数
                        //编译器会在编译时会对参数ab校验是否正确、

          dynamic da = a; //dynamic将类型校验推延到运行时、
          dynamic db = b; //当运行时已经为T类型赋予了int或者double类型
          return da + db;
      }

```

dynamic 动态的[当运行时根据传过来的值确定其类型]

daɪˈnæ mɪk

# 多样化泛型

``` class Program {

  static void Main(string[] args)
  {   
    reyy<int, string, double> Fanxing = new reyy<int, string, double>();
    Fanxing.LeiXing_1[1] = 500;
    Fanxing.LeiXing_2[1] = "ABSD";
    Fanxing.LeiXing_3[1] = 63.588;

} }

      //多样化泛型类
      class reyy<T , U , F>
      {   
          public T[] LeiXing_1 = new T[300];
          public U[] LeiXing_2 = new U[300];
          public F[] LeiXing_3 = new F[300];
      }

```

# 泛型的继承-1普通类继承泛型

泛型可以被继承 例如：继承时特化泛型类型 ```

  class Program
  {
      static void Main(string[] args)
      {
          teacher Teacher = new teacher();//实例化老师对象
          Teacher.id = 550346;//老师作为人类的id
      }

  }
  class people<T>
  {
      //编号属性
      public T id { get; set; } 
  }
  class teacher : people<int> 
  //继承一个泛型父类、继承的同时特化泛型
  {
  }

```

# 泛型的继承-2泛型继承泛型

泛型继承泛型、当子类被实例化时特化的类型也会传导给父类 ```

  class Program
  {
      static void Main(string[] args)
      {
          teacher<int> Teacher = new teacher<int>();//实例化老师对象
                                                    //把子类特化int类型传导给父类T
          Teacher.id = 550346;//老师作为人类的id
      }
  }

  class people<T>
  {
      //编号属性
      public T id { get; set; } 
  }
  class teacher<B> : people<B>
  {
      //当无法确定子类的类型时、可以把子类看做泛型类、
      //当子类实例化时、特化的类型B也会传导给父类T
  }

``` # 总结