抽象类、接口、委托

抽象类：提供了部分功能的实现，不能被实例化的类，

              除了不能被实例化和含有抽象方法，其余使用和正常类使用一样。

特点：不能被实例化

             抽象类里面可以包含抽象方法，这个方法子类必须实现，而且本类不能使用

             子类要实现抽象方法必须使用关键字override。

//抽象类 不能被实例化
    public abstract class NPC
    {
        //抽象类里面可以包含抽象方法：子类必须实现的方法，但是本类不能使用
        public abstract void Say();
    }
    public class Yihao : NPC
    {
        //要实现抽象方法必须要使用重写的override
        public override void Say()
        {
        }
    }
    
    class Program
    {
        static void Main(string[] args)
        {
            NPC npc = new Yihao();

            Console.ReadKey();
        }
    }

 

接口：同样不能被实例化，包含的方法必须在继承该接口的类上实现，一个类可以继承多个接口，

          C#通过接口实现多继承的问题。

特点：不能被实例化

           接口的方法必须实现

            接口中不能写public，因为接口中的方法默认都是public

            接口可以被继承

            接口中也可以实现多态

 //抽象类 不能被实例化
    public abstract class NPC
    {
        //抽象类里面可以包含抽象方法：子类必须实现的方法，但是本类不能使用
        public abstract void Say();
    }

    //接口 接口里面不能写变量，只能写方法,接口里面的方法必须实现
    public interface Enemy
    {
        //不能加public,因为接口中所有的方法都是public
        void GetHit();
    }
    //接口是可以继承的
    public interface Boss : Enemy
    {
        void Skill();
    }

    public class Yihao : NPC,Enemy,Boss
    {
        //要实现抽象方法必须要使用重写的override
        public override void Say()
        {
        }
        //实现接口
        public void GetHit()
        {
        }

        public void Skill()
        {
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Yihao yh = new Yihao();
            NPC npc = yh;
            //接口也可以实现多态
            Boss boss = yh;
            boss.GetHit();
            boss.Skill();


            Console.ReadKey();
        }
    }

 

委托：int是保存整数的变量类型，float是保存浮点数的变量类型

          委托是保存方法的变量类型

特点：public delegate void Func(int a); 参数类型和数量要一致

        委托里面可以保存多个方法，当我们保存多个方法的时候，会一次调用所有方法

public class Person
    {
        //创建一个委托类型 要求：返回值为void，有一个参数为int类型的方法
        //public delegate void(int a) Func;
        //注意：这里的a是随意取的名称，重要的参数的类型和数量int a
        //（）里面是写的是保存的方法名
        public delegate void Func(int a);
        //通过刚才创建的委托类型，声明一个委托
        public Func func;

        public Person()
        {
            //Say(2);

            //让func保存Say方法
            //第一种
            //func = new Func(Say);
            //我们以后可以直接用委托调用方法
            //第二种 func保存了一个Say方法
            func += Say;
            func += Eat;
            func(2);
            //委托里面可以保存多个方法，当我们保存多个方法的时候，会一次调用所有方法
            //func -=Eat；
            //委托解决的是回掉问题
        }
        public void Say(int a)
        {
            Console.WriteLine("11111111111111");
        }
        public void Eat(int b)
        {
            Console.WriteLine("22222222222222");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Person person = new Person();

            Console.ReadKey();
        }
    }