你能用Java编写虚函数/方法吗？

来自维基百科

在Java中，所有非静态方法都是缺省情况下的“虚函数”。只有标有关键字 final（无法覆盖）的方法以及未继承的私有方法才是非虚拟的。

你能用Java编写虚函数吗？

是的。实际上，默认情况下，Java 中的所有实例方法都是虚拟的。只有某些方法不是虚拟的：

• 类方法（因为通常每个实例都包含有关其特定方法的 vtable 指针等信息，但此处没有可用的实例）。
• 私有实例方法（因为没有其他类可以访问该方法，所以调用实例始终具有定义类本身的类型，因此在编译时是明确已知的）。

以下是一些示例：

“普通”虚拟功能

以下示例来自另一个答案中提到的维基百科页面的旧版本。

import java.util.*;

public class Animal 
{
   public void eat() 
   { 
      System.out.println("I eat like a generic Animal."); 
   }

   public static void main(String[] args) 
   {
      List<Animal> animals = new LinkedList<Animal>();

      animals.add(new Animal());
      animals.add(new Fish());
      animals.add(new Goldfish());
      animals.add(new OtherAnimal());

      for (Animal currentAnimal : animals) 
      {
         currentAnimal.eat();
      }
   }
}

class Fish extends Animal 
{
   @Override
   public void eat() 
   { 
      System.out.println("I eat like a fish!"); 
   }
}

class Goldfish extends Fish 
{
   @Override
   public void eat() 
   { 
      System.out.println("I eat like a goldfish!"); 
   }
}

class OtherAnimal extends Animal {}

输出：

I eat like a generic Animal.
I eat like a fish!
I eat like a goldfish!
I eat like a generic Animal.

带接口的虚函数示例

Java 接口方法都是虚拟的。它们必须是虚拟的，因为它们依赖于实现类来提供方法实现。要执行的代码将仅在运行时选择。

例如：

interface Bicycle {         //the function applyBrakes() is virtual because
    void applyBrakes();     //functions in interfaces are designed to be 
}                           //overridden.

class ACMEBicycle implements Bicycle {
    public void applyBrakes(){               //Here we implement applyBrakes()
       System.out.println("Brakes applied"); //function
    }
}

具有抽象类的虚函数的示例。

与接口类似，抽象类必须包含虚拟方法，因为它们依赖于扩展类的实现。例如：

abstract class Dog {                   
    final void bark() {               //bark() is not virtual because it is 
        System.out.println("woof");   //final and if you tried to override it
    }                                 //you would get a compile time error.

    abstract void jump();             //jump() is a "pure" virtual function 
}                                     
class MyDog extends Dog{
    void jump(){
        System.out.println("boing");    //here jump() is being overridden
    }                                  
}
public class Runner {
    public static void main(String[] args) {
        Dog dog = new MyDog();       // Create a MyDog and assign to plain Dog variable
        dog.jump();                  // calling the virtual function.
                                     // MyDog.jump() will be executed 
                                     // although the variable is just a plain Dog.
    }
}