C#——面向对象——泛型——泛型类

什么是泛型类？

泛型就是一个模型（娃娃模型），装入类型的材料（泥、金属），可以塑造出想要的产品（泥娃娃、金属娃娃）。

class Cage<T>
    {
        T[] petsArray;这个就是T
        public void Putln(T pet) { }第一个方法是传入T类型的宠物
        public T TakeOut(int index) {...}第二个方法是取出一个T类型的宠物，int index限定了取出的是第几个
    }
Cage 宠物笼子模型
T 宠物类型
以上程序实现了：填充宠物类型T，得到了对应的笼子。T就是个占位符。

泛型类和普通类有什么区别呢？

长相不同：class Cage<T>{}     类名后面有个括号，括号里就是占位符了。区别是相当大的（人和天使在长相方面有什么别吗？天使长了双翅膀，泛型类长了个介个<T>）

T是个类类型参数，不是普通类型参数。类类型的参数也会出现在泛型类的实体当中。

为什么要用泛型呢？

现在我们来建笼子，不用泛型类的话就很麻烦了，如下所示

class DogCage{狗狗的笼子
       Dog[] petsArray;
       public void PutIn(Dog pet){...}
       public Dog TakeOut(int index){...}
}

class CatCage{猫咪的笼子
       Dog[] petsArray;
       public void PutIn(Dog pet){...}
       public Dog TakeOut(int index){...}
}

class MouseCage{老鼠的笼子
       Dog[] petsArray;
       public void PutIn(Dog pet){...}
       public Dog TakeOut(int index){...}
}

大大大提高了工作效率。

可是可是可是，为什么不用基类或接口呢？

这里就有个弊端了，看下面的代码：

class Cage{这里用的是一个接口，可是可是可是笼子的类型就没法设定了，用泛型的话可以具体到放什么类型的笼子，可是换成了接口，
那么就不知道放的是什么类型的笼子了，可能是狗类型的笼子，也有可能是猫类型的笼子。。。乱套了。。。如果真想用接口的话，也不是不行，
需要显式转换类型，把object类转换成具体的，然后再判断真实类型是什么。来来来，看看多麻烦。
      object[] petsArray;
       public void putIn(object pet){...}
       public object TakeOut(int index){...}
}

我们再来看下使用泛型类的具体步骤

class Cage<T>{...}第一步——泛型类声明
Cage<Dog> dogCage;第二步——Cage<Dog>类型的引用
dogCage=new Cage<Dog>();第三步——构造实例

具体例子如下：

namespace fanxinglei
{
    public class Cage<T>
    {
        T[] array;
        readonly int Size;笼子的大小
        int num;当前笼子已经装了多少只宠物 

        public Cage(int n)构造函数
        {
            Size = n;这个笼子可以容纳多少只同类型的宠物
            num = 0;数量初始化为0
            array = new T[Size];数组初始化
        }
        public void Putin(T pet)
        {
            if (num < Size)如果没有装满就放入数组
            {
                array[num++] = pet;
            }
            else如果装满了就打印一句话
            {
                Console.WriteLine("cage is full");
            }
        }
        public T TakeOut()
        {
            if (num > 0)如果有宠物的时候就取
            {
                return array[--num];
            }
            else如果没宠物的时候就打印一句话
            {
                Console.WriteLine("cage is empty");
                return default(T);
            }
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            var dogCage = new Cage<Dog>(1);
            dogCage.Putin(new Dog("A"));
            dogCage.Putin(new Dog("B"));
        }
    }
}

网友攻克流程：

刚看第一遍的时候乱的很，反复看了三四次，耗费了三四个小时也不明白，后来自己不用泛型，使用普通类去实现相同功能，才明白泛型怎么用 和目的；老师的一些与之前不同的写法也增加了理解难度。比如不写Petcage<Dog> dog=new Petcage<Dog> ("名字");而用一个从来没见过的 var代替。 还有 return default<T>也没解释啥意思；
说下我的理解：
泛型就是在不确定类的 参数类型和返回类型时，设置一个变量来代替这个固定的类型。 当创建类实例时，在给这个变量赋对应类类型值，这样就可以实现一个类，输出不同类型的值和方法； 
不用老师的例子，用一个给数组赋值输出数组的例子更好理解；比如设置一个类，构造函数初始化一个数组，数组类型为int,有给数组赋值方法和获取数组值的方法，在此注意：数组的类型int和获取数组值的方法的返回值类型都为int，如果实例此类调用方法，实参和返回值类型也必须是int；就此限定死了此类的实例； 如果想要一个设置char类型的实例，还得必须创建一个新的char的类和方法，才能实现；这样代码工作量就会很大；如果使用泛型，用变量<T>代替固定类型int或char,这样在实例化的时候，将T赋不同类型（int、double、char）,这样就可以获得想要的返回值类型，从而实现了一个模板，只变一个参数T 就能实现相同的功能；
上面给出的例子。只需要把所有<T>去掉，后面的T全改为int或char 就能变为普通类了。对比理解非常简单了

using System
namespace MyArrayApplication
{
    public class Array<T>
    {
        public int index;
        T[] a;
        public Array(int num)
        {
            a = new T[num];
        }
        public T GetArray(int index)
        {
            return a[index];
        }
        public void SetArray(int index, T value)
        {
            a[index] = value;
        }
    }
    public class Print 
    {
        static void Main(string[] args)
        {
           
            Array<char> b = new Array<char>(5);
            for (int i = 0; i < 5; i++)
            {
                b.SetArray(i, (char)(i + 98));
                Console.Write(b.GetArray(i)+" ");
             
            }
          
            Array<double> d = new Array<double>(20);
            for (int k = 0; k< 20; k++)
            {
                d.SetArray(k, Convert.ToDouble(k + 5.2));
                Console.Write(d.GetArray(k) + " ");
            }
            Console.ReadKey();
        }
    }
}