泛型知识

int   -2147483648～2147483647    21亿

在继承中，子类拥有父类的一切属性和行为，而且任何父类出现的地方，都可以用子类来替代;可谓“长江后浪推前浪”啊

object是一切类的父类

泛型在编译的时候确定类型(延迟思想)；

泛型：用一个方法，来满足不同类型的参数；泛型实际上是语法糖，由编译器提供功能；没有性能损失

泛型参数的个数可以随便定义

========================贴代码=====================================================

public class GenericClass //定义一个泛型类
{
    public static void show < T > (T tParameter) //泛型是一个方法后<T> 括号里传参数
        {
            Console.WriteLine("这是{0}，类型是{1}", tParameter, tParameter.GetType());
        }
    public static int Show < T, S > (string s, int t, int d) //泛型传的类型可以是多个T，S
        {
            int num = Convert.ToInt32(s);
            return num + t + d;
        }
    public static void Add < T > (int i, string s, double d)
    {
        double dd = i + d;
        Console.WriteLine("我是{0},我今年{1}岁", s, dd);
    }
    public static void ShowObject(object obj) //object 是所有类型的基类，但是在传入类型的时候，可能会牵扯到不同类型之间的装箱和拆箱，有性能损失；泛型没有装拆箱，没有性能损失
        {
            Console.WriteLine("这是{0},类型是{1}", obj, obj.GetType());
        }
    public static void ShowT < SPara > (SPara tparameter) //这个任何类型都可以用，只要传入类型，括号里的参数正确就ok
        {
            Console.WriteLine("这个是泛型类Show T,parameter={0},parameterType={1}", tparameter, tparameter.GetType());
        }
    public static void ShowTT < SPara, T, S > (SPara tparameter, T t, S s) //传入多个类型
        {
            Console.WriteLine("这个是泛型类ShowTT,parameter={0},parameterType={1},t={2},tType={3},s={4},sType={5}", tparameter, tparameter.GetType(), t, t.GetType(), s, s.GetType());
        }
}

public class GenericConstaint //定义泛型约束
{
    //where后面意思是T不仅要是个class对象，还可以new对象(可以有无参数构造)
    public static T Get < T > (T t) where T: class, new() //必须是个引用类型，string class ....
        {
            //引用类型的默认值是null
            T tt = new T(); //约束加了new(),才能new出来
            return default(T); //不管T是什么类型，都会给一个默认值，
           // default 为泛型代码中的默认关键字，
           // 给定参数化类型 T 的一个变量 t， 只有当 T 为引用类型时， 语句 t = null 才有效；
           // 只有当 T 为数值类型而不是结构时， 语句 t = 0 才能正常使用。
           // 解决方案是使用
           // default 关键字， 此关键字对于引用类型会返回空， 对于数值类型会返回零。
            对于结构， 此关键字将返回初始化为零或空的每个结构成员， 具体取决于这些结构是值类型还是引用类型。
        }
    public static T GetQuery < T > (T t) where T: struct //必须是个值类型， 
        { //值类型的默认值不确定
            return default(T);
        }
    public static void SayHi < T > (T t) where T: People //t必须是People类型或者people类型的子类
        {
            Console.WriteLine("ID:{0},Name:{1}", t.Id, t.name);
            t.SayHi();
        }
    public interface ISaySometing
    {
        void SayHello();
    }
}
public class People
{
    public string name
    {
        set;
        get;
    }
    public int Id
    {
        set;
        get;
    }
    public void SayHi()
    {
        Console.WriteLine("上午好");
    }
}

class Program
{
    static void Main(string[] args)
    {
        GenericClass.show < DateTime > (DateTime.Now);
        int num = GenericClass.Show < string, string > ("1", 1, 1);
        Console.WriteLine(num);
        //在泛型的单个类型的时候，<T>是传参数的类型；当要传入多个参数的时候，括号里可以有多个参数
        GenericClass.Add < int > (4, "zhu", 1.0);
        //object 是所有类型的父类
        GenericClass.ShowObject("132"); //ShowObject方法可以传入各种类型~~~string
        GenericClass.ShowObject(1231); //ShowObject方法可以传入各种类型~~~int
        GenericClass.ShowObject(DateTime.Now.Year); //ShowObject方法可以传入各种类型~~~DateTime
        GenericClass.ShowT < string > ("朱凯宾"); // public static void ShowT<SPara>(SPara tparameter)只要传入相对应的T
        GenericClass.ShowT < DateTime > (DateTime.Now);
        GenericClass.ShowTT < DateTime, int, string > (DateTime.Now, 100, "猪八戒");
        Console.WriteLine("**********泛型约束****************");
        //泛型约束声明后，类型参数必须满足约束
        //GenericConstaint.Get<int>(3);// 这样会报错，泛型约束where是class，class是引用类型，int是值类型
        // GenericConstaint.Get<string>("132");//string是引用类型，因为约束加了new(), 但是string类型是没有无参数构造的，所有会报错
        GenericConstaint.GetQuery < int > (123); //值类型
        //DateTime 是个结构体，不是引用类型
        GenericConstaint.GetQuery < DateTime > (DateTime.Now);
        People p = new People()
        {
            Id = 1,
            name = "我是people"
        };
        GenericConstaint.SayHi < People > (p);
        Console.ReadLine();
        //用泛型没有装箱和拆箱，所以没有性能损失
        //用object类型的时候会有拆箱和装箱~~~~~有性能损失
    }
}