泛型

// 泛型类------可以一个类型满足不同类型的需求---尖括号+占位符
public class ChildClass2: GenericAbstractClass<int>
{
    //可以已经指定为int类型
}
public class ChildClass : GenericAbstractClass<T> 
{
    //不行？子类不知道父类是什么类型，延迟声明
}
 
public class ChildClass1<S> : GenericAbstractClass<S>
{
    //可以--子类由父类决定
}
 
public class ChildClass2<S> 
{
    public S Show()
    {
      //  return new S();          //变量没有约束无法创建实例  S没指定
        return default(S);         //可以 ，返回的是类型
    }
    public S Show2(S s)
    {
        return s;                   //可以，返回的是参数
    }
}

/// <summary>
        /// 泛型方法   泛型方法----可以一个方法满足不同类型的需求
        /// </summary>
        /// <typeparam name="T">类型变量  类型参数</typeparam>
        /// <param name="tParameter"></param>
        public static void Show<T>(T tParameter)
        {
            Console.WriteLine($"This is {typeof(CommonMethod).Name},parameter={tParameter.GetType().Name},type={tParameter}");
        }
        /// <summary>
        /// 普通方法
        /// </summary>
        /// <typeparam name="T">类型变量  类型参数</typeparam>
        /// <param name="tParameter"></param>
        public static void Show(T tParameter)
        {
            //这样和普通方法一样了，括号里面前面是参数类型，后面是参数    所以在前面加<T> 表明这玩意是泛型
            Console.WriteLine($"This is {typeof(CommonMethod).Name},parameter={tParameter.GetType().Name},type={tParameter}");
        }

//interface
 public interface GenericInterfac<T>
 {
     public T Show();
 }
 GenericInterfac<string> sgenericInterfac = null;
 GenericInterfac<DateTime> dtgenericInterfac = null;
 //delegate
 public delegate T Genericdelegate<T>();
 Genericdelegate<string> sGenericdelegate = null;
 Genericdelegate<DateTime> dtGenericdelegate = null;

//泛型约束--要有真正的自由--就必须要有约束
//1.基类约束
// a.就是把类型参数当做People
// b.调用---就可以传递Popple或者People的子类型
// c.泛型约束：要么不让你进来，如果让你进来，就一定是没有问题

//2接口约束：
// a.把这个T 当做ISports
// b.就只能传递ISports 这个接口或者是实现过这个接口的类
// c.就可以增加功能，可以获取新的功能

//3引用类型约束
// a.就只能传递类型进来

//4.值类型约束
// a.就只能传递值类型进来

//5.无参数构造函数约束
// b.必须有一个无参数构造函数才能当做参数传入

//6.枚举约束
// a.必须是一个枚举类型才能传入

/// <summary>
/// 1.<strong>基类约束</strong>
///   a.就是把类型参数People 传入  限定现在的T的类型
///   b.调用---就可以传递Popple或者People的子类型
///   c.泛型约束：要么不让你进来，如果让你进来，就一定是没有问题
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="tParameter"></param>
public static void ShowBase<T>(T tParameter) where T : <strong>People</strong>
{
    Console.WriteLine($"People.Id={tParameter.Id}");
    Console.WriteLine($"People.Name={tParameter.Name}");
    //tParameter.Pingpang();
}    

    public static void ShowObject(object oParameter)
        {
            //Console.WriteLine("This is {0},parameter={1},type={2}",
            //    typeof(GenericConstraint), oParameter.GetType().Name, oParameter);  
            //传递一个实体对象：操作字段和数据 
            //问题：
            //1.无法去属性字段--因为oParameter是Object； C#是强类型语言，编译时决定参数是什么类型；
            //2.强制转换
            //Console.WriteLine($"People.Id={oParameter.Id}");
            //Console.WriteLine($"People.Name={oParameter.Name}"); 
            People people = (People)oParameter;
            Console.WriteLine($"People.Id={people.Id}");
            Console.WriteLine($"People.Name={people.bing}");
        }    
// oParameter 传入的不一定是people的实现，转换出问题，但是编译通过的，这个就是<strong>类型安全问题 </strong> 

/// <summary>
     /// <strong>接口约束</strong>：   2
     ///   a.把这个T 当做ISports
     ///   b.就只能传递ISports 这个接口或者是实现过这个接口的类
     ///   c.就可以增加功能，可以获取新的功能
     /// </summary>
     /// <typeparam name="T"></typeparam>
     /// <param name="tParameter"></param>
     public static void ShowInterface<T>(T tParameter) where T : ISports
     {
         tParameter.Pingpang();
     }
      //接口约束--
    {
        //GenericConstraint.ShowInterface<People>(people);
        GenericConstraint.ShowInterface<Chinese>(chinese);
        GenericConstraint.ShowInterface<Japanese>(japanese);
    }

/// <summary>
        /// <strong>引用类型约束   3</strong>
        ///    T就只能传递类型进来
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="tParameter"></param>
        public static void ShowClass<T>(T tParameter) where T : class
        {
            //T t = new T(); //因为T 可能没有无参数构造构造函数
        }
         {
         GenericConstraint.ShowClass<People>(people);       
         //GenericConstraint.ShowClass<int>(iValue); //因为Int 是结构--值类型
       }
        /// <summary>
        /// <strong>值类型约束   4</strong>
        ///  就只能传递值类型进来
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="tParameter"></param>
        public static void ShowStruct<T>(T tParameter) where T : struct
        {
            T t = new T();
        }
        //值类型约束
        {
            //GenericConstraint.ShowStruct<Chinese>(chinese);//应用类型--不行         
            GenericConstraint.ShowStruct<int>(iValue);       //因为Int  是Struct
            GenericConstraint.ShowStruct<DateTime>(dtValue); //因为DateTime  是Struct
        }

/// <summary>
        /// <strong>无参数构造函数约束</strong>
        ///    a.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="tParameter"></param>
        public static void ShowNew<T>(T tParameter) where T : new()
        {
            T t = new T();   //明确为值 可以直接实例化    <strong>必须有一个无参数构造函数才能当做参数传入</strong>
 
        }
        //无参数构造函数约束
        {
            GenericConstraint.ShowNew<People>(people);
        }

/// <summary>
    ///<strong> 枚举约束</strong>
    ///     a.必须是个枚举才能够传递进来
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="tParameter"></param>
    public static void ShowEnum<T>(T tParameter) where T : Enum
        {
              
        }