黑马程序员——05 泛型

------- Windows Phone 7手机开发、.Net培训、期待与您交流！ -------

——什么是泛型：

简介:具有占位符的类（类型参数）的类，结构，接口和方法

作用：可以最大限度的重用代码，保护类型的安以及提高性能

 ——类型形参：

.简介：

类型形参是一个简单标识符，它只起占位符的作用，直到在使用时才为其制定实际类型

规则：放置在类名后的“<>”分隔符中指定

注意：该实例将存储类型形参的数据而不进行数据类型转换

例码:

1.声明一个泛型类Test<T>,其中T为类型形参 

 public class Test<T>
    {
    
    }

2.创建Test<T>泛型类的实例t，并指定该实例的类型形参的类型为int

Test<int> t = newTest<int>();

 （注意：在类声明中，每个类型形参在该类的声明空间中定义一个名称，而且不能与另一个类型形参或该类中声明的成员具有相同的名称。当然，类型形参也不能与类型本身具有相同的名称）

3.声明有两个类型形参的泛型类Test<T,U>的泛型类

public class Test<T,U>
    {
    
    }

——类型形参的约束

规则：

访问修饰符 classTest<T>where T：类型

列表项：

可以是类类型，接口类型甚或类型形参（还可以是特殊引用类型，值类型和构造函数约束）

常用约束：

1.T:结构，类型参数必须是值类型，但不能是Nullable类型。

2.T:类，类型形参必须是引用类型

3.T：new（），类型参数必须距有无参数的公共构造函数，如果该类型参数存在多个约束，则new（）约束必须最后指定。

4.T:<基类名>，类型参数必须是指定的基类或者其派生类

5.T:<接口名称>，类型参数必须是指定的借口或试下指定的借口

6.T:U,T的类型参数必须是U提供的参数或派生自为U提供的参数

例码：

1.创建名称为Test<T>泛型类型，并指定约束。该约束指定T的类型参数必须为值类型

（除了Nullable类型之外）

public class Test<T> where T : struct
{ 
    
}

2.创建名称为”Test<T>”泛型类型，并指定了约束，该约束指定T的类型参数必须为引用类型(class指定)或者具有无参数的公共构造函数的类型（new()指定）

public class Test<T> where T : class,new()
{
    
}

（注意：通常情况下，对于一个给定的类型参数而言，其约束的接口和类型形参的数目不受限制，但只能有一个类）

 3.创建一个名称为Test<T>泛型类型，并指定约束，该约束指定T的类型形参必须为引用类型，且需要实现Iinterface和Iinterface（T）借口

Public classTest<T>where T：class，Iinterface，Iinterface<T>
{

 

}

注意：类型形参约束虽然提供更强的编译时类型检查，并在某些情况下改进性能，但是它们也使泛型类型的使用受到限制)

——声明泛型类

泛型类声明和普通类一样遵循类声明的规则。

规则：

泛型类名<类型形参>自定义名=new泛型类名<类型形参>（）；

注意:

（一个泛型类一般至少包含一个类型形参。）

（当创建该泛型类的实例时，需要执行该类型形参的具体类型）

例码：

1.首先声明一个泛型类Test<T>

public class Test<T>

2.实例化该泛型类Test<T>，并指定该实例的类型形参为string类型

Test<string>a=newTest<string>（）;

 ——泛型类的成员

简介:

泛型类是一种特殊的类，有自己的成员

泛型类的所有成员都可以直接使用其所属类的类型形参

在运行时，类型形参都被替换为相应的实际类型（该类型在创建类的实例时指定）

例码：

1.声明一个泛型类Test<T>，T为类型形参，在该类中声明一个私有字段t（类型为T）和一个方法GetValue（）（返回值的类型为T）

public class Test<T>
    {
        private T t;         //定义私有变量t，类型为T
        public T GetValue()   //获取t变量的值
        {
            return t;
        }
    }

2.如果在下面创建一个Test<T>泛型类的实例te：“Test<int>te=new Test<int>（）；”，实际上代码已被解释成如下代码

public class Test<T>
    {
        private T t;         //定义私有变量t，类型为T
        public T GetValue()   //获取t变量的值
        {
            return t;
        }
    }

——泛型类中的静态字段

简介：

泛型类中的静态字段的共享方法比较特殊，即只有在具有相同类型形参的类型的实例才能够共享同一个静态字段的值

 例码：

1.  声明一个泛型类Test<T>的泛型类，在该类中声明一个静态字段count和一个静态属性Count。

count静态字段的初始化值为0，并在Test<T>泛型类的构造函数中增加1.Count静态属性获取count静态字段的值

public class Test<T>
    {
        static int count = 0;        //静态字段count，初始化值为0
        public Test()
        {
            count++;              //在构造函数中，将count静态字段的值增加1
        }
        public static int Count()        //静态属性Count，获取静态字段的值
        {
            return count;
        }
    }

 2.创建泛型类Test<T>泛型类的3个实例：t1，t2，t3。

t1和t2实例的类型形参的类型为int，而t3实例的类型形参的类型float

因为 t1和t2实例的类型形参的类型相同，因此，它们能够共享count静态字段的值

此时count1的值为1，count2的值为2.

而t3实例和t1或者t2实例都不能共享count静态字段的值。此时，count3的值为1

Test<int>t1=newTest<int>();  //实例化一个int类型的泛型类t1

Intcount1=t1.Count;          //count1的值为1

 

Test<int>t2=newTest<int>();  //实例化一个int类型的泛型类t2

Intcount2=t2.Count；         //count2的值为2

 

Test<float>t3=newTest<float>();//实例化一个float类型的泛型类t3

Intcount3=t3.Count；           //count3的值为1

 

 ——泛型方法

简介:

泛型方法和泛型类性质相同，都使用类型形参，也可以对类型形参加以约束。

泛型方法可以加以约束，可以声明在类，结构或接口中，而这些类，结构，接口本身可以是泛型或非泛型

如果这些接口，结构或接口是泛型类型，那么在这些方法中内既可以引用该泛型方法的类型形参，也可以使用这些类，结构，或接口的类型形参

 声明泛型方法:

泛型方法除了普通方法的普通参数以外，还必须包含类型形参，即泛型方法是指在声明中包含类型形参的方法

 例码:

1.在Test类中声明一个名称为”Swap<T>(refT left，ref T right)”的泛型方法

该方法交换left和right参数的数据，参数的类型由T类型形参决定。

其中T为类型形参，left和right为引用参数。

public class Test
    {
        //声明泛型方法Swap，该方法交换left和right参数的数据
        public void Swap<T>(ref T left, ref T right)
        {
            T temp;//创建临时变量
            temp = left;
            left = right;
            right = temp;
        }
    }

2.在Test<T>泛型类中声明一个名称为“Swap<U>(ref U left，ref U right)”的泛型方法

该方法叫交换left和right参数的数据，参数的类型由U类型形参决定。

其中，U为类型形参，left和right为引用参数

public void Swap<U>(ref U left, ref U right)
        {
            U temp;
            temp = left;
            left = right;
            right = temp;
        }
    }

注意：

Test<T>泛型类和Swap<U>(refU left，ref U right)泛型方法都包含了类型形参

如果把Swap<U>(ref U left，refU right)泛型方法的声明修改为Swap<T>(ref T left，refT right)

则在编译该代码时，系统会显示警告

那是因为Swap<T>(ref T left，refT right)中的T类型形参会覆盖A<T>泛型类的T类型形参

 调用泛型方法：

简介：

调用泛型方法和调用普通方法一样，但需要为类型形参提供相应的类型实参列表

泛型方法调用可以显示指定类型实参列表，或者可以省略类型实参列表并一栏类型判断确定类型实参

例码：

1.创建Test类的实例t，并创建类型为int的两个变量：i和j（它们的值分别为10和20）

然后调用T类的Swap<T>(refT left，ref T right)泛型方法

                Test t=new Test();           //创建Test类的实例t
                int i=10;                //创建类型为int的变量i
                int j=20;                //创建类型为int 的j变量
                t.Swap<int>(ref  i, ref  j);//调用Swap<T>(refT left，ref T right)方法

注意：在调用泛型方法时，如果编译器可以推断出类型形参的值，那么可以省略类型形参

通过委托调用泛型方法：

简介:

除可以调用普通方法外，还可以通过委托来调用泛型方法

例码:

1.  声明一个PrintDelegate委托，该委托的参数列表为：“int i，int j”，返回类信为int。

然后在Test类中声明一个泛型方法F<T><T i>。

最后在Main()方法中创建Test类的实例t，创建PrintDelegate委托的实例pd，并用pd调用t的F<T><Ti>泛型方法

namespace 调用委托方法
{
    public delegate int PrintDelegate(int i, int j);
    public class Test
    {
        public T F<T>(T i)
        {
           return i;
        }
    }
    class Program
    {
       static void Main(string[] args)
        {
            Test t = new Test(); //实例化一个Test类
            PrintDelegate pd = new PrintDelegate(t.F<int>(10));
            Console.WriteLine("通过委托PrintDelegate 调用泛型方法F<T><Ti>" + pd(10));
            Console.ReadKey();
        }
    }

 虚泛型方法：

简介：

同普通方法一样，泛型方法也存在虚泛型方法，它可以使用abstract，virtual和override修饰符进行声明

例码：

1.声明一个Program和一个派生与Program类的Test类

Program类中声明一个名称为”Swap<T>(ref T left，ref T right)”的虚泛型方法

Test类中使用”Swap<U>(ref U left，ref U right)”来重写该虚方法。

这两个方法都实现left和right参数的数据，参数的类型由T或U类型形参决定。

其中T和U都为类型形参，left和right为引用参数

namespace 虚构泛型方法
{
    public class Program
    {
        public virtual void Swap<T>(ref T left, ref T right)
        {
            T temp;
            temp = left;
            left = right;
            right = temp;

        }
        public class Test : Program
        {
            public override void Swap<U>(ref U left, ref U right)
            {
                U temp;
                temp = left;
                left = right;
                right = temp;
            }
        }
        static void Main(string[] args)
        {
            int left = 10, right = 20;
            Test t = new Test();
            t.Swap<int>(ref left, ref right);
            Console.WriteLine("left=" + left + "" + "right=" + right);
            Console.ReadKey();
        }
    }
}