Java 中的虚拟方法调用和运行时多态是面向对象编程的重要特性。

虚拟方法调用是指在运行时根据对象的实际类型来确定要调用的方法。在 Java 中，通过覆盖/重写（Override）父类的方法来实现虚拟方法调用。

简单的示例

abstract class Animal {

    private String type;
    private String name; // Name
    private String breed; // breed

    public Animal(String aType) {
        type = new String(aType);
    }
	
	  public Animal() {
       this( "Some Type of Animal " );
    }
    public String getType() {
        return type;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setBreed(String breed) {
        this.breed = breed;
    }
		/*
    public void sound() {
    	System.out.println("Animal sound!");
    }
    */
    public abstract void sound();
}

class Dog extends Animal {

    public Dog(String aName, String aBreed) {
        super("Dog");// Call the super constructor
        setName(aName);  // Supplied name
        setBreed(aBreed);  // Supplied breed
    }
    
    public void sound() {
        System.out.println(getType() + " " + 
                   getName() + " WangWang!");
    }
}

class Duck extends Animal {

    public Duck(String aName, String aBreed) {
        this();      // Call the base constructor
        setName(aName);  // Supplied name
        setBreed(aBreed);  // Supplied breed
    }

    public Duck() {
        super("Duck");
    }

    public void layEggs() {
        System.out.println("Egg laid!");
    }

    public void sound() {
        System.out.println(getType() + " " + 
                     getName() + " Quack quack!");
    }
}

class Cat extends Animal {

    public Cat(String aName, String aBreed) {
       super("Cat");      // Call the base constructor
        setName(aName);  // Supplied name
        setBreed(aBreed);  // Supplied breed
    }

    public void catchMice() {
        System.out.println("Mouse catched!");
    }

    public void sound() {
        System.out.println(getType() + " " + 
                         getName() + " MiuMiu!");
    }
}

public class TestAnimalsSound {

    public static void main(String[] args) {    	    	
        //Heterogeneous Collection
        Animal[] theAnimals = {
            new Dog("Gooffy", "Poodle"),
            new Duck("Docnald", "Disney"),
            new Cat("Jaffy", "White")
        };

        for (Animal a : theAnimals) {
        	   // Output the class name: Cat/Dog/Duck
            System.out.println("\n" + a.getClass());
            //sound
            a.sound();
            //Lay eggs or Catch mice
            if (a instanceof Duck) ((Duck)a).layEggs();
            if (a instanceof Cat) ((Cat)a).catchMice();
        }
    }
}

这个程序的输出结果如下：

class Dog
Dog Gooffy WangWang!

class Duck
Duck Docnald Quack quack!
Egg laid!

class Cat
Cat Jaffy MiuMiu!
Mouse catched!

在这个示例中：

1. Animal 是一个抽象的基类，包含一个抽象的sound() 方法，也就是这里所说的虚拟方法。
2. Dog 、Duck 和 Cat 是 Animal 的子类，它们分别覆盖/重写了 sound() 方法。
3. 在 main 方法中，创建了一个 Animal类型的数组对象，并将数组元素分别初始化赋为 Dog 、Duck 和 Cat 三个对象。
4. 使用For-each循环，依次取出Animal数组元素，调用 a.sound() 时，由于调用的是Animal中定义的虚拟方法，实际会根据对象的实际类型（在这里是 Dog、Duck 和 Cat ）来确定要执行的具体方法。

使用多态的优点

通过虚拟方法调用和运行时多态，使得不同类型的对象可以具有不同的行为。

1. 灵活性：可以根据具体的对象类型执行不同的操作。

2. 可扩展性：方便地添加新的子类并提供独特的行为。

3. 代码重用：父类的方法可以在子类中重用，并根据需要进行定制。