1.接口（将类的设计内容进行实现；类似与抽象类）（接口类似与模板）
1.格式：修饰符 interface 接口名称：接口列表{接口内容}
（其中接口列表是指包含多个接口）
2.规定 1.接口的成员是抽象的
2.为不同的类提供通用的功能
3.接口成员包括 方法、属性、索引器、事件，不包含字段（成员变量）
4.继承接口的所有非抽象类都必须实现接口的所有成员
5.接口不能被实例化，只能被类或者是结构所继承
6.接口本身也可以被继承，并且支持多重继承，一对多的继承
7.当继承接口的类采用显性方式实现接口成员时，只能采用接口引用访问类中实现的接口成员。（下例子）
class Program
{
public interface IA { void FunA(); } public interface IB { void FunB(); } public interface IC : IA ,IB { void FunC(); }
} class A : IC { public void FunA(){ } //隐性实现：格式：public 接口里的方法 {} void IC.FunC() { Console.WriteLine("FunC");} //显性实现：格式：接口名字 接口里的方法{}
public void FunB(){ Console.WriteLine("FunB"); } //IC下的成员的继承方法里的成员只能用隐性实现
}
8.只有sealed和abstract不能使用，其他5个关键字都可以使用
9.抽象方法互相继承不同实现
10.非抽象类继承接口实现
3.接口引用（概念：用接口变量对继承该接口类的对象实例；作用：对于显性实现必须用接口引用才能调用接口成员）
static void Main(string[] args) { A a = new A(); a.FunA(); //该类为隐性实现，可直接实例化方法在调用 a.FunB(); IC ic = a; //该类为显性实现，必须先将继承改接口的对象实例，然后才能将其实例化 ic.FunC(); }
4.系统自带的接口：1.IComparble（用于排序） 2.IComparer（用于比较两个对象） 3.IEumerable（链表都是继承于它）
5.泛型接口：
public interface ID<T> { void FunD(T x,T y); }
class A : ID<int> { public void FunD(int x, int y) { } //隐性实现泛型接口
void ID<int>.FunD(int x, int y) { } //显性实现泛型接口
}
2.结构（关键字struct）（具体结构如下）
public struct（其成员不能被初始化）/class（其成员可以被初始化） Infor { public string name; //结构体的变量不能初始化 public byte age; public string rexual; public string nation; public Infor(string name, byte age, string rexual, string nation) { this.name = name; //构造函数的变量可以初始化 this.age = age; this.rexual = rexual; this.nation = nation; } }
1.格式：修饰符 struct 名称
2.规定：1.结构不能被继承，所以不能用抽象（abstract），密封（sealed），保护（protected）
2.结构体里的变量不可以被初始化；构造函数里的值可以初始化
3.struct属于值类型；class属于引用类型
4.结构类实例化可以砽new
3.泛型结构：1.格式：修饰符 struct 名称<T>{内容;}
3.泛型委托和泛型约束
（1）.泛型委托
//委托
static void Main(string[] args) { Program pro = new Program(); EventDele eventDele = new EventDele(pro.Fun); eventDele("Fun"); }
void Fun(string str) { Console.WriteLine(str); }
//泛型委托
static void Main(string[] args) { Program pro = new Program(); _EventDele<int> _eventDele = new _EventDele<int>(pro._Fun); _eventDele(5); } int _Fun(int str) { Console.WriteLine(str); return 0; }
（2）.泛型约束
1.格式：类修饰符 class 泛型类名称<类型参数表> where 类型参数名称:约束{ 类体；}
2.基类约束：class A<T> where T : Program //基类 { }
3.值类型和引用类型约束 struct class
1.class A1<T> where T : struct//值类 { }
2.class A2<T> where T : class//引用类 { }
4.接口约束：class A3<T> where T : IComparable //系统自带（自创）接口 { }
5.构造函数约束 new() ： class A4<T> where T : new()//关键符号 { }
6.混合约束：要求：基类约束不能和值/引用类型同时使用，其他的都可以
class A5<T1,T2> where T1 : struct,IList<T1> where T2 : class,new() {}
4.多线程的调用与挂起
1.创建线程
2.实例化创建
3.启动线程
4.销毁线程
5.线程消息状态
6.线程挂起
7.学习一步线程，线程池，线程=>（就像一个人运作一个线程）
8.unity不支持多线程，其里面的线程原理就好比（一个人运作多个线程）
class Program { Thread Thread_TestTimer; Thread Thread_LoopPrintf; Thread Thread_OnePrintf; int Sec = 0; static void Main(string[] args) { //异步线程 线程池 线程 Program pro = new Program(); pro.Thread_TestTimer = new Thread(new ThreadStart(pro.Thread1)); pro.Thread_TestTimer.Start(); //while (true) //{ // pro.Thread3(); // Thread.Sleep(5000); //} pro.Thread_LoopPrintf = new Thread(new ThreadStart(pro.Thread2)); pro.Thread_LoopPrintf.Start(); //pro.Thread_OnePrintf = new Thread(new ThreadStart(pro.Thread2)); //pro.Thread_OnePrintf.Start(); } void Thread1() { while (true) { Thread.Sleep(500); ++Sec; Console.WriteLine("辅助线程：计时每隔一秒更新一次,当前秒数计时:{0}",Sec); if (Thread_TestTimer.IsAlive && Sec > 20) Thread_TestTimer.Abort(); } } void Thread2() { while (true) { Thread.Sleep(2000); Console.WriteLine("每隔两秒打印该文本一次"); } } void Thread3() { ++Sec; Console.WriteLine("主线程：计时每隔一秒更新一次,当前秒数计时:{0}", Sec); } }
