C#通过完整的例子，Get常用的2个套路，理解抽象方法，虚方法，接口，事件

一.理解：抽象方法，虚方法，接口，事件

描述：

1.定义一个抽象父类“People”：

要求：

1>3个属性：名字，性别，年龄；

2>一个普通方法“说话”;

3>2个抽象方法：“喜欢什么”，“会做什么”

4>1个虚方法“母语”

5>定义一个接口，用于唱歌

2.分别创建3个子类：学生，老师，校长

要求：都继承抽象类People，而且都实现唱歌接口，老师覆写虚方法“母语”

3.每个子类都有自己独有的才艺，提供一个方法功能如下：

打印“开始表演才艺”

执行具体才艺

打印“才艺表演结束，大家鼓掌！！”

意义： 抽象类，虚方法

4.定义事件

要求：

抽象类中定义一个事件，模拟“发财了”。提供一个设置金钱的方法，默认1000作为触发条件，但老师需要1,0000触发，校长需要10,0000触发

意义：  理解观察者模式，理解事件的发布/触发，事件的观察者(订户)，事件的订阅

5.新增一个“明星子类”

要求：

“明星”子类中，定义三个事件：表演开始/表演高潮/表演结束;

然后新增一个Show方法: 依次调用->说话->触发表演开始事件->喜欢什么->会做什么->触发表演高潮事件->才艺->触发表演结束事件

意义：理解事件的流程封装扩展的意义

一.搭建程序

自己新建一个工程，按照下图建好框架，拷贝下面的对应类即可

People类：中有2个常用的套路

常用套路1：

封装Skill的时候，用到了套路1

★★★适用情形：子类大部分动作都相同，个别不同的情况：

父类定义一个方法Skill()，大部分相同动作放Skill中；不同的动作在父类中做成一个抽象方法或者虚方法SelfSkill()，让各个子类去实现。

 常用套路2：

模拟“发财了”。提供一个设置金钱的方法，做这个的时候又套路1,2,3中方式供选择

1>小套路1：Poeplez中定义一个 虚方法SetMoney，然后子类Teacher和Schoolmaster需要重载这个虚方法，然后子类虚方法里面设置不同的金额来触发GetRich事件

2>小套路2：把金钱在People中，定义为字段 protected int Money = 1000;，然后Teacher和Schoolmaster的构造函数中，重新对这个字段赋值即可

3>小套路3：在People中，定义一个委托判断条件，protected Func<int, bool> FuncJudge = i => i > 1000;，然后Teacher和Schoolmaster的构造函数中，重写委托即可

using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Policy;
using System.Text;
using System.Threading.Tasks;

namespace Self.Interface
{
    public abstract class People
    {
        //4.定义事件
        //抽象类中定义一个事件，模拟“发财了”。提供一个设置金钱的方法，默认1000作为触发条件，但老师需要1,0000触发，校长需要10,0000触发
        //套路：提供3中类型的套路
        protected int Money = 1000;//套路2 把金钱做成字段，构造函数时候初始化
        protected Func<int, bool> FuncJudge = i => i > 1000;//套路3 委托判断条件

        public event Action GetRich;//发财了时间
        public virtual void SetMoney(int monry)
        {
            //if (monry >= 1000)//套路1 虚方法重载
            //if (monry >= Money)//套路2 把金钱做成字段，构造函数时候初始化
            if (FuncJudge.Invoke(monry))//套路3 委托判断条件
            {
                FireGetRich();
            }
        }
        /// <summary>
        /// 触发发财了事件
        /// </summary>
        protected void FireGetRich()
        {
            GetRich?.Invoke();
        }
        public string Name { get; set; }
        public string Age { get; set; }
        public string Gender { get; set; }
        public void Speak()
        {
            Console.WriteLine("我是抽象父类方法：现在我开始说话！");
        }
        public abstract void Like();
        public abstract void ICanDo();
        public virtual void MotherTongue()
        {
            Console.WriteLine("我是抽象类：我的母语是汉语");
        }
        /// <summary>
        /// 3.每个子类都有自己独有的才艺，提供一个方法功能如下：
        /// 打印“开始表演才艺”
        /// 执行具体才艺
        /// 打印“才艺表演结束，大家鼓掌！！”
        /// 
        /// 常用的套路1：
        /// ★★★适用情形：子类大部分动作都相同，个别不同的情况：
        /// 父类定义一个方法Skill()，大部分相同动作放Skill中；不同的动作在父类中做成一个抽象方法或者虚方法SelfSkill()，让各个子类去实现。
        /// </summary>
        public void Skill()
        {
            Console.WriteLine("开始表演才艺");
            this.SelfSkill();
            Console.WriteLine("才艺表演结束，大家鼓掌！！");
        }
        protected abstract void SelfSkill();//这里注意 受保护的protected 和每个子类都必须实现的abstract
    }
}

Sing类

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Self.Interface
{
    public interface ISing
    {
        void Sing();
    }
}

4个子类

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Self.Interface;

namespace Self.Service
{
    public class Schoolmaster : People, ISing
    {
        public Schoolmaster()
        {
            base.Money = 100000;//2 把金钱做成字段，构造函数时候初始化
            FuncJudge = i => i >= 100000;//套路3 委托判断条件
        }
        public override void Like()
        {
            Console.WriteLine("我喜欢看广场舞！");
        }
        public override void ICanDo()
        {
            Console.WriteLine("我会管理学校");
        }
        public void Sing()
        {
            Console.WriteLine("开始唱:我的中国心！");
        }
        protected override void SelfSkill()
        {
            Console.WriteLine("我会拉小提琴");
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Self.Interface;

namespace Self.Service
{
    public class Teacher : People, ISing
    {
        public Teacher()
        {
            base.Money = 10000;//2 把金钱做成字段，构造函数时候初始化
            FuncJudge = (i) => i >= 10000;//套路3 委托判断条件
        }
        public override void Like()
        {
            Console.WriteLine("我喜欢科研");
        }
        public override void ICanDo()
        {
            Console.WriteLine("我可以教学");
        }
        public void Sing()
        {
            Console.WriteLine("开始唱:新贵妃醉酒！");
        }
        public override void MotherTongue()
        {
            Console.WriteLine("我是老师，我的母语是英语！");
        }
        protected override void SelfSkill()
        {
            Console.WriteLine("我会跳拉丁舞");
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Self.Interface;

namespace Self.Service
{
    public class Student : People, ISing
    {
        public override void ICanDo()
        {
            Console.WriteLine("我会写作业！");
        }

        public override void Like()
        {
            Console.WriteLine("我喜欢打游戏");
        }

        public void Sing()
        {
            Console.WriteLine("开始唱：我的滑板鞋！");
        }
        protected override void SelfSkill()
        {
            Console.WriteLine("我会打王者荣耀！");
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Self.Interface;


namespace Self.Service
{
    public class Star : People, ISing
    {
        public event Action StartOn;
        public event Action HightOn;
        public event Action EndOn;
        /// <summary>
        /// ★★★目的：理解事件的流程封装扩展的意义
        ////封装框架的时候，固定的业务都封装好，开放出扩展点封装成事件；让用户自己定义逻辑。类似于事件的按钮情况
        ///也可以理解为：程序设计的时候，固定部分写死，不固定部分通过一个事件封装出去。
        /// </summary>
        public void Show()
        {
            base.Speak();//固定部分写死

            this.StartOn?.Invoke();//不固定部分，通过事件逻辑

            this.Like();
            this.ICanDo();

            this.HightOn?.Invoke();

            this.Sing();

            this.EndOn?.Invoke();
        }
        public override void ICanDo()
        {
            Console.WriteLine("我会演戏");
        }

        public override void Like()
        {
            Console.WriteLine("我喜欢表演");
        }

        public void Sing()
        {
            Console.WriteLine("开始唱：我爱我的祖国");
        }

        protected override void SelfSkill()
        {
            Console.WriteLine("我一秒钟能哭出来");
        }
    }
}

主程序类

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Self.Service;
using Self.Interface;

namespace 自己模仿写的例子
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("********************teacher************************");
            People teacher = new Teacher()
            {
                Name = "苍井空",
                Age = "33",
                Gender = "女",
            };
            teacher.GetRich += () => { Console.WriteLine("我发财了！！"); };//当设置金钱>=10000的时候，执行这个lambda表达式
            teacher.Like();
            teacher.ICanDo();
            teacher.MotherTongue();
            teacher.Skill();
            teacher.SetMoney(10);
            teacher.SetMoney(10000);
            Console.WriteLine("**********************Student**********************");
            Student student = new Student()
            {
                Name = "无名小辈",
                Age = "22",
                Gender = "男"
            };
            student.Like();
            student.ICanDo();
            student.MotherTongue();
            student.Skill();
            Console.WriteLine("**********************star**********************");
            Star star = new Star()
            {
                Name = "颖宝宝",
                Age = "28",
                Gender = "女",
            };
            star.StartOn += () => { Console.WriteLine("主持人讲话了，大家安静了，明星即将开始表演了"); };
            star.HightOn += () => { Console.WriteLine("主持人讲话了，明星表演的精彩吧！"); };
            star.EndOn += () => { Console.WriteLine("主持人讲话了，明星表演结束了，大家鼓掌！！"); };
            star.Show();
            Console.ReadKey();
        }
    }
}

二.抽象方法和虚方法的区别

下图中，调用虚方法MotherTongue()的时候，学生类没有重写这个方法，就调用父类的MotherTongue()；老师类重写了虚方法MotherTongue，调用的时候就调用重写的方法。

目的：

1>父类的虚方法，子类想重写就重写，不行重写就算了。调用的时候，子类有重写就调用子类重写的虚方法，没有重写就调用父类虚方法。

2>父类的抽象方法，子类必须都得重写，不管子类愿不愿意，都必须重写的。

 三.理解程序封装的思想

实例化一个明星类，然后调用Show()，固定部分写死了，不固定的部分通过事件封装出去了，让用户去实现业务逻辑。

从图中可以看到，当Show()方法遇到事件的时候，就去执行用户定义的事件逻辑了，执行完用户定义的逻辑，再继续往下继续执行。

目的：

1>理解程序设计的时候，固定的部分写死，不固定部分，通过事件封装出去。