浅谈C# 多态的法力
前言：咱们都知道面向对象的三大特性：封装，继承，多态。封装和继承对于初学者而言比较好理解，但要理解多态，尤为是深刻理解，初学者每每存在有不少困惑，为何这样就能够？有时候感受很难以想象，由此，面向对象的魅力体现了出来，那就是多态，多态用的好，能够提升程序的扩展性。经常使用的设计模式，好比简单工厂设计模式，核心就是多态。编程
其实多态就是：容许将子类类型的指针赋值给父类类型的指针。也就是同一操做做用于不一样的对象，能够有不一样的解释，产生不一样的执行结果。在运行时，能够经过指向基类的指针，来调用实现派生类中的方法。若是这边不理解能够先放一放，先看下面的事例，看完以后再来理解这句话，就很容易懂了。
理解多态以前首先要对面向对象的里氏替换原则和开放封闭原则有所了解。设计模式
里氏替换原则（Liskov Substitution Principle）：派生类（子类）对象可以替换其基类（超类）对象被使用。通俗一点的理解就是“子类是父类”，举个例子，“男人是人，人不必定是男人”，当须要一个父类类型的对象的时候能够给一个子类类型的对象；当须要一个子类类型对象的时候给一个父类类型对象是不能够的！数组
开放封闭原则（Open Closed Principle）：封装变化、下降耦合，软件实体应该是可扩展，而不可修改的。也就是说，对扩展是开放的，而对修改是封闭的。所以，开放封闭原则主要体如今两个方面：对扩展开放，意味着有新的需求或变化时，能够对现有代码进行扩展，以适应新的状况。对修改封闭，意味着类一旦设计完成，就能够独立完成其工做，而不要对类进行任何修改。ide
对这两个原则有必定了解以后就能更好的理解多态。函数
咱们都知道，喜鹊（Magpie）、老鹰（Eagle）、企鹅（Penguin）都是属于鸟类，咱们能够根据这三者的共有特性提取出鸟类（Bird）作为父类，喜鹊喜欢吃虫子，老鹰喜欢吃肉，企鹅喜欢吃鱼。优化
建立基类Bird以下，添加一个虚方法Eat():ui
/// <summary>
/// 鸟类：父类
/// </summary>
public class Bird
{
/// <summary>
/// 吃：虚方法
/// </summary>
public virtual void Eat()
{
Console.WriteLine("我是一只小小鸟，我喜欢吃虫子~");
}
}
建立子类Magpie以下，继承父类Bird，重写父类Bird中的虚方法Eat()：this
/// <summary>
/// 喜鹊：子类
/// </summary>
public class Magpie:Bird
{
/// <summary>
/// 重写父类中Eat方法
/// </summary>
public override void Eat()
{
Console.WriteLine("我是一只喜鹊，我喜欢吃虫子~");
}
}
建立一个子类Eagle以下，继承父类Bird，重写父类Bird中的虚方法Eat()：spa
/// <summary>
/// 老鹰：子类
/// </summary>
public class Eagle:Bird
{
/// <summary>
/// 重写父类中Eat方法
/// </summary>
public override void Eat()
{
Console.WriteLine("我是一只老鹰，我喜欢吃肉~");
}
}
建立一个子类Penguin以下，继承父类Bird，重写父类Bird中的虚方法Eat()：设计
/// <summary>
/// 企鹅：子类
/// </summary>
public class Penguin:Bird
{
/// <summary>
/// 重写父类中Eat方法
/// </summary>
public override void Eat()
{
Console.WriteLine("我是一只小企鹅，我喜欢吃鱼~");
}
}
到此，一个基类，三个子类已经建立完毕，接下来咱们在主函数中来看下多态是怎样体现的。
static void Main(string[] args)
{
//建立一个Bird基类数组，添加基类Bird对象，Magpie对象，Eagle对象，Penguin对象
Bird[] birds = {
new Bird(),
new Magpie(),
new Eagle(),
new Penguin()
};
//遍历一下birds数组
foreach (Bird bird in birds)
{
bird.Eat();
}
Console.ReadKey();
}
运行结果：
因而可知，子类Magpie，Eagle，Penguin对象能够赋值给父类对象，也就是说父类类型指针能够指向子类类型对象，这里体现了里氏替换原则。
父类对象调用本身的Eat()方法，实际上显示的是父类类型指针指向的子类类型对象重写父类Eat后的方法。这就是多态。
多态的做用究竟是什么呢？
其实多态的做用就是把不一样的子类对象都看成父类来看，能够屏蔽不一样子类对象之间的差别，写出通用的代码，作出通用的编程，以适应需求的不断变化。
以上程序也体现了开放封闭原则，若是后面的同事须要扩展我这个程序，还想再添加一个猫头鹰（Owl），很容易，只须要添加一个Owl类文件，继承Bird，重写Eat()方法，添加给父类对象就能够了。至此，该程序的扩展性获得了提高，而又不须要查看源代码是如何实现的就能够扩展新功能。这就是多态带来的好处。
仍是刚才的例子，咱们发现Bird这个父类，咱们根本不须要使用它建立的对象，它存在的意义就是供子类来继承。因此咱们能够用抽象类来优化它。
咱们把Bird父类改为抽象类，Eat()方法改为抽象方法。代码以下：
/// <summary>
/// 鸟类：基类
/// </summary>
public abstract class Bird
{
/// <summary>
/// 吃：抽象方法
/// </summary>
public abstract void Eat();
}
抽象类Bird内添加一个Eat()抽象方法，没有方法体。也不能实例化。
其余类Magpie，Eagle，Penguin代码不变，子类也是用override关键字来重写父类中抽象方法。
Main主函数中Bird就不能建立对象了，代码稍微修改以下：
static void Main(string[] args)
{
//建立一个Bird基类数组，添加 Magpie对象，Eagle对象，Penguin对象
Bird[] birds = {
new Magpie(),
new Eagle(),
new Penguin()
};
//遍历一下birds数组
foreach (Bird bird in birds)
{
bird.Eat();
}
Console.ReadKey();
}
执行结果：
因而可知，咱们选择使用虚方法实现多态仍是抽象类抽象方法实现多态，取决于咱们是否须要使用基类实例化的对象.
好比说 如今有一个Employee类做为基类，ProjectManager类继承自Employee，这个时候咱们就须要使用虚方法来实现多态了，由于咱们要使用Employee建立的对象，这些对象就是普通员工对象。
再好比说 如今有一个Person类做为基类，Student，Teacher 类继承Person，咱们须要使用的是Student和Teacher建立的对象，根本不须要使用Person建立的对象，
因此在这里Person彻底能够写成抽象类。
总而言之，是使用虚方法，或者抽象类抽象方法实现多态，视状况而定，什么状况？以上我说的两点~
接下来~~~~
我要问一个问题，喜鹊和老鹰均可以飞，这个飞的能力，我怎么来实现呢？
XXX答：“在父类Bird中添加一个Fly方法不就行了~~”
我再问：“好的，照你说的，企鹅继承父类Bird，可是不能企鹅不能飞啊，这样在父类Bird中添加Fly方法是否是不合适呢？”
XXX答：“那就在能飞的鸟类中分别添加Fly方法不就能够了吗？”
对，这样是能够，功能彻底能够实现，但是这样违背了面向对象开放封闭原则，下次我要再扩展一个鸟类好比猫头鹰（Owl），我还要去源代码中看下Fly是怎么实现的，而后在Owl中再次添加Fly方法，相同的功能，重复的代码，这样是不合理的，程序也不便于扩展；
其次，若是我还要添加一个飞机类（Plane），我继承Bird父类，合适吗？
很显然，不合适！因此咱们须要一种规则，那就是接口了，喜鹊，老鹰，飞机，我都实现这个接口，那就能够飞了，而企鹅我不实现这个接口，它就不能飞~~
添加一个接口IFlyable，代码以下：
/// <summary>
/// 飞 接口
/// </summary>
public interface IFlyable
{
void Fly();
}
喜鹊Magpie实现IFlyable接口，代码以下：
/// <summary>
/// 喜鹊：子类，实现IFlyable接口
/// </summary>
public class Magpie:Bird,IFlyable
{
/// <summary>
/// 重写父类Bird中Eat方法
/// </summary>
public override void Eat()
{
Console.WriteLine("我是一只喜鹊，我喜欢吃虫子~");
}
/// <summary>
/// 实现 IFlyable接口方法
/// </summary>
public void Fly()
{
Console.WriteLine("我是一只喜鹊，我能够飞哦~~");
}
}
老鹰Eagle实现IFlyable接口，代码以下：
/// <summary>
/// 老鹰：子类实现飞接口
/// </summary>
public class Eagle:Bird,IFlyable
{
/// <summary>
/// 重写父类Bird中Eat方法
/// </summary>
public override void Eat()
{
Console.WriteLine("我是一只老鹰，我喜欢吃肉~");
}
/// <summary>
/// 实现 IFlyable接口方法
/// </summary>
public void Fly()
{
Console.WriteLine("我是一只老鹰，我能够飞哦~~");
}
}
在Main主函数中，建立一个IFlyable接口数组，代码实现以下：
static void Main(string[] args)
{
//建立一个IFlyable接口数组，添加 Magpie对象，Eagle对象
IFlyable[] flys = {
new Magpie(),
new Eagle()
};
//遍历一下flys数组
foreach (IFlyable fly in flys)
{
fly.Fly();
}
Console.ReadKey();
}
执行结果：
因为企鹅Penguin没有实现IFlyable接口，因此企鹅不能对象不能赋值给IFlyable接口对象，因此企鹅，不能飞~
好了，刚才我提到了飞机也能飞，继承Bird不合适的问题，如今有了接口，这个问题也能够解决了。以下，我添加一个飞机Plane类，实现IFlyable接口，代码以下：
/// <summary>
/// 飞机类，实现IFlyable接口
/// </summary>
public class Plane:IFlyable
{
/// <summary>
/// 实现接口方法
/// </summary>
public void Fly()
{
Console.WriteLine("我是一架飞机，我也能飞~~");
}
}
在Main主函数中，接口IFlyable数组，添加Plane对象：
class Program
{
static void Main(string[] args)
{
//建立一个IFlyable接口数组，添加 Magpie对象，Eagle对象，Plane对象
IFlyable[] flys = {
new Magpie(),
new Eagle(),
new Plane()
};
//遍历一下flys数组
foreach (IFlyable fly in flys)
{
fly.Fly();
}
Console.ReadKey();
}
}
执行结果：
由此，能够看出用接口实现多态程序的扩展性获得了大大提高，之后不论是再扩展一个蝴蝶（Butterfly），仍是鸟人（Birder）建立一个类，实现这个接口，在主函数中添加该对象就能够了。
也不须要查看源代码是如何实现的，体现了开放封闭原则！
接口充分体现了多态的魅力~~
以上经过一些小的事例，给你们介绍了面向对象中三种实现多态的方式，或许有人会问，在项目中怎么使用多态呢？多态的魅力在项目中如何体现？
那么接下来我作一个面向对象的简单计算器，来Show一下多态在项目中使用吧！
加减乘除运算，咱们能够根据共性提取出一个计算类，里面包含两个属性 Number1和Number2，还有一个抽象方法Compute();代码以下：
/// <summary>
/// 计算父类
/// </summary>
public abstract class Calculate
{
public int Number1
{
get;
set;
}
public int Number2
{
get;
set;
}
public abstract int Compute();
}
接下来，咱们添加一个加法器，继承计算Calculate父类：
/// <summary>
/// 加法器
/// </summary>
public class Addition : Calculate
{
/// <summary>
/// 实现父类计算方法
/// </summary>
/// <returns>加法计算结果</returns>
public override int Compute()
{
return Number1 + Number2;
}
}
再添加一个减法器，继承计算Calculate父类：
/// <summary>
/// 减法器
/// </summary>
public class Subtraction : Calculate
{
/// <summary>
/// 实现父类计算方法
/// </summary>
/// <returns>减法计算结果</returns>
public override int Compute()
{
return Number1 - Number2;
}
}
在主窗体FormMain中，编写计算事件btn_Compute_Click，代码以下：
private void btn_Compute_Click(object sender, EventArgs e)
{
//获取两个参数
int number1 = Convert.ToInt32(this.txt_Number1.Text.Trim());
int number2 = Convert.ToInt32(this.txt_Number2.Text.Trim());
//获取运算符
string operation = cbb_Operator.Text.Trim();
//经过运算符，返回父类类型
Calculate calculate = GetCalculateResult(operation);
calculate.Number1 = number1;
calculate.Number2 = number2;
//利用多态，返回运算结果
string result = calculate.Compute().ToString();
this.lab_Result.Text = result;
}
/// <summary>
/// 经过运算符，返回父类类型
/// </summary>
/// <param name="operation"></param>
/// <returns></returns>
private Calculate GetCalculateResult(string operation)
{
Calculate calculate = null;
switch (operation)
{
case "+":
calculate = new Addition();
break;
case "-":
calculate = new Subtraction();
break;
}
return calculate;
}
在该事件中主要调用GetCalculateResult方法，经过运算符，建立一个对应的加减乘除计算器子类，而后赋值给父类，其实这就是设计模式中的简单工厂设计模式，我给你一个运算符你给我生产一个对应的加减乘除计算器子类，返回给我。。其实大多数的设计模式的核心就是多态，掌握好多态，设计模式看起来也很轻松。
现阶段工做已经完成，可是过了一段时间，又添加新的需求了，我还要扩展一个乘法了，那好，很简单只要建立一个乘法计算器继承Calculate父类便可，看代码：
/// <summary>
/// 乘法计算器
/// </summary>
public class Multiplication:Calculate
{
public override int Compute()
{
return Number1*Number2;
}
}
而后在GetCalculateResult函数中添加一个case 就行了：
switch (operation)
{
case "+":
calculate = new Addition();
break;
case "-":
calculate = new Subtraction();
break;
case "*":
calculate = new Multiplication();
break;
}
执行结果：
好了，就这么方便，一个新的功能就扩展完毕了，我根本不须要查看源代码是如何实现的，这就是多态的好处！
- 1. 浅谈C++多态性
- 2. 浅谈C#中的多态性
- 3. Java的多态浅谈
- 4. 浅谈产品生态的力量
- 5. C++：多态浅析
- 6. 谈谈我对C# 多态的理解
- 7. 浅谈C++静态库与动态库
- 8. 浅谈面向对象中的多态
- 9. 浅谈c++面向对象的封装，继承和多态
- 10. 浅谈C++中的多线程（一）
- 更多相关文章...
- • C# 多态性 - C#教程
- • C# 多线程 - C#教程
- • C# 中 foreach 遍历的用法
- • 漫谈MySQL的锁机制
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. python的安装和Hello，World编写
- 2. 重磅解读：K8s Cluster Autoscaler模块及对应华为云插件Deep Dive
- 3. 鸿蒙学习笔记2（永不断更）
- 4. static关键字 和构造代码块
- 5. JVM笔记
- 6. 无法启动 C/C++ 语言服务器。IntelliSense 功能将被禁用。错误: Missing binary at c:\Users\MSI-NB\.vscode\extensions\ms-vsc
- 7. 【Hive】Hive返回码状态含义
- 8. Java树形结构递归（以时间换空间）和非递归（以空间换时间）
- 9. 数据预处理---缺失值
- 10. 都要2021年了，现代C++有什么值得我们学习的？
- 1. 浅谈C++多态性
- 2. 浅谈C#中的多态性
- 3. Java的多态浅谈
- 4. 浅谈产品生态的力量
- 5. C++：多态浅析
- 6. 谈谈我对C# 多态的理解
- 7. 浅谈C++静态库与动态库
- 8. 浅谈面向对象中的多态
- 9. 浅谈c++面向对象的封装，继承和多态
- 10. 浅谈C++中的多线程（一）