泛型
// 泛型类------可以一个类型满足不同类型的需求---尖括号+占位符
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.基类约束
/// 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 : People
{
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的实现，转换出问题，但是编译通过的，这个就是类型安全问题
/// <summary>
/// 接口约束： 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>
/// 引用类型约束 3
/// 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>
/// 值类型约束 4
/// 就只能传递值类型进来
/// </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>
/// 无参数构造函数约束
/// a.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="tParameter"></param>
public static void ShowNew<T>(T tParameter) where T : new()
{
T t = new T(); //明确为值 可以直接实例化 必须有一个无参数构造函数才能当做参数传入
}
//无参数构造函数约束
{
GenericConstraint.ShowNew<People>(people);
}
/// <summary>
/// 枚举约束
/// a.必须是个枚举才能够传递进来
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="tParameter"></param>
public static void ShowEnum<T>(T tParameter) where T : Enum
{
}
