C#自定义泛型

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace 自定义泛型
{
    /*
     * 泛型：泛型实现了类型的参数化，可以简单的理解为泛型相当于具体数据类型的占位符。
     * 举例：ArrayList(集合)、List<T>、<T>代表一个泛型声明，T就是泛型，使用的时候可以指定具体的数据类型。
     * 应用：当定义类、接口以及其它成员的时候如果不知道具体的数据类型，那么就可以使用声明一个泛型进行使用。
     * 分类：根据泛型声明的位置不同进行分类
     *      1、泛型类、泛型接口
     *          语法：class 类名<泛型>{}、interface 接口名<泛型>{} 
     *          如：public class List<T> : IList<T>, ICollection<T>
     *      2、泛型方法
     *          语法：修饰符 返回值类型 函数名<泛型>(参数列表){}
     *          如：public Read0nlycollection<T> AsReadOnly()
     *      
     * 特点：
     *      <T>代表声明一个泛型,该泛型T是具体数据类型的一个占位符
     *      T代表就是一个广泛的类型，创建该类对象的时候可以具体进行指定new Dataclass<int>实现泛型接口的子类也需要重新声明接口的泛型
     *      
     * 扩展：
     *      泛型的声明可以有多个，多个泛型使用一个尖括号<>，多个大写字母使用逗号分隔，一般都是采用单个大写字母：T、K等
     */

    // 自定义泛型：泛型类
    public class DataClass<T>
    {
        // 定义字段，但是字段的具体类型现在描述的时候还不清楚
        private T data;
        // 定义属性
        public T Datat { get; set; }
        // 定义构造函数
        public DataClass() { }
        public DataClass(T _data)
        {
            this.data = _data;
        }
        // 定义函数
        public T ShowData()
        {
            return this.data;
        }
    }

    // 自定义泛型：泛型接口
    public interface I_Move<K>
    {
        K Speed { get; set; }
        void Move(K speed);
    }

    // 实现接口
    public class Fish<K, N, P, W> : I_Move<K>
    {
        public K Speed { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
        // 定义自己的字段
        public N name;
        public P price;
        public W weight;
        public void Move(K speed)
        {
            Console.WriteLine($"移动速度：{speed}");
        }

        public void Print()
        {
            Console.WriteLine($"{name} 价格是：{price} 元/斤 总重：{weight}.");
        }
    }

    // 定义泛型方法：定义一个类，提供一个泛型函数，用于返回任何数据类型的默认值
    public class Compute
    {
        // 泛型方法
        public M DefaultValue<M>(M param)
        {
            Console.WriteLine(param);
            return default(M);
        }
    }

    class Person<T>
    {
        public T Id { get; set; }
    }

    // 1、将父类进行特化，然后继承
    class Teacher : Person<int>
    {

    }

    // 2、无法在Class Teacher子类声明的时候决定父类的泛型类型
    class Teacher<T> : Person<T>
    {

    }

    class Teacher<T, U> : Person<T>
    {
        public U Data { get; set; }
    }

    class Program
    {
        static void Main(string[] args)
        {
            // 【1】泛型类的使用
            DataClass<string> dataClass01 = new DataClass<string>();
            Console.WriteLine(dataClass01.ShowData());

            DataClass<int> dataClass02 = new DataClass<int>();
            Console.WriteLine(dataClass02.ShowData());

            // 【2】泛型接口的使用：需要创建泛型接口实现类的子类对象
            I_Move<double> i_Move = new Fish<double, string, double, float>();
            i_Move.Move(12.5f);
            Fish<double, string, double, float> fish = i_Move as Fish<double, string, double, float>;
            fish.name = "金枪鱼";
            fish.price = 55.5d;
            fish.weight = 5f;
            fish.Print();

            // 【3】泛型方法的使用
            Compute compute = new Compute();
            // 结果：0
            Console.WriteLine(compute.DefaultValue<int>(12));
            // 结果：False
            Console.WriteLine(compute.DefaultValue<bool>(true));

            // 【4】泛型类的继承使用
            Teacher<int, float> teacher = new Teacher<int, float>();

            Console.ReadKey();
        }
    }
}