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

当前位置:

首页 > temp > C#教程 >

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>理解程序设计的时候，固定的部分写死，不固定部分，通过事件封装出去。

原文链接：https://www.cnblogs.com/dfcq/p/13205089.html

栏目列表