抽象函数（方法）：

● 抽象方法是用关键字abstract声明的方法。

● 它没有身体。

● 它应该由派生类实现。

● 如果方法是抽象的，那么类应该是抽象的。

虚拟函数（方法）：

● 虚方法是用关键字virtual声明的方法，它可以通过使用override关键字由派生类方法重写。

● 是否重写它取决于派生类。

抽象函数“只是”签名，没有实现。它在接口中用于声明如何使用类。它必须在其中一个派生类中实现。

虚函数（实际上是方法）也是您声明的函数，应该在继承层次结构类之一中实现。

此类类的继承实例也继承实现，除非您在较低层次结构类中实现它。

在这里，我写了一些示例代码，希望这可能是一个非常实际的例子，可以从非常基本的层面上看到接口、抽象类和普通类的行为。如果您想将其用作演示，也可以在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(){
    //
    //    }
    }
}

抽象函数不能有主体，必须由子类重写

虚函数将有一个主体，并且可以或不可以被子类重写

必须始终重写抽象函数。

因此：

抽象函数-当继承者必须提供自己的实现时虚拟-由继承人决定

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