泛型及泛型约束

---

前言

泛型是什么

泛型是类型占位符，可以在声明类型时使用泛型，后面到真正使用其它类型时再替换

泛型约束

顾名思义，是对泛型使用时增添的限制条件，用来限制泛型可以替代的类型范围

---

泛型的使用

基本语法
class 类名<泛型占位字母>
interface 接口名<泛型占位字母>

---

泛型类和泛型接口

class TestClass<T> {
   public T Value;
}
class TestClass2<T, M> {
   public T tValue;
   public M mValue;
}
//泛型接口
interface ITestInterface<T> {
   public T Value{get;set;}
}
//泛型接口继承
class Test : ITestInterface<int>
{
   public int Value { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
}

---

泛型方法

注意：泛型类的名字 和 普通类的 类名可以相同

//1、普通类中的泛型方法
class Test2 {
    public void TestFun<T>(T value){
        Console.WriteLine(value);
    }
    public void TestFun<T>() {
        //用泛型类型 在里面做一些逻辑处理
        T t = default(T);
    }
    //有返回值的泛型方法
    //泛型返回不确定的类型时用default
    public T TestFun<T>(string value){
        return default(T);
    }
    //多个泛型占位符的泛型方法
    public void TestFun<T, K, M>(T t,K k,M m) {

    }
}
//2、泛型类中的泛型方法


class Test2<T> {
    public T value;

    //这个不叫泛型方法,因为 T是泛型类申明的时候就  指定的，和泛型方法无关
    public void TestFun(T t) {
        
    }
    public void TestFun<M>(M m){
        Console.WriteLine(m);   
    }
}

---

泛型的作用

注意：此处的ArrayList并非unity封装好的，是自定义的同名类

//因为使用了泛型可以替代万物之父Object任意类型的数据
//1、不同类型对象的相同逻辑处理就可以选择泛型
//2、使用泛型可以一定程度避免装箱拆箱
//举例：优化ArrayList
class ArrayList<T> {
   private T[] array;

   public void Add(T value) {

   }
   public void Remove(T value) {
   
   }
}

关于泛型总结

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

---

泛型约束

六种泛型约束

1、值类型 where 泛型字母：struct
2、引用类型 where 泛型字母：class
3、存在无参公共构造函数 where 泛型字母：new()
4、某个类本身或者其派生类 where 泛型字母：类名
5、某个接口的派生类型 where 泛型字母：接口名
6、另一个泛型类型本身或者派生类型 where 泛型字母：另一个泛型字母
此处的派生类指的是父类的子类

值类型约束

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

引用类型约束

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

存在无参公共构造函数的约束

在一个类中如果不声明无参构造函数而去声明其它构造函数，那么这个类中的无参构造函数就会被顶替掉

    class Test3<T> where T : new() {
        
    }
    //不满足约束
    class Test1 {
        //顶掉 公共无参构造
        public Test1(int i) { }
    }
    //满足约束
    class Test2 {
        
    }

某个类本身或其派生类的约束

    class Test4<T>where T : Test2{ 
        
    }
    class Test3 : Test2{ 
        
    }

接口约束

    interface IFly{ }
    interface IMove : IFly
    {
        
    }
    class Test4 : IFly { }
    class Test5<T> where T : IFly {
        
    }

另一个泛型类型本身或者派生类型

 class Test6<T, U> where T : U {
     public T value;
     public void TestFun<K,V>(K k) where K : V {
     
     }
 }

约束的组合使用

//用逗号隔开即可
class Test7<T>where T : class,new()
{
    
}

多个泛型有约束

//在泛型约束完后用逗号隔开，开始下一个约束
class Test8<T,K>where T : class,new() where K : new()
{
    
}