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 产生了不一样的结果。还记得多态的定义吗？不一样的对象对同一操做产生不一样的执行结果。没错，这就是多态。多态的做用：把不一样的子类对象都当作父类来看，能够屏蔽不一样子类对象之间的差别，写出通用的代码，作出通用的编程，以适应需求的不断变化。

 

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

原文来自：C#面向对象-多态-曾亚平我的原创博客