C#泛型概述（三）

今天更新的比较早，因为太有空了，所以多看看书让自己脑袋转起来，这次我们就讲一些常规的理论，我也会举例子来说明，举例子会更加便于理解。

 

三、对比泛型类和常规类

首先介绍泛型类是什么，看了前面章节的都知道，泛型类就是这样class Person<T>,而常规类就是我们基于object的类例如class Animal，他的所有方法获取都是object类型的参数，返回的也是object类型。这很容易区分。下面我们看看它们之间有什么区别。

第一、

常规类可以用于容纳各种类型的类，例如int，string等，但是无论如何它都是使用一个类的实例，必须将数据转换成object类型，或将object类型转为正确的类型才可以，我们举例说明，代码不是很长而且都标有注释，耐心的看：

常规类：Generalize.cs

     //常规类
    class Generalized
    {
        //object类型的数组
        private object[] data;
        //设置数组的头尾
        private int head=0;
        private int tail=0;
        //设置入队，出队操作次数.入+1，出-1
        private int queueop = 0;

        //构造方法，实例化时创建一个大小为10的object类型数组
        public Generalized() {
            this.data = new object[10];
        }
        //入队，向数组添加数字，传入一个object类型的数值，这一步就叫装箱
        public void Enqueue(object num) {
            if (queueop == this.data.Length) {
                Console.WriteLine("数组满了，装不下了");
            }
            this.data[head] = num;//将传进来的参数放进数组
            this.head++;               //数组下标+1
            this.head %= this.data.Length;
            this.queueop++;           //入队操作+1
        }
        //出队，向数组取出数字，返回一个object类型的数值
        public object Dequeue() {
            if (queueop == 0) {
                Console.WriteLine("数组是空的，没得出了");
            }
            object num = data[tail];//将数组里的数取出来 
            this.tail++;            
            this.tail %= this.data.Length;
            queueop--;             //出队操作-1
            return num;
        }
    }

程序主入口 :Program.cs

 class Program
    {
        static void Main(string[] args)
        {
            //实例化一个常规类
            Generalized generalized = new Generalized();
            //创建一个int类型
            int num = 99;
            //入队:这是一个装箱操作，int类型转进去给了object，把int装进去了object对象中
            generalized.Enqueue(num);
            //出队:这是一个拆箱操作,将返回的object类型转为int类型
            int a = (int)generalized.Dequeue();
            //控制台输出
            Console.WriteLine(a);
        }
    }

为什么说它容纳或处理多类型时任何情况都是用同一个类的实例，我们看看这个就知道了，这样的话可以一个实例处理多个，但是由于多次拆箱装箱就会消耗内存和处理器的时间。

    class Program
    {
        static void Main(string[] args)
        {
            //实例化一个常规类
            Generalized generalized = new Generalized();
            //创建一个int类型，string类型
            int num = 99;
            string str = "你好";
            //入队:这是一个装箱操作，int和string类型转进去给了object，把int装进去了object对象中
            generalized.Enqueue(num);
            generalized.Enqueue(str);
            //出队:这是一个拆箱操作,将返回的object类型转为int类型,将返回的object类型转为string类型
            int a = (int)generalized.Dequeue();
            string b = (string)generalized.Dequeue();
            //控制台输出
            Console.WriteLine(a);
            Console.WriteLine(b);           
        }
    }

第二、

泛型类，每次我们为泛型类指定参数时，实际上编译器会把它变成一个全新的类，例如Genericity<int>,Genericity<string>,它们两者是不一样的类，只不过"恰好”它们是有相同的行为，所以我们可以说泛型类是一个模版，可以把它比做成一个画板，而里面的<T>,我们给予类型时好比我们给这个画板的外貌新添了一种类型，比如有的人画板是漫威封面，有的人的画板是DC封面，但它们的作用都是相同的，都是拿来画画，只不过类型上它们有所不同，当我们给他赋予类型时，编译器只不过是按照我们的实际情况对着该模版生成一个具有具体类型的类，也就是说当你创建一个泛型类时它本身可以说它不是一个类，它是一个模版，等你给它赋予类型时编译器才会生成这个类，所以它们都称之为:"已构造类型" 

泛型类：Genericity.cs

    class Genericity<T>
    {
        //泛型字段
        private T[] data;
        //构造方法，实例化自动填充数组大小,2个位置
        public Genericity(){
            this.data = new T[2];
          }
        //泛型带返回值的方法,返回data数组的第一个值
        public T getData() {
            return data[0];
        }
        //泛型无返回值，带参方法，给数组第一个位置赋值
        public void setData(T num) {
            data[0] = num;
        }
    }

程序主入口：Program.cs

    class Program
    {
        static void Main(string[] args)
        {
            //看似来自同一类，其实编译器早已各自生成新的类并创建新的对象，它们都具有相同的属性，方法但却是不同类型的。
            Genericity<string> Strgenericity = new Genericity<string>();
            Genericity<int> Intgenericity = new Genericity<int>();
        }
    }