1_索引器
（1）索引器是C#中一个强大而实用的特性，允许像访问数组一样访问类的成员
（2）索引器：一种可以让我们使用索引来访问对象的一种方法，是一组get,set访问器，与属性类似，但不同，索引器使用索引运算符[]而非点运算符.访问
（3）格式：public 返回值类型，this[索引器数据类型 索引]
（4）获取数据使用get访问，获取数据时set执行
class ClassRoom
{
public string No { get; set; }
private List<Student> students= new List<Student>();
public void MyAdd(Student s)
{
students.Add(s);
}
public Student this[int index]
{
get
{
Console.WriteLine("index="+index);
return students[index];
}
set
{
Console.WriteLine("value=========" + value);
students[index] = value;
}
}
public Student this[string n]
{
get
{
/* for(int i = 0; i < students.Count; i++)
{
if (students[i].Name == n)
{
return students[i];
}
}
return null;*/
return students.Find(s => s.Name == n);
}
}
}2_接口
（1）接口：没有实现的合同，契约，规则，是定义一组成员，而不对成员进行实现的引用类型，只能被类和结构体所继承，类和结构体实现接口的时候，必须实现接口中定义的所有成员
（2）接口是一种规范，不具备存储数据和定义方法的能力，类和结构体继承这个接口就要以这个接口为准，进行一一实现，具体怎么实现由类和结构体决定
（3）接口：规则，指定应该有什么；类和结构体：实现规则，具体应该有什么
（4）接口一般以I开头：格式：interface 接口的名称{成员}
（5）接口成员不能加访问修饰符，方法不能有方法体
（6）：的作用：类的继承、接口的实现
（7）类的实现中，可以拥有更多的成员，但不能少
（8）当父类已经实现了接口，当子类再次继承咸通的接口，子类可以不用实现接口成员，也可以重写
（9）当基类和接口拥有相同的属性名和方法的时候，派生类不需要自己实现，也可以使用new关键字重新实现
interface IPeople
{
string Name { get; set; }
char Sex { get; set; }
int Age { get; set; }
}
interface IStudnt
{
string StudentNo { get; set; }
int Age { get; set; }
}
class People : IPeople, IStudnt
{
public string Name { get; set; }
public string StudentNo { get; set; }
public int Age { get; set; }
public char Sex { get; set; }
}
//父类已经实现了接口，子类再次继承相同接口可以不需要实现接口成员，也可以重写，
//当基类和接口中拥有同名的属性和方法的时候，派生类不需要自己实现，也可以使用new关键字重新实现
class Student : People, IStudnt
{
//重新实现
public new int Age { get; set; }
}3_多接口
（1）当一个类实现了多个接口的时候，如果多个接口拥有相同的属性，只需要实现一个即可
（2）如果多个接口拥有不同类型但数据名相同的属性，需要显示实现接口中的属性；显示实现接口，不需要也不能添加访问修饰符，访问这个成员的时候需要将对象标记为对应的接口类型
（3）因为方法可以重载，所以直接重载两个接口中的方法即可
internal class Program
{
static void Main(string[] args)
{
Test test = new Test();
// test.C
IA t1 = new Test();
t1.C = 12;
}
}
interface IA
{
string A { get; set; }
string B { get; set; }
int C { get; set; }
void Fn(int v);
}
interface IB
{
string B { get; set; }
string C { get; set; }
string D { get; set; }
void Fn(string v);
}
class Test : IA, IB
{
public string A { get; set; }
//当一个类实现了多个接口的时候，如果多个接口拥有相同的属性，只需要实现一个即可
public string B { get; set; }
//如果多个接口拥有不同类类型但是名称相同的属性，需要显示实现接口中的属性
//显式实现接口 不需要也不能添加访问修饰符 这个成员的访问,需要将对象标记为对应的接口类型
int IA.C { get; set; }
string IB.C { get; set; }
public string D { get; set; }
//因为方法可以重载,所有直接重载两个接口中的方法即可
public void Fn(int v)
{
}
public void Fn(string v)
{
}
}4_接口的继承
（1）一个类实现一个接口的时候，如果接口(B)继承了另一个接口(A)，这个类就必须实现A和B里面的所有成员
（2）接口与抽象类的异同
①：相同点：1、抽象类和接口都不能实例化 2、都可以包含未实现的方法，有派生类实现
②：不同点：
抽象类可以包含非抽象方法，接口不能包含抽象成员
一个类只能继承一个抽象类，但可以实现多个接口
抽象类的派生类需要使用override覆写类的成员，接口派生直接覆写
抽象类包含访问修饰符，接口不能有访问修饰符
抽象类可以包含属性，方法字段；接口可以包含属性和方法
5_泛型
（1）泛型：不固定数据类型，广泛的类型，泛型可以让不同数据类型支持相同的业务逻辑
（2）默认情况下在定义方法时就需要指定类型，通过泛型可以把指定类型延迟到方法调用的时候
（3）泛型方法：在方法名后面添加<>，里面相当于类型的形参列表
（4）泛型的命名规范：以T开头的单词，尽量表达出这个类型的作用，如果使用一个单词作为方法，建议使用T
（5）泛型方法在调用的时候指定数据类型，方法的返回值也可以用泛型；再调用方法的时候，泛型的指定可以省略，C#会自动根据实参推断类型
Fn<int>(123);//明确23<T>的数据类型.
Fn<string>("aaaaa");
Fn<bool>(true);
//类型的指定是可以省略的，C#会自动根据实参推断类型
Fn(123);
Fn("4444");
public static void Fn<T>(T i)
{
Console.WriteLine(i);
}
//返回值也可使用泛型
public static T Fn1<T>(T i, T[] arr)
{
return i;
}
public static Test1 Fn2<Test1,Test2>(Test1 i, Test2[] arr)
{
return i;
}
public static int Fn3<Test1, Test2>(Test1 i, Test2[] arr)
{
return 1;
} 6_泛型的使用
（1）泛型类：Cal3c<T> : ICalc<T>泛型接口中的泛型的类型，使用的是泛型类中定义的类型（即泛型是什么类型，接口就是什么类型）
（2）default 默认的，default（T）得到T的默认值
（3）泛型方法在调用的时候指定类型；泛型接口在实现的时候指定类型；泛型类实例化的时候指定类型
class Cal3c<T> : ICalc<T>
{
public T Add(T a, T b)
{
//return a + b;//报错，
//T 未知类型，指所有的类型，并不是所有的数据类型都重载了+运算符，所以报错
//default 默认的 default(T)得到T的默认值
return default(T);
}
public T Sub(T a, T b)
{
throw new NotImplementedException();
}
}7_泛型的约束
（1）声明泛型方法，泛型接口，泛型类的时候，可以通过添加约束让这个泛型不那么广泛
（1）where T:struct 约束 T只能是值类型
public static void Fn2<T>(T v)where T:struct{}（2）where T: calss 约束T只能是引用类型
public static void Fn3<T>(T v) where T : class{}（3）where T ：new() 约束泛型必须是一个类，并拥有无参构造方法
public static void Fn4<T>(T v) where T : new(){}（4）where T : Peopele 约束泛型只能是这个类或者这个类的子类
public static void Fn5<T>(T v) where T : People{}（5）where T : IPeople 约束泛型必须是实现了这个接口类或者这个类的子类
public static void Fn6<T>(T v) where T : IPeople