泛型可以作用于类,结构和函数,之所以使用泛型,是为了用一种类,结构或函数,能处理不同的输入对象,而不用重复编写代码,从而提高代码的重用率
而输入的这个对象,就要T来泛指,也就是泛型。
泛型类与普通类的简单对比
泛型类的比一般类效率更高,因为没有装箱和拆箱操作
库中的泛型类
System.Collections; 空间中的 ArrayList 类;与 System.Collections.Generic; 空间中的 List<T>
普通类
var Alist = new ArrayList();
Alist.Add(1); // 向 List 增加 数据1,分配内存,装箱操作(将值类型(栈空间数据)变为引用类型(堆空间))
Alist.Add("hello"); //ArrayList 类支持不同类型变量的添加
int i = (int) Alist[0]; // 从List 取得第0个数据,拆箱操作
String a = (String ) Alist[1]; //从这里可以看到有风险,如果1位置加入的不是 String 类型,那就会出错
泛型类
var Blist = new List<int>(); //初始化时限定只能加入 int类型
Blist.Add(1); //无装箱操作,为什么没有,不清楚哈哈
int i = Blist[0];//无拆箱操作
//对于不同的类型
var Blist = new List<String>;
Blist.Add("hehe"); //无装箱操作,为什么没有,不清楚哈哈
String a = Blist[0];//因为类型被限定 所以此处无风险了
创建泛型类
//创建泛型类
public class C_A<T>{
public T Value{get; set}; //T 类型的属性
public T Fuc(){
T a = default; // 创建T类型时 怎么初始化,因为T类型未知用 0(初始化值类型),用 null(初始化引用类型),都不好,C#提供default 操作,避免这种尴尬,在运行时自动确定。
...
}
}
对T的约束
where T : struct; // T 必须是值类型
where T : class; // T 必须是引用类型
where T : Inf; //必须实现接口
where T : Foo; //必须派生自Foo
where T : new();//必须有构造函数,可以使用new方法
where T1 : T2 //派生自泛型类型T2
public interface Inf_A{
public void FuncA();
public void FuncB();
}
public class C_A<T>
where T : Inf_A, new() //必须实现接口a 并且必须有默认构造函数
{
private T value;
public C_A(T value) { //构造函数
this.value = value;
}
public void FuncA(){ //实现接口a 函数
}
public void FuncB(){ //实现接口a 函数
}
}
泛型的继承
泛型继承泛型
public class Base<T>{
}
public class Class_A<T> : Base<T>{
}
泛型继承泛型类的具体类实现
public class Base<T>{
}
public class Class_A<T> : Base<int>{ //Base 里面放了特点类
}
普通类继承泛型类的具体类实现
public class Base<T>{
}
public class Class_B : Base<int>{ //Base 里面放了特点类
}
泛型的静态成员
public class Base<T>{
public static int a; //a 是泛型类的静态成员
}
var m = Base<int>; //创建一个静态成员a,输入泛型类的int实现
var n = Base<string>; //再创建一个静态成员a,属于泛型类的string 实现
var o = Base<int>; //不再创建静态成员,因为 m 已经创建过输入 int 泛型实现的 静态成员
泛型应用在接口
接口定义方法和属性,但不实现
类继承泛型接口并实现其方法
public interface Inf_A<T>{
void func(T a); //定义方法 注意:接口没有访问修饰符
int A{get;set}; //定义属性
}
public class Class_A : Base<T>{
public void func(T a) //实现方法
{
}
public int A{get;set}; //实现属性
}
接口的协变与抗变(in/out)
//首先定义一个泛型接口
public interface Inf_A<T>{
}
//然后定义一个父类
public class Class_Base{
}
//然后定义一个子类继承父类
public class Class_extern : Class_Base{
}
//然后定义一个类继承自这个接口
public class Class_Handel: Inf_A<>{
}
//创建一个父类的接口实例
Inf_A<Class_Base> A = new Class_Handel(); //因为Class_Handel类继承自接口,所以可以被接口引用
//创建一个子类的接口实现; 并父类的接口实现付给子类
Inf_A<Class_extern> B = A; //也就是说此时 B 作为扩展类被父类萎缩赋值,这时编译器不支持
//当把接口定义改为 public interface Inf_A<in T>时,编译器就不报错了,这就叫抗变,也叫逆变
反过来
//创建一个子类的接口实例
Inf_A<Class_extern> A = new Class_Handel();
//创建一个父类的接口实现; 将子类的接口实现付给父类
Inf_A<Class_Base> B = A; //也就是说此时 B 作为父类被子类赋值属于扩充赋值,这时编译器也不支持
//当把接口定义改为 public interface Inf_A<out T>时,编译器不报错了,这就叫协变