为什么Java中的函数默认是虚拟函数

 其实这个主要还是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();   

        }   

    }   

}  

 

 

补充：C#中的重载/覆盖实现方法

1、当调用一个对象的函数时，系统会直接去检查这个对象申明定义的类，即申明类，看所调用的函数是否为虚函数；

2、如果不是虚函数，那么它就直接执行该函数。而如果有virtual关键字，也就是一个虚函数，那么这个时候它就不会立刻执行该函数了，而是转去检查对象的实例类。

3、在这个实例类里，他会检查这个实例类的定义中是否有重新实现该虚函数（通过override关键字），如果是有，那么OK，它就不会再找了，而马上执行该实例类中的这个重新实现的函数。而如果没有的话，系统就会不停地往上找实例类的父类，并对父类重复刚才在实例类里的检查，直到找到第一个重载了该虚函数的父类为止，然后执行该父类里重载后的函数。

Java中则是根据同名函数的签名（参数列表/返回值）判断是否为多态/重载。子类中如果有与父类签名完全相同的同名函数，就直接认为是覆盖，否则就是重载。