浅谈.NET中不一样的多态

来源:转载

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

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

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

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

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

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

泛型体现了参数的多态性

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

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

如果我们使用MyList,在内部就会声明一个字符串数组,Add方法的参数也必须为string。如果使用MyList,在内部就会声明一个int数组,Add方法的参数也必须为int。这看上去就像是T是string和int的“基类”,在使用MyList时(相当于客户端代码),T既可以是string也可以是int,或者是其他符合约束的类型,

[1] [2] 下一页

分享给朋友:
您可能感兴趣的文章:
随机阅读: