C++、JAVA与C#中的多态虚函数、纯虚函数（抽象函数）

面向对象之中，最重要的概念无外乎四个：封装、继承、抽象与多态。

其他三个很好理解，但多态，总是一个不大不小容易模糊的问题。多态，定义为，不同对象调用同一方法的不同行为。具体的见代码，就会感觉很明晰：

C++代码：

#include<iostream>
using namespace std;
class father
{
public:
virtual void f()
{
cout<<"father's f()"<<endl;
}
};
class son:public father
{
public:
virtual void f()
{
cout<<"son's f()"<<endl;
}
};
int main()
{
father *myf=new father();
father *mys=new son();
myf->f();
mys->f();
delete myf;
delete mys;
system("pause");
return 0;
}

运行结果为：

father's f()

son's f()

对应的JAVA代码为：

import java.util.*;
public class test
{
class father
{
public void f()
{
System.out.println("father's f()");
}
}
class son extends father
{
public void f()
{
System.out.println("son's f()");
}
}
public void tes()
{
father myf=new father();
father mys=new son();
myf.f();
mys.f();
}
public static void main(String[] args)
{
test myt=new test();
myt.tes();
}
}

运行的结果为:

father's f()

son's f()

可以看到，JAVA中没有虚函数的概念，它的普通函数就相当于C++中的虚函数。

需要注意的是，C++代码中将virtual修饰去掉，也可以编译通过，不过运行出来的结果就是两次都调用的是father类中的f()函数。

C#代码为：

using System;
public class myt
{
class father
{
public virtual void f()
{
Console.WriteLine("father's f()");
}
}
class son:father
{
public override void f()
{
Console.WriteLine("son's f()");
}
}
public void func()
{
father myf=new father();
myf.f();
father mys=new son();
mys.f();
}
public static void Main(string[] args)
{
myt t=new myt();
t.func();
}
}

运行结果为：

father's f()

son's f()

可以看到，C#同C++一样，也是保留了virtual函数修饰符的，而且，它如果子类要重写的话，必须加上override。同样，如果去掉virtual和override，那么两次都是调用的父类的f()函数。会有一个警告，myt.son.f()隐藏了myt.father.f()。

如果不是标记为virtual的父类的函数，是override不了的。

接下来，再讨论一下纯虚函数。

在C++中，标记为virtual的函数必须得有函数体，哪怕函数体为空都可以。要不然虽然可以通过编译，但是会发生link错误。

C++中的纯虚函数为：

virtual void f()=0;纯虚函数可以没有函数体。

含有纯虚函数的类不能被实例化，它必须得有子类。子类重写了它的纯虚函数之后，才能够实例化。

#include<iostream>
using namespace std;
class father
{
public:
virtual void f()=0;
};
class son:public father
{
public:
virtual void f()
{
cout<<"son's f()"<<endl;
}
};
int main()
{
//father *myf=new father();//错误，不能被实例化
father *mys=new son();
//myf->f();
mys->f();
//delete myf;
delete mys;
system("pause");
return 0;
}

对于java而言，纯虚函数的修饰符为abstract，当然，它不叫纯虚函数，而叫做抽象函数。

抽象函数得定义在抽象类中，抽象函数没有函数体。当然，抽象类中还可以包括非抽象函数。

abstract class father
 {
                 public abstract void f();
                 public void f1()
                 {
                        System.out.println("f1");
                  }
}

对于C#而言，virtual函数必须得有函数体。它的抽象函数（纯虚函数）为：

 public abstract class Book
    {
        //抽象方法，不含主体，抽象方法所在类必须为抽象类，派生类必须实现该方法
        public abstract void Introduce();
    }

    public class JavaBook : Book
    {
        //实现抽象方法，必须实现，必须添加override关键字
        public override void Introduce()
        {
            Console.WriteLine("I'm Java");
        }

    }

同JAVA一样，也是用abstrace作为修饰。

综上所述：

C++：

虚函数，virtual，有函数体。纯虚函数=0，没有函数体。多态用虚函数实现。包含纯虚函数的类不能实例化。子类可以实现也可以不实现纯虚函数。

JAVA：

没有虚函数，重写（多态）用纯虚函数即可。抽象函数abstract没有函数体，必须放在abstract类中。abstract类不能实例化。abstract的子类可以不实现父类的abstract方法，不是abstract的子类必须实现。

C#:

虚函数为virtual,有函数体，子类重写用override。抽象函数为abstract，与JAVA相同。只是子类实现时也要加上override。