绑定是将名称映射到代码单元的过程。

后期绑定意味着我们使用名称，但延迟映射。换言之，我们首先创建/提及名称，然后让后续流程处理代码到该名称的映射。

现在考虑：

与人类相比，机器确实擅长搜索和排序与机器相比，人类确实擅长发明和创新

因此，简单的答案是：virtual是机器（运行时）的后期绑定指令，而abstract是人类（程序员）的后期约束指令

换句话说，虚拟意味着：

亲爱的运行时，通过执行您最擅长的操作将适当的代码绑定到此名称：搜索

抽象意味着：

亲爱的程序员，请尽你所能将适当的代码绑定到这个名字上：发明

为完整起见，重载意味着：

“亲爱的编译器，通过做你最擅长的事情，将适当的代码绑定到这个名称：排序”。

抽象方法：当类包含抽象方法时，该类必须声明为抽象的。抽象方法没有实现，因此派生自该抽象类的类必须为该抽象方法提供实现。

虚拟方法：类可以具有虚拟方法。虚拟方法有一个实现。当从具有虚拟方法的类继承时，可以重写虚拟方法并提供额外的逻辑，或者用自己的实现替换逻辑。

何时使用什么：在某些情况下，您知道某些类型应该有一个特定的方法，但您不知道该方法应该有什么实现。在这种情况下，您可以创建包含具有此签名的方法的接口。然而，如果您有这样的情况，但您知道该接口的实现者也将有另一个通用方法（您已经可以为其提供实现），那么您可以创建一个抽象类。然后，这个抽象类包含抽象方法（必须重写）和另一个包含“公共”逻辑的方法。

如果您有一个可以直接使用的类，但您希望继承者能够更改某些行为，则应使用虚拟方法，尽管这不是强制性的。

在这里，我写了一些示例代码，希望这可能是一个非常实际的例子，可以从非常基本的层面上看到接口、抽象类和普通类的行为。如果您想将其用作演示，也可以在github中找到此代码作为项目：https://github.com/usavas/JavaAbstractAndInterfaceDemo

public interface ExampleInterface {

//    public void MethodBodyInInterfaceNotPossible(){
//    }
    void MethodInInterface();

}

public abstract class AbstractClass {
    public abstract void AbstractMethod();

    //    public abstract void AbstractMethodWithBodyNotPossible(){
    //
    //    };

    //Standard Method CAN be declared in AbstractClass
    public void StandardMethod(){
        System.out.println("Standard Method in AbstractClass (super) runs");
    }
}

public class ConcreteClass
    extends AbstractClass
    implements ExampleInterface{

    //Abstract Method HAS TO be IMPLEMENTED in child class. Implemented by ConcreteClass
    @Override
    public void AbstractMethod() {
        System.out.println("AbstractMethod overridden runs");
    }

    //Standard Method CAN be OVERRIDDEN.
    @Override
    public void StandardMethod() {
        super.StandardMethod();
        System.out.println("StandardMethod overridden in ConcreteClass runs");
    }

    public void ConcreteMethod(){
        System.out.println("Concrete method runs");
    }

    //A method in interface HAS TO be IMPLEMENTED in implementer class.
    @Override
    public void MethodInInterface() {
        System.out.println("MethodInInterface Implemented by ConcreteClass runs");

    //    Cannot declare abstract method in a concrete class
    //    public abstract void AbstractMethodDeclarationInConcreteClassNotPossible(){
    //
    //    }
    }
}

虚拟方法：

虚拟意味着我们可以超越它。虚拟函数有一个实现。当我们继承类时可以重写虚拟函数并提供我们自己的逻辑。我们可以在实现子类中的函数（可以说是阴影）。

抽象方法

抽象意味着我们必须重写它。抽象函数没有实现，必须在抽象类中。它只能声明。这迫使派生类提供它的实现。抽象成员是隐式虚拟的。在某些语言中，抽象可以称为纯虚拟。公共抽象类BaseClass{ 受保护的抽象void xAbstractMethod（）；公共虚拟void xVirtualMethod（）{变量x=3+4；}}

从C++背景来看，C#虚拟对应于C++虚拟，而C#抽象方法对应于C++纯虚拟函数

从面向对象的常规视图：关于抽象方法：当你把一个抽象方法放在父类中时，实际上你在对子类说：嘿，注意你有一个这样的方法签名。如果你想使用它，你应该实现你自己的！关于虚拟函数：当你在父类中放置一个虚拟方法时，你会对派生类说：嘿，这里有一个功能可以为你做些什么。如果这对你有用，就使用它。如果没有，重写它并实现你的代码，甚至你可以在代码中使用我的实现！这是关于通用OO中这两个概念之间不同的一些哲学