派生抽象基类

public abstract class cal<T>
{
    public abstract T add();
}

public class ab : cal<string>
{
    public override string add()
    {
        return null;
    }
}

泛型类的静态成员

public  class cal<T>
{
    public static int X=9;
}

public class ab : cal<string>
{
    
}

public class abs : cal<int>
{
    
}

public class Test : MonoBehaviour
{
    void Start()
    {
        cal<string>.X = 10;
        Debug.Log(cal<string>.X);
        Debug.Log(cal<int>.X);
    }

泛型类的接口

public interface IPort<T>
{
    T Go(T t);
}

public class person<T> :MonoBehaviour,IPort<person<T>>
{

    public virtual person<T> Go(person<T> t)
    {
        Debug.Log("10");
        return null;
    }
}

public class student : person<student>
{
    public override person<student> Go(person<student> s)
    {
        Debug.Log("20");
        return null;
    }
}

public class teacher : person<teacher>
{
    
}

public class Test : MonoBehaviour
{
    void Start()
    {
        person<student> s = new person<student>();
        person<teacher> t = new person<teacher>();
        student student = new student();
        teacher teacher = new teacher();
        s.Go(s);  //10
        t.Go(t);  //10
        student.Go(student);  //20
        student.Go(s);  //20
        teacher.Go(teacher);  //10
        teacher.Go(t); //10
    }

泛型方法

泛型方法实例

public class Account
{
    public string Name { get;}
    public int Balance { get;}

    public Account(string name, int balance)
    {
        Name = name;
        Balance = balance;
    }
}

public static class Algori
{
    public static int Acc(IEnumerable<Account> source)  //IEnumerable是List等的基类
    {
        int sun = 0;
        foreach (Account a in source)
        {
            sun+=a.Balance;
        }
        return sun;
    }
}

public class Test : MonoBehaviour
{
    public List<Account> acc;
    void Start()
    {
        int index = Algori.Acc(acc);
    }

带约束的泛型方法

public interface IAccount
{
    string Name { get;}
    int Balance { get;}
}

public class Account :IAccount
{
    public string Name { get; }
    public int Balance { get; }

    public Account(string name, int balance)
    {
        Name = name;
        Balance = balance;
    }
    
}

public static class Algori
{
    public static int Acc<TAccount>(IEnumerable<TAccount> source)
        where TAccount :IAccount//IEnumerable是List等的基类
    {
        int sun = 0;
        foreach (TAccount a in source)
        {
            sun+=a.Balance;
        }
        return sun;
    }
}

public class Test : MonoBehaviour
{
    public List<Account> acc;
    void Start()
    {
        int index = Algori.Acc(acc);
    }

带委托的泛型方法

public interface IAccount
{
    string Name { get;}
    int Balance { get;}
}

public class Account :IAccount
{
    public string Name { get; }
    public int Balance { get; }

    public Account(string name, int balance)
    {
        Name = name;
        Balance = balance;
    }
    
}

public static class Algori
{
    public static T2 Acc<T1,T2>(IEnumerable<T1> source,
        Func<T1,T2,T2> action)  //第三个T2表示返回值类型，不加下方委托实现则会报错
    {
        T2 sun = default(T2);
        foreach (T1 a in source)
        {
            sun=action(a,sun);
        }
        return sun;
    }
}

public class Test : MonoBehaviour
{
    public List<Account> acc;
    void Start()
    {
        int index = Algori.Acc<Account,int>(acc, (Account a, int i) => { return a.Balance + i;});
    }