虚拟方法：

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

抽象方法

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

抽象函数（方法）：

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

● 它没有身体。

● 它应该由派生类实现。

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

虚拟函数（方法）：

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

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

解释：用类比。希望这对你有帮助。

上下文

我在一栋楼的21层工作。我对火很偏执。时不时地，在世界的某个地方，一场大火正在烧毁一座摩天大楼。但幸运的是，我们在这里有一本指导手册，说明发生火灾时该怎么做：

FireEscape（）

不要收集物品步行至消防通道走出大楼

这基本上是一个名为FireEscape（）的虚拟方法

虚拟方法

这个计划对99%的情况都很好。这是一个可行的基本计划。但有1%的可能性是消防通道被堵塞或损坏，在这种情况下，你会彻底完蛋，除非你采取一些激烈的行动，否则你会被烤焦。使用虚拟方法，您可以做到这一点：您可以使用自己版本的计划覆盖基本的FireEscape（）计划：

运行到窗口跳出窗口降落伞安全到达底部

换句话说，虚拟方法提供了一个基本的计划，如果需要的话可以重写。如果程序员认为合适，子类可以重写父类的虚拟方法。

抽象方法

并非所有组织都训练有素。一些组织不进行消防演习。他们没有全面的逃跑政策。每个人都是为了自己。管理层只对现有的这种政策感兴趣。

换句话说，每个人都被迫开发自己的FireEscape（）方法。一个人会走出消防通道。另一个人会跳伞。另一个人将使用火箭推进技术飞离大楼。另一个人会用绳索离开。管理层不在乎你如何逃跑，只要你有一个基本的FireEscape（）计划——如果他们不这样做，你可以保证OHS会像一吨砖头一样砸在组织身上。这就是抽象方法的含义。

这两者又有什么区别？

抽象方法：子类被迫实现自己的FireEscape方法。使用虚拟方法，你有一个基本的计划等着你，但如果不够好，你可以选择实施自己的计划。

现在这并不难，是吗？

抽象函数或方法是由类公开的公共“操作名称”，其目的与抽象类一起，主要是在对象设计中针对对象必须实现的结构提供一种形式的约束。

事实上，从其抽象类继承的类必须为该方法提供一个实现，通常编译器在不实现时会引发错误。

使用抽象类和方法非常重要，主要是为了避免在设计类时关注实现细节，从而导致类结构与实现过于相关，从而在它们之间协作的类之间创建依赖关系和耦合。

虚拟函数或方法只是一种模拟类的公共行为的方法，但我们可以在继承链中自由修改它，因为我们认为子类可能需要为该行为实现一些特定的扩展。

它们都代表了面向对象范式中的一种多元化。

我们可以一起使用抽象方法和虚拟函数来支持一个好的继承模型。

我们为解决方案的主要对象设计了一个很好的抽象结构，然后通过定位那些更易于进一步专门化的对象来创建基本实现，我们将这些对象作为虚拟对象，最后我们专门化我们的基本实现，最终“覆盖”继承的虚拟对象。

我通过对以下课程（从其他答案）进行一些改进，使这一点更简单：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace TestOO
{
    class Program
    {
        static void Main(string[] args)
        {
            BaseClass _base = new BaseClass();
            Console.WriteLine("Calling virtual method directly");
            _base.SayHello();
            Console.WriteLine("Calling single method directly");
            _base.SayGoodbye();

            DerivedClass _derived = new DerivedClass();
            Console.WriteLine("Calling new method from derived class");
            _derived.SayHello();
            Console.WriteLine("Calling overrided method from derived class");
            _derived.SayGoodbye();

            DerivedClass2 _derived2 = new DerivedClass2();
            Console.WriteLine("Calling new method from derived2 class");
            _derived2.SayHello();
            Console.WriteLine("Calling overrided method from derived2 class");
            _derived2.SayGoodbye();
            Console.ReadLine();
        }
    }


    public class BaseClass
    {
        public void SayHello()
        {
            Console.WriteLine("Hello\n");
        }
        public virtual void SayGoodbye()
        {
            Console.WriteLine("Goodbye\n");
        }

        public void HelloGoodbye()
        {
            this.SayHello();
            this.SayGoodbye();
        }
    }


    public abstract class AbstractClass
    {
        public void SayHello()
        {
            Console.WriteLine("Hello\n");
        }


        //public virtual void SayGoodbye()
        //{
        //    Console.WriteLine("Goodbye\n");
        //}
        public abstract void SayGoodbye();
    }


    public class DerivedClass : BaseClass
    {
        public new void SayHello()
        {
            Console.WriteLine("Hi There");
        }

        public override void SayGoodbye()
        {
            Console.WriteLine("See you later");
        }
    }

    public class DerivedClass2 : AbstractClass
    {
        public new void SayHello()
        {
            Console.WriteLine("Hi There");
        }
        // We should use the override keyword with abstract types
        //public new void SayGoodbye()
        //{
        //    Console.WriteLine("See you later2");
        //}
        public override void SayGoodbye()
        {
            Console.WriteLine("See you later");
        }
    }
}

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