3.5（接口，结构，泛型委托和泛型约束，多线程的调用与挂起）

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);
        }
    }