简单说明多态

简单说明多态

多态（Polymorphic）–面向对象高级语言重要特性，属于运行时绑定技术。

重载则属于编译时绑定技术，重载不是面向对象特性。

在“设计模式前奏–多态”那篇文章中我用了大量篇幅讲解多态，也许有的读者不太容易理解，所以这篇就如标题一样，我只想简单说明多态。

本篇文章我们将不深入讨论abstract,virtaul,new,override之间的关系，只是简单说明在实际开发中90%以上会使用到的情况，而不是各种复杂多变的组合，从而带来不同的调用形式。

public class Super
{
    public void F(){ //code }
}

public class SubA:Super
{

}

public class SubB:Super
{
    public void F(){ //code }
}

这种情况我们不探讨
Super s= new Super();//call self
SubA a= new SubA();//call self
SubB b= new SubB();//call self

只探讨以下这种情况
Super sa= new SubA();
Super sb= new SubB();

基类（父类）有一个实体方法void F(){ //code }或virtual void F(){ //code }

如果子类不实现基类的方法F，那么很明显将会调用基类的方法F。

如果子类实现基类的方法F，那么void F()和 new void F()调用的是基类方法，而override void F()调用的是子类方法。

如果子类使用了new或override修饰符，那么基类中的方法必须添加virtual修饰符。

我们来看一下完整的代码：

//代码一，这种情况并不多见。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace conAppSimplePolymorphic
{
    class Program
    {
        static void Main(string[] args)
        {
            Super sa = new SubA();
            sa.F();

            Super sb = new SubB();
            sb.F();
        }
    }

    public class Super
    {
        public void F()  
        //public virtual void F()
        {
            Console.WriteLine("Super");
        }       
    }

    public class SubA : Super
    {

    }

    public class SubB : Super
    {
        public void F()  
        //public new void F()
        {
            Console.WriteLine("Sub B");
        }
    }
}

以上代码运行后输出
Super
Super

//代码二，这种情况比较常见，也就是我前面说到的实际开发中90%以上会使用到的。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace conAppSimplePolymorphic
{
    class Program
    {
        static void Main(string[] args)
        {
            Super sa = new SubA();
            sa.F();

            Super sb = new SubB();
            sb.F();
        }
    }

    public class Super
    {
        public virtual void F()
        {
            Console.WriteLine("Super");
        }       
    }

    public class SubA : Super
    {

    }

    public class SubB : Super
    {
        public override void F()
        {
            Console.WriteLine("Sub B");
        }
    }
}

以上代码运行后输出
Super
Sub B

关于前面提到的“运行时绑定”，是什么意思呢，就是说无法简单的通过代码去判断函数的调用，不能在“编译时绑定”，比如你把光标移动到sa.F()或sb.F()上，均显示调用void Super.F()，运行之后代码一的sb.F()调用了Super.F()，而代码二的sb.F()则调用了SubB.F()，这就是“运行时绑定”技术，也叫“动态绑定”。而重载则属于“编译时绑定”，也叫“静态绑定”。

当然你看了这篇文章以及前面的“设计模式前奏–多态”后，你应该能通过函数修饰去判断函数具体调用情况。

后续可能还会有文章来说明pubclic abstract override string F()这种更复杂的情况，当然这是很复杂的多态，已经大大超出本文的范畴。

版权所有，转载请注明文章出处 http://blog/csdn.net/cadenzasolo