C#进阶02——泛型

1.泛型

1.泛型是什么

泛型实现了类型参数化，达到代码重用目的

通过类型参数化来实现同一份代码上操作多种类型

泛型相当于类型占位符

定义类或方法时使用替代符代表变量类型

当真正使用类或者方法时再具体指定类型

2.泛型分类

泛型类和泛型接口

基本语法：

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

泛型函数
基本语法：函数名<泛型占位字母>(参数列表)

注意：泛型占位字母可以有多个，用逗号分开

3.泛型类和接口

    //泛型类
    class TestClass<T>
    {
        public T value;
    }
    class TestClass2<T1, T2, K, M, LL, Key, Value>
    {
        public T1 value1;
        public T2 value2;
        public K value3;
        public M value4;
        public LL value5;
        public Key value6;
        public Value value7;
    }
 
    //泛型接口
    interface TestInterface<T>
    {
        T value
        {
            get;
            set;
        }
    }
    class Test : TestInterface<int>
    {
        public int value { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
    }

 4.泛型方法

1.普通类中的泛型方法

    class Test2
    {
        public void TestFun<T>( T value)
        {
            Console.WriteLine(value);
        }

        public void TestFun<T>()
        {
            //用泛型类型 在里面做一些逻辑处理
            T t = default(T);
        }

        public T TestFun<T>(string v)
        {
            return default(T);
        }

        public void TestFun<T,K,M>(T t, K k, M m)
        {

        }
    }

2.泛型类中的泛型方法

    class Test2<T>
    {
        public T value;

        public void TestFun<K>(K k)
        {
            Console.WriteLine(k);
        }

        //这个不叫泛型方法 因为 T是泛型类申明的时候 就指定 在使用这个函数的时候 
        //我们不能再去动态的变化了
        public void TestFun(T t)
        {

        }
    }

5.泛型的作用

1.不同类型对象的相同逻辑就可以选择泛型

2.使用泛型可以一定程度避免装箱拆箱

举例：优化ArrayList

    class ArrayList<T>
    {
        private T[] array;
        public void Add(T value)
        {
            
        }
        public void Remove(T value)
        {
 
        }
    }

 6.总结

1. 申明泛型时 它只是一个类型的占位符
2. 泛型真正起作用的时候 是在使用它的时候
3. 泛型占位字母可以有n个用逗号分开
4. 泛型占位字母一般是大写字母
5. 不确定泛型类型时 获取默认值 可以使用default(占位字符)
6. 看到<>包裹的字母 那肯定是泛型

    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("泛型");
 
            TestClass<int> t = new TestClass<int>();
            t.value = 10;
            Console.WriteLine(t.value);
 
            TestClass<string> t2 = new TestClass<string>();
            t2.value = "123123";
            Console.WriteLine(t2.value);
 
            TestClass2<int, string, float, double, TestClass<int>, uint, short> t3 = new TestClass2<int, string, float, double, TestClass<int>, uint, short>();
 
            Test2 tt = new Test2();
            tt.TestFun<string>("123123");
 
            Test2<int> tt2 = new Test2<int>();
            tt2.TestFun(10);
            tt2.TestFun<string>("123");
            tt2.TestFun<float>(1.2f);
 
        }
    }

2.泛型约束 

1.什么是泛型约束 

让泛型的类型有一定的限制
关键字：where
泛型约束一共有6种
1.值类型                                                 where 泛型字母:struct
2.引用类型                                             where 泛型字母:class
3.存在无参公共构造函数                       where 泛型字母:new()
4.某个类本身或者其派生类                   where 泛型字母:类名
5.某个接口的派生类型                          where 泛型字母:接口名
6.另一个泛型类型本身或者派生类型    where 泛型字母:另一个泛型字母

where 泛型字母:(约束的类型)

2.各泛型约束讲解

1.值类型约束

    class Test1<T> where T:struct
    {
        public T value;

        public void TestFun<K>(K v) where K:struct
        {

        }
    }

 2.引用类型约束

    class Test2<T> where T : class
    {
        public T value;
        public void TestFun<K>(K k) where K : class
        {
 
        }
    }

3.公共无参构造约束

    class Test3<T> where T : new()
    {
        public T value;
        public void TestFun<K>(K k) where K : new()
        {
 
        }
    }
    class Test1
    {
        
    }
    class Test2
    {
        public Test2(int a)
        {
            
        }
    }

4.类约束

    class Test4<T> where T : Test1
    {
        public T value;
        public void TestFun<K>(K k) where K : Test1
        {
 
        }
    }
    class Test3 : Test1
    {
        
    }

5.接口约束

    interface IFly
    {

    }

    interface IMove:IFly
    {

    }

    class Test4:IFly
    {

    }

    class Test5<T> where T : IFly
    {
        public T value;

        public void TestFun<K>(K k) where K : IFly
        {

        }
    }

6.接口约束

    interface IFly
    {
        
    }
    class Test4 : IFly
    {
        
    }
    class Test5<T> where T : IFly
    {
        public T value;
        public void TestFun<K>(K k) where K : IFly
        {
 
        }
    }

7.另一个泛型约束

    class Test6<T,U> where T : U
    {
        public T value;

        public void TestFun<K,V>(K k) where K : V
        {

        }
    }

3.约束的组合使用

    //new()放在最后
    class Test7<T> where T : class,new()
    {
        
    }

4.多个泛型有约束

    class Test8<T,K> where T:class,new() where K:struct
    {

    }

5.总结

泛型约束：让类型有一定限制

class

struct

new()

类名

接口名

另一个泛型字母

注意：

1. 可以组合使用
2. 多个泛型约束 用where连接即可