就我个人理解而言。
抽象方法代表你先定下一个行为准则，你没有考虑好具体的实现，但是子类必须要实现这个行为。
而虚方法是代表子类可以重写这个行为，你可以有和父类不同的实现逻辑，或者说你就不重写，默认和父类的行为一模一样。

这个应该算概念上的区别。

抽象就是连默认实现都没有，必须由子类来提供具体业务逻辑
虚方法是默认已经提供了相应的业务执行逻辑，但子类可以按自身需求将其进行重写

那子类必须要强制实现，那还不如都用虚方法呢？想重写就重写不想重写就那样

Quote: 引用 1 楼 hanjun0612 的回复:

就我个人理解而言。
抽象方法代表你先定下一个行为准则，你没有考虑好具体的实现，但是子类必须要实现这个行为。
而虚方法是代表子类可以重写这个行为，你可以有和父类不同的实现逻辑，或者说你就不重写，默认和父类的行为一模一样。

这个应该算概念上的区别。

什么情况下需要考虑定这个准则呢？ 有没有大概的例子之类的。我想不过来。。，既然没想好具体的实现那为什么不不写呢，万一后来也不需要实现那子类不是很麻烦

Quote: 引用 5 楼 weixin_40068689 的回复:

那子类必须要强制实现，那还不如都用虚方法呢？想重写就重写不想重写就那样

.........如果一个方法无法提供默认实现,必须要求子类实现的情况呢?

Quote: 引用 4 楼 starfd 的回复:

抽象就是连默认实现都没有，必须由子类来提供具体业务逻辑
虚方法是默认已经提供了相应的业务执行逻辑，但子类可以按自身需求将其进行重写

     那子类必须要强制实现，那还不如都用虚方法呢？想重写就重写不想重写就那样

抽象方法其实是虚方法的特例。你看il代码，抽象方法会自动添加 virtual 的修饰符。既然抽象方法是虚方法的特例，那么它特殊就在，基类是抽象类没办法实现的情况。比如说一个抽象表示形状的类，它的“面积”就没有意义，必须是派生类（比如三角形类、四边形类、圆类等）去实现了。

虚方法就是具有默认实现的抽象方法。

所以，不是楼上说的，精益求精的精神。

实际上是反的，在做最原始的抽象的时候，我们不要什么精益求精，我们要的抽象，要的是必须如此。我们不但不精益求精，我们反而是粗枝大叶，我们要剪掉所有能剪掉的，只保留最原始，最基本的最直接反映你要做的这个设计的最原始的核心。也就是他是最核心的符合要求的，纯理论上的设计

当然在纯理论设计完毕后，我们还得设计他实际上能够证明他真正能够跑起来的最初的原型代码

就我个人理解而言。
抽象方法代表你先定下一个行为准则，你没有考虑好具体的实现，但是子类必须要实现这个行为。
而虚方法是代表子类可以重写这个行为，你可以有和父类不同的实现逻辑，或者说你就不重写，默认和父类的行为一模一样。

这个应该算概念上的区别。

Quote: 引用 1 楼 hanjun0612 的回复:

就我个人理解而言。
抽象方法代表你先定下一个行为准则，你没有考虑好具体的实现，但是子类必须要实现这个行为。
而虚方法是代表子类可以重写这个行为，你可以有和父类不同的实现逻辑，或者说你就不重写，默认和父类的行为一模一样。

这个应该算概念上的区别。

这个解释的都可以了，不动手进行设计  是不太容易理解的。

Quote: 引用 14 楼 wanghui0380 的回复:

所以，不是楼上说的，精益求精的精神。

实际上是反的，在做最原始的抽象的时候，我们不要什么精益求精，我们要的抽象，要的是必须如此。我们不但不精益求精，我们反而是粗枝大叶，我们要剪掉所有能剪掉的，只保留最原始，最基本的最直接反映你要做的这个设计的最原始的核心。也就是他是最核心的符合要求的，纯理论上的设计

当然在纯理论设计完毕后，我们还得设计他实际上能够证明他真正能够跑起来的最初的原型代码

正相反，我认为你描述的，恰恰是精益求精，你陷入了追求文字描述的“奇巧”而忽略了文字的本意。
我的理解，一个精益求精的架构，它就是一个当前最适合的架构。你“剪掉所有能剪掉的，只保留最原始”，这就是精益精神。
如果你说，“我粗枝大叶的设计了一个架构”，谁能够相信，你是设计了一个好的符合核心需求的架构？

大巧若拙，大智若愚

粗枝大叶不是错误，能做到粗枝大叶，才是真本事来着

Quote: 引用 18 楼 duanzi_peng 的回复:

Quote: 引用 1 楼 hanjun0612 的回复:

就我个人理解而言。
抽象方法代表你先定下一个行为准则，你没有考虑好具体的实现，但是子类必须要实现这个行为。
而虚方法是代表子类可以重写这个行为，你可以有和父类不同的实现逻辑，或者说你就不重写，默认和父类的行为一模一样。

这个应该算概念上的区别。

这个解释的都可以了，不动手进行设计  是不太容易理解的。

我以为你已经失踪了

楼主想问的是什么样子的场景吧？
我举一个抽象类的场景吧，你想开发一个兼容SqlServer和MySql的数据库操作类：

abstract class SqlHelper{

// 不知道具体实现是啥数据库，所以只能用抽象方法

abstract object GetFirstRec();

}



public class SqlServerHelper : SqlHelper {

    override object GetFirstRec(){

        var sql = "select top 1 * from tb";

        return xxx;

    }

}

public class MySqlHelper : SqlHelper {

    override object GetFirstRec(){

        var sql = "select * from tb limit 1";

        return xxx;

    }

}

再举一个虚方法的例子：
[code]abstract class Animal{
    // 动物移动，默认用脚走路，这个暂时不考虑没脚的
    virtual void Move(){
        Move on foot;
    }
}
public class Human : Animal {
    // 人只能用脚走路，所以不用重写   
}

public class Bird : Animal {
    // 为了性能，重写，鸟用翅膀飞
    virtual void Move(){
        Move on wing;
    }
}
[/code]

哈哈，可能不一定恰当，能理解就好，
实际场景中，看你的需要了。

从自己的项目里找了一个例子，缓存实现类，
有的业务要用内存缓存，有的业务不能用内存缓存，要用Redis缓存，
那么框架层要提供不同的实现，各业务根据需求修改配置文件，灵活变更自己想要的缓存方案：

// 缓存操作父类

public abstract class AbstractCache : ICache

{

    // 读取单个缓存，不同的缓存实现不同，所以无法提供默认实现

    public abstract T Get<T>(string key);

        

    // 批量读取缓存的默认实现

    public virtual IDictionary<string, T> GetAll<T>(IEnumerable<string> keys)

    {

        var resultDic = new Dictionary<string, T>();

        foreach (var item in items)

        {

            resultDic.Add(item, Get<T>(item));

        }

        return resultDic;

    }

}

下面是内存缓存实现，批量方法直接用父类的就ok了

// 基于 System.Web.HttpRuntime.Cache 运行时缓存的封装

public class HttpRuntimeCache : AbstractCache

{

    public override T Get<T>(string key)

    {

        var ret = HttpRuntime.Cache.Get(key);

        if (ret == null)

        {

            return default(T);

        }

        return ClonedCast<T>(ret);

    }

}

下面是Redis缓存实现，批量方法也可以直接用父类的，但是性能比较低下，所以重写了

public class RedisCache : AbstractCache

{

    public override T Get<T>(string key)

    {

        byte[] data;

        using (var client = GetManager().GetClient())

        {

            data = client.Get<byte[]>(key);

        }

        if (data == null)

            return default(T);

        return DeSerializ<T>(Encoding.UTF8.GetString(data));

    }

  

    // 批量读取缓存优化实现

    public override IDictionary<string, T> GetAll<T>(IEnumerable<string> keys)

    {

        IDictionary<string, byte[]> data;

        using (var client = GetManager().GetClient())

        {

            data = client.GetAll<byte[]>(keys);

        }

        var resultDic = new Dictionary<string, T>();

        foreach (var kvp in data)

        {

            resultDic.Add(kvp.Key, kvp.Value == null ? default(T) : DeSerializ<T>(Encoding.UTF8.GetString(kvp.Value)));

        }

        return resultDic;

    }

}

能不能顺便再问一下，接口应用场景，就是跟抽象方法的区别

能不能顺便再问一下，接口应用场景，就是跟抽象方法的区别

虚方法就是具有默认实现的抽象方法。

抽象方法其实是虚方法的特例。你看il代码，抽象方法会自动添加 virtual 的修饰符。既然抽象方法是虚方法的特例，那么它特殊就在，基类是抽象类没办法实现的情况。比如说一个抽象表示形状的类，它的“面积”就没有意义，必须是派生类（比如三角形类、四边形类、圆类等）去实现了。