C#面向对象-多态_c#

面向对象的三大特性（封装，继承，多态）大多少人都应该知道。前两个的话比较容易理解。本文主要说一下面向对象中的多态。

什么是多态？
不同的对象对同一操作，产生不同的执行结果。这就是多态。那么多态又包含了：重载，重写，虚方法，抽象方法。

1，重载
什么叫重载？
在同一个作用域的两个或多个方法函数名相同，参数列表不同的方法叫做重载。重载有三个特点：
1.1：方法名必须相同。
1.2：参数列表必须不同。
1.3：返回值类型可以不相同。

列如：

1 public void animal()
2 {
3     console.writeline("睡觉");
4 }
5 public void animal(int time)
6 {
7     console.writeline("{0}点睡觉", time);
8 }

2，重写
什么是重写？子类中为满足自己的需求需要来重复定义基类中的某个方法的不同实现。重写需要使用override关键词。需要重写基类中的方法必须是虚方法或抽象方法。重写的特点：
2.1：相同的方法名。
2.2：相同的参数列表。
2.3：相同的返回值。

3，虚方法
什么是虚方法？
基类中定义的允许在子类中重写的方法叫虚方法。使用virtual关键字定义。子类可以不重写虚方法。列如：

1 class animal
2 {
3         public virtual void eatfood()
4         {
5             console.writeline("吃东西");
6         }
7 }

虚方法可以被直接调用，如：

1 animal a = new animal();
2 a.eatfood();

输出的是：

吃东西

虚方法被子类重写，如：

1 class bird:animal
2 {
3         public override void eatfood()
4         {
5             console.writeline("鸟吃虫子");
6         }
7 }

4，抽象方法
什么是抽象方法？
在基类中定义的并且必须在子类中重写的方法叫抽象方法。使用abstract关键字定义。注意：抽象方法只能在抽象类中定义。

虚方法与抽象方法的区别：因为抽象类无法被实例化，抽象方法无法被调用，也就是说抽象方法永远不可能被实现。

应用场景：
其实多态理解起来并不是很困难。主要是怎么灵活运用到实际开发中。那么现在我举个例子：一个大型工厂，目前可以生产苹果，华为，oppo手机，每个手机所使用的芯片都是一样的，屏幕主板不一样，华为手机有红外线。你会怎么实现呢？

 1 public abstract class phone
 2     {
 3         //手机芯片
 4         public string chip { get; set; } = "chip";
 5 
 6         //手机屏幕
 7         public string screen { get; set; }
 8 
 9         //主板
10         public string mainboard { get; set; }
11 
12         //生产手机方法
13         public abstract string production();
14     }
15 
16     //苹果手机
17     public class iphone: phone
18     {
19         public override string production()
20         {
21             console.writeline("开始生产苹果手机");
22             return chip + screen + mainboard;
23         }
24     }
25 
26     //oppo
27     public class oppophone: phone
28     {
29         public override string production()
30         {
31             console.writeline("开始生产oppo手机");
32             return chip + screen + mainboard;
33         }
34     }
35 
36     //华为
37     public class huaweiphone: phone
38     {
39         //华为手机有红外线
40         public string infraredray { get; set; }
41 
42         public override string production()
43         {
44             console.writeline("开始生产华为手机");
45             return chip + screen + mainboard + infraredray;
46         }
47     }

那么现在要生产苹果和华为手机：

 1         static void main(string[] args)
 2         {
 3             //生产苹果手机
 4             iphone iphone = new iphone() { screen = "苹果屏幕", mainboard = "苹果主板" };
 5             console.writeline(iphone.production());
 6 
 7             //生产华为手机
 8             huaweiphone huawei = new huaweiphone() { screen = "华为屏幕", mainboard = "华为主板", infraredray = "红外线" };
 9             console.writeline(huawei.production());
10             console.readkey();
11         }

执行输出结果：

开始生产苹果手机
chip苹果屏幕苹果主板
开始生产华为手机
chip华为屏幕华为主板红外线

我们可以看到 iphone 对象和 huawei 对象都执行了同一个方法 production 产生了不同的结果。还记得多态的定义吗？不同的对象对同一操作产生不同的执行结果。没错，这就是多态。多态的作用：把不同的子类对象都当做父类来看，可以屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，以适应需求的不断变化。

本篇文章就结束啦，如有错误的地方还望大神指点。

原文来自：