【C#】泛型

【C#】泛型

泛型是什么

泛型是将类型作为参数传递给类、结构、接口和方法,这些参数相当于类型占位符。当我们定义类或方法时使用占位符代替变量类型,真正使用时再具体指定数据类型,以此来达到代码重用目的。

泛型特点

  1. 提高代码重用性
  2. 一定程度避免装箱拆箱

泛型分类

声明 泛型类 基本语法:

class 类名<泛型占位字母>

声明 泛型结构 基本语法:

struct 结构名<泛型占位字母>

声明 泛型接口 基本语法:

interface 接口名<泛型占位字母>

声明 泛型函数 基本语法:

函数名<泛型占位字母>(参数列表)
注意:泛型占位字母可以有多个,用逗号分开

代码展示

1. 泛型类

class TestClass<T>
{
    public T value;
}
class TestClass2<T1, T2, K, J>
{
    public T1 value1;
    public T2 value2;
    public K value3;
    public J value4;
}
class Program
{
    static void Main(string[] args)
    {
        //使用时必须指定具体数据类型,如:int类型
        TestClass<int> t = new TestClass<int>();
        t.value = 5;
        Console.WriteLine(t.value);//输出:5
    
        //再创建一个对象,将泛型指定为string类型,这里说明泛型可以提高代码重用性
        TestClass<string> t2 = new TestClass<string>();
        t2.value = "123456";
        Console.WriteLine(t2.value);//输出:123456
    
        //创建一个有多个泛型类的对象
        TestClass2<int, string, bool, TestClass<float>> t3 = new TestClass2<int, string, bool, TestClass<float>>();
        
        Console.ReadLine();
    }
}

2. 泛型结构体

struct TestStruct<T>
{
    public T value;
}
class Program
{
    static void Main(string[] args)
    {
        //创建结构体对象
        TestStruct<bool> ts = new TestStruct<bool>();
        Console.WriteLine(ts.value);//输出:False
        
        Console.ReadLine();
    }
}

3. 泛型接口及类继承

interface TestInterface<T>
{
    T value
    {
        get;
        set;
    }
}

class Test : TestInterface<int>
{
    private int myValue;
    public int value 
    {
        get
        {
            return myValue;
        }
        set
        {
            myValue = value;
        }
    }
}
class Program
{
    static void Main(string[] args)
    {
        //创建接口实例,Test类是实现 指定泛型为int类型的接口 的类,所以创建接口实例时,泛型指定类型必须与Test类指定的泛型类型一致 即int类型
        TestInterface<int> it = new Test();
        it.value = 100;
        Console.WriteLine(it.value);//输出:100
        
        Console.ReadLine();
    }
}

创建接口实例时,泛型指定类型必须与Test类指定的泛型类型不一致时,会报错。
在这里插入图片描述

4. 泛型方法

  1. 普通类中的泛型方法
class Test2
{
    //泛型作为参数传递
    public void TestFun<T>(T value)
    {
        Console.WriteLine(value);
    }

    //泛型作为返回值
    public T TestFun<T>(bool v)
    {
        return default(T);
    }

    //泛型既不作为参数传递 也不作为返回值
    public void TestFun<T>()
    {
        //用参数类型在里面进行逻辑处理,例如:
        T t = default(T);//获得类型的默认值方法:default()
        Console.WriteLine(t);
    }

    //多个泛型作为参数传递
    public void TestFun<T, K, M>(T t, K k, M m)
    {

    }
}
class Program
{
    static void Main(string[] args)
    {
        //创建Test2对象
        Test2 tt = new Test2();
        tt.TestFun<float>(12.5f);//作为参数传递时 输出:12.5
        tt.TestFun<string>(true);//作为返回值
        tt.TestFun<int>();//既不作为参数传递 也不作为返回值  输出:0
        tt.TestFun<int, double, bool>(1, 8.888888, false);//多个作为参数传递
        
        Console.ReadLine();
    }
}
  1. 泛型类中的泛型方法
//Test2 与 Test2 名字一样但是后者有泛型,就相当于新的类,两个类是不一样的
class Test2<T>
{
    public T value;

    //这个不叫泛型方法 因为 T是泛型类声明的时候 就指定的 在使用这个函数的时候 不能进行动态变化
    public void TestFun(T t)
    {
        Console.WriteLine("No :" + t);
    }

    //这个才是泛型方法 一直是方法名后面加了尖括号并且有占位符
    public void TestFun<K>(K k)
    {
        Console.WriteLine("YES :" + k);
    }
}

class Program
{
    static void Main(string[] args)
    {
        Test2<int> tt2 = new Test2<int>();
        //这两个不是同一个方法
        tt2.TestFun(156);//输出:No :156
        tt2.TestFun<int>(156);//输出:YES :156
        //这两个同一个方法
        tt2.TestFun<string>("123");//输出:YES :123
        tt2.TestFun("789");//输出:YES :789
    }
}

tt2.TestFun(156); 与 tt2.TestFun(156); 调用的方法如下:
【C#】泛型_第1张图片
tt2.TestFun(“123”); 与 tt2.TestFun(“789”); 调用的方法如下:
【C#】泛型_第2张图片

【tt2】是一个泛型为【int类型】的【Test2】对象,使用tt2.TestFun()方法时,传入的参数与对象的泛型一致时,则会调用【public void TestFun(T t)】。传入的参数与对象的泛型不一致时,则会调用同名的泛型方法【public void TestFun(K k)】,且调用时可以省略尖括号【<>】,通过参数直接判断该方法的泛型数据类型。

小结

  1. 声明泛型时,就是一个任意类型的占位符,真正起作用是在使用它时。
  2. 泛型占位符至少有一个,可以有无数个,多个时用逗号分隔开。
  3. 文章提到的default目的是用来获取任意类型的默认值的。

因为作者精力有限,文章中难免出现一些错漏,敬请广大专家和网友批评、指正。

你可能感兴趣的:(C#知识模块,c#,开发语言)