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

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");
        }
    }
}

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

我在一些地方看到抽象方法的定义如下**

“必须在子类中实现抽象方法”

**我觉得是这样。

如果子类也是抽象的，则不必在子类中实现抽象方法。。

1） 抽象方法不能是私有方法。2） 抽象方法不能在同一抽象类中实现。

我会说。。如果我们要实现一个抽象类，您必须重写基础抽象类中的抽象方法。因为使用重写关键字实现抽象方法。类似于虚拟方法。

虚拟方法不必在继承类中实现。

                                 ----------CODE--------------

public abstract class BaseClass
{
    public int MyProperty { get; set; }
    protected abstract void MyAbstractMethod();

    public virtual void MyVirtualMethod()
    {
        var x = 3 + 4;
    }

}
public abstract class myClassA : BaseClass
{
    public int MyProperty { get; set; }
    //not necessary to implement an abstract method if the child class is also abstract.

    protected override void MyAbstractMethod()
    {
        throw new NotImplementedException();
    }
}
public class myClassB : BaseClass
{
    public int MyProperty { get; set; }
    //You must have to implement the abstract method since this class is not an abstract class.

    protected override void MyAbstractMethod()
    {
        throw new NotImplementedException();
    }
}

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

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

抽象方法总是虚拟的。它们无法实现。

这是主要的区别。

基本上，如果您有一个虚拟方法的“默认”实现，并且希望允许后代更改其行为，那么您将使用该方法。

使用抽象方法，可以强制后代提供实现。

抽象函数不能具有功能。你基本上是说，任何子类都必须给出自己版本的这个方法，但是它太通用了，甚至无法在父类中实现。

一个虚拟函数，基本上就是说，看，这里的功能对于子类来说可能不够好，也可能不够好。因此，如果它足够好，请使用此方法，如果不好，请重写我，并提供您自己的功能。