其实这个主要还是C#的问题而非Java问题。
多态的实现就是靠后绑定。当从父类中继承的时候,虚函数和被继承的函数具有相同的签名。在运行期间根据情况(参数,返回值)决定调用函数的入口地址。
Java中“所有函数默认为虚函数”,也就是说所有的方法(除final)默认都是可以继承的。
java代码
class A {
public void func() {
System.out.println("A");
}
}
class B extends A {
public void func() {
System.out.println("B");
}
}
class C extends A {
}
class Test {
public static void main(String[] args) {
A a = new A();
A b = new B();
A c = new C();
a.func(); //A
b.func(); //B
c.func(); //A
}
}
C#代码
using System;
namespace SouthWolf
{
class A
{
public virtual void Func()
{
Console.WriteLine("A");
}
}
class B : A
{
public override void Func() // 注意override ,表明重新实现了虚函数
{
Console.WriteLine("B");
}
}
class C : B
{
}
class D : A
{
public new void Func() // 注意new ,表明覆盖父类里的同名方法,而不是重新实现
{
Console.WriteLine("D");
}
}
class program
{
static void Main()
{
A a;
A b;
A c;
A d;
a = new A();
b = new B();
c = new C();
d = new D();
a.Func(); // 执行a.Func:1.先检查申明类A 2.检查到是虚拟方法 3.转去检查实例类A,就为本身 4.执行实例类A中的方法 5.输出结果 A
b.Func(); // 执行b.Func:1.先检查申明类A 2.检查到是虚拟方法 3.转去检查实例类B,有重载的 4.执行实例类B中的方法 5.输出结果 B
c.Func(); // 执行c.Func:1.先检查申明类A 2.检查到是虚拟方法 3.转去检查实例类C,无重载的 4.转去检查类C的父类B,有重载的 5.执行父类B中的Func方法 5.输出结果 B
d.Func(); // 执行d.Func:1.先检查申明类A 2.检查到是虚拟方法 3.转去检查实例类D,无重载的(这个地方要注意了,虽然D里有实现Func(),但没有使用override关键字,所以不会被认为是重载) 4.转去检查类D的父类A,就为本身 5.执行父类A中的Func方法 5.输出结果 A
D d1 = new D();
d1.Func(); // 执行D类里的Func(),输出结果 Func In D
Console.ReadLine();
}
}
}
1、当调用一个对象的函数时,系统会直接去检查这个对象申明定义的类,即申明类,看所调用的函数是否为虚函数;
2、如果不是虚函数,那么它就直接执行该函数。而如果有virtual关键字,也就是一个虚函数,那么这个时候它就不会立刻执行该函数了,而是转去检查对象的实例类。
3、在这个实例类里,他会检查这个实例类的定义中是否有重新实现该虚函数(通过override关键字),如果是有,那么OK,它就不会再找了,而马上执行该实例类中的这个重新实现的函数。而如果没有的话,系统就会不停地往上找实例类的父类,并对父类重复刚才在实例类里的检查,直到找到第一个重载了该虚函数的父类为止,然后执行该父类里重载后的函数。
Java中则是根据同名函数的签名(参数列表/返回值)判断是否为多态/重载。子类中如果有与父类签名完全相同的同名函数,就直接认为是覆盖,否则就是重载。