OO世界中的核心概念.NET中的多态

多态（Polymorphism）一词源于生物学，顾名思义就是指多种形态。在面向对象世界里，多态与继承和封装一起构成了三大核心概念。

在沧源等地区，都构建了全面的区域性战略布局，加强发展的系统性、市场前瞻性、产品创新能力，以专注、极致的服务理念，为客户提供成都做网站、网站制作 网站设计制作按需设计网站,公司网站建设,企业网站建设,品牌网站建设,营销型网站,外贸网站制作,沧源网站建设费用合理。

.NET中的多态通常意味着子类对于父类一种衍变。子类继承自父类，拥有父类所定义的一切（public或protected）成员。但同时，它又可以修改（重写或复写）这些成员，使其实现与父类以及其他子类完全不同。我们可以说，继承体现了类的多态性。

大家应该很熟悉Duck的例子了吧？

 
 
 
    
  
  
  
  1. public abstract class Duck  
    2. 
  
  
  
  2. {  
    3. 
  
  
  
  3.     public abstract void Quack();  
    4. 
  
  
  
  4. }  
    5. 
  
  
  
  5.  
    6. 
  
  
  
  6. public class MallardDuck : Duck  
    7. 
  
  
  
  7. {  
    8. 
  
  
  
  8.     public override void Quack()  
    9. 
  
  
  
  9.     {  
    10. 
  
  
  
  10.         Console.WriteLine("Quack, quack, quack...");  
    11. 
  
  
  
  11.     }  
    12. 
  
  
  
  12. }  
    13. 
  
  
  
  13.  
    14. 
  
  
  
  14. public class RubberDuck : Duck  
    15. 
  
  
  
  15. {  
    16. 
  
  
  
  16.     public override void Quack()  
    17. 
  
  
  
  17.     {  
    18. 
  
  
  
  18.         Console.WriteLine("Squeak, squeak, squeak...");  
    19. 
  
  
  
  19.     }  
    20. 
  
  
  
  20. }  
    21. 
  
  
  
  21.  
    22. 
  
  
  
  22. public class Program  
    23. 
  
  
  
  23. {  
    24. 
  
  
  
  24.     public static void Main()  
    25. 
  
  
  
  25.     {  
    26. 
  
  
  
  26.         Duck duck = new MallardDuck();  
    27. 
  
  
  
  27.         duck.Quack();  
    28. 
  
  
  
  28.         duck = new RubberDuck();  
    29. 
  
  
  
  29.         duck.Quack();  
    30. 
  
  
  
  30.         Console.ReadLine();  
    31. 
  
  
  
  31.     }  
    32. 
  
  
  
  32. }  
    33.

MallardDuck和RubberDuck虽然都继承自抽象类Duck，同样拥有Quack()方法，但它们却有不同的实现，产生不同的结果。在声明Duck类型时，既可以实例化为Mallard，也可以实例化为RubberDuck，或者是其他继承自Duck的类，在运行时，将自动调用各个子类的实现。

多态的这些特性使依赖注入和面向抽象编程成为可能，其重要性不言而喻。

不一样的多态

然而，既然多态是指同一类事物之间的不同形态，那么我们为什么要把对于多态的理解局限于类的继承关系呢？在.NET中是否还存在着非继承关系的多态性呢？

泛型体现了参数的多态性

类型参数在泛型中通常解释为占位符，而我更愿意将其理解为对参数的一种抽象。以最常见的List< T>为例，List< string>和List< int>在语法上完全相同，仅仅是类型参数有所不同，然而它们却是两个完全不同的类。也就是说，是类型参数的不同，导致了不同的类的形态。

 
 
 
    
  
  
  
  1. public class MyList< T>  
    2. 
  
  
  
  2. {  
    3. 
  
  
  
  3.     private T[] items;  
    4. 
  
  
  
  4.     private int size;  
    5. 
  
  
  
  5.     public void Add(T item)  
    6. 
  
  
  
  6.     {  
    7. 
  
  
  
  7.         if (size == items.Length)  
    8. 
  
  
  
  8.         {  
    9. 
  
  
  
  9.             // modify capacity  
    10. 
  
  
  
  10.         }  
    11. 
  
  
  
  11.         items[size++] = item;  
    12. 
  
  
  
  12.     }  
    13. 
  
  
  
  13. } 
    14.

如果我们使用MyList< string>，在内部就会声明一个字符串数组，Add方法的参数也必须为string。如果使用MyList< int>，在内部就会声明一个int数组，Add方法的参数也必须为int。这看上去就像是T是string和int的“基类”，在使用MyList< T>时（相当于客户端代码），T既可以是string也可以是int，或者是其他符合约束的类型，但在设计时，我们对这一切毫无所知。

您是否也觉得这是多态性的一种体现呢？

再来看看十分经典的Swap< T>的例子。

 
 
 
    
  
  
  
  1. public class Swapper  
    2. 
  
  
  
  2. {  
    3. 
  
  
  
  3.     private static void Swap< T>(ref T o1, ref T o2)  
    4. 
  
  
  
  4.     {  
    5. 
  
  
  
  5.         T temp = o1;  
    6. 
  
  
  
  6.         o1 = o2;  
    7. 
  
  
  
  7.         o2 = temp;  
    8. 
  
  
  
  8.     }  
    9. 
  
  
  
  9. } 
    10.

Swap< T>泛型方法就像是封装了N个非泛型的Swap方法，如Swap(ref int o1, ref int o2)、Swap(ref string o1, ref string o2)等等。在类型推断特性的支持下，您甚至可以像使用非泛型方法一样来使用泛型方法。参数T在某种程度上体现了不同的参数形态，因此我们有理由认为，泛型类型T体现了参数的多态性。

委托体现了方法的多态性

委托是对拥有相同参数和返回值的所有方法的封装。只要方法拥有同样的参数列表和返回值，委托都认为它们属于同一“类型”的方法，可以添加到同一个委托链表中。

 
 
 
    
  
  
  
  1. public delegate void FooDelegate(List< string> list, string str);  
    2. 
  
  
  
  2.  
    3. 
  
  
  
  3. public class DelegateTest  
    4. 
  
  
  
  4. {  
    5. 
  
  
  
  5.     public void AddToList(List< string> list, string strToAdd)  
    6. 
  
  
  
  6.     {  
    7. 
  
  
  
  7.         list.Add(strToAdd);  
    8. 
  
  
  
  8.     }  
    9. 
  
  
  
  9.  
    10. 
  
  
  
  10.     public static void PrintIfContains(List< string> list, string strToCheck)  
    11. 
  
  
  
  11.     {  
    12. 
  
  
  
  12.         if (list.Contains(strToCheck))  
    13. 
  
  
  
  13.             Console.WriteLine("The list contains " + strToCheck);  
    14. 
  
  
  
  14.     }  
    15. 
  
  
  
  15. }  
    16. 
  
  
  
  16.  
    17. 
  
  
  
  17. public class Program  
    18. 
  
  
  
  18. {  
    19. 
  
  
  
  19.     public static void Main()  
    20. 
  
  
  
  20.     {  
    21. 
  
  
  
  21.         List< string> list = new List< string>();  
    22. 
  
  
  
  22.         list.Add("Kirin");  
    23. 
  
  
  
  23.         DelegateTest delegateTest = new DelegateTest();  
    24. 
  
  
  
  24.         FooDelegate fooDelegate = new FooDelegate(delegateTest.AddToList);  
    25. 
  
  
  
  25.         fooDelegate += new FooDelegate(DelegateTest.PrintIfContains);  
    26. 
  
  
  
  26.         fooDelegate(list, "麒麟.NET");  
    27. 
  
  
  
  27.         Console.ReadLine();  
    28. 
  
  
  
  28.     }  
    29. 
  
  
  
  29. }  
    30.

在上例中，FooDelegate委托封装了参数为List< string>和string，并且没有返回值的方法。任何符合上述约束的方法，在FooDelegate中一视同仁。如，AddToList实例方法与PrintIfContains静态方法除了参数列表与返回值相同外，内部实现完全不同，但是它们却可以添加到同一个委托链表中。也就是说，同一个委托，可以定义并调用不同的方法（约束相同而实现不同）。

您是否也认为这是方法的多态性的一种体现呢？

小结

我们通常所讨论的多态，就是指子类对父类方法的重写（虚方法）或覆盖（非虚方法），这样的理解未免过于狭隘。.NET强大的特性能够实现其他语言中无法实现的多态性。

本文题目：OO世界中的核心概念.NET中的多态
URL分享：http://www.shufengxianlan.com/qtweb/news39/294339.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

云服务器知识

各行业网站

成都网站建设公司　　 　成都SEO公司　　 　成都木托盘　　 　网络推广平台　　 　成都广告公司　　 　成都网站推广　　 　专业网站建设　　 　胜锦安防科技　　 　化妆品企业网站建设方案　　 　成都茶叶销售　　 　重庆网站制作　　 　成都广告招牌　　 　手机app　　 　国泰民安消防　　 　成都网站设计　　 　微信小程序开发　　 　甘孜州博瑞斯　　 　成都网站优化　　 　德阳服务器托管　　 　移动服务器托管