抽象方法和虚方法有什么区别？

Question

抽象方法和虚方法有什么区别？ 在什么情况下建议使用抽象或虚拟方法？ 哪一种是最好的方法？

Answer 1

抽象函数不能具有功能。您基本上是说，任何子类都必须提供自己的此方法的版本，但是它太笼统，甚至无法尝试在父类中实现。

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

Answer 2

抽象函数没有实现，只能在抽象类上声明。 这迫使派生类提供实现。

虚函数提供默认实现，它可以存在于抽象类或非抽象类中。

例如：

public abstract class myBase
{
    //If you derive from this class you must implement this method. notice we have no method body here either
    public abstract void YouMustImplement();

    //If you derive from this class you can change the behavior but are not required to
    public virtual void YouCanOverride()
    { 
    }
}

public class MyBase
{
   //This will not compile because you cannot have an abstract method in a non-abstract class
    public abstract void YouMustImplement();
}

Answer 3

1. 只有abstract 类可以拥有abstract 成员。
2. 从 abstract 类继承的非abstract类必须覆盖其abstract成员。
3. abstract 成员隐式是virtual。
4. abstract 成员无法提供任何实现（abstract 在某些语言中称为 pure virtual）。

Answer 4

您必须始终重写抽象函数。

因此：

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

Answer 5

抽象函数：

1. 只能在抽象类中声明。
2. 它仅包含
   方法声明而不是抽象类中的实现。
3. 必须在派生类中重写它。

虚函数：

1. 可以在抽象类和非抽象类中声明。
2. 它包含方法实现。
3. 它可能会被覆盖。

Answer 6

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

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

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

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

Answer 7

抽象方法是必须实现才能形成具体类的方法。 声明位于抽象类中（任何具有抽象方法的类都必须是抽象类）并且必须在具体类中实现。

虚拟方法是可以使用重写在派生类中重写的方法，替换超类中的行为。 如果您不覆盖，您将获得原始行为。 如果这样做，您总是会得到新的行为。 这与非虚拟方法相反，非虚拟方法不能被覆盖但可以隐藏原始方法。 这是使用 new 修饰符完成的。

请参阅以下示例：

public class BaseClass
{
    public void SayHello()
    {
        Console.WriteLine("Hello");
    }


    public virtual void SayGoodbye()
    {
        Console.WriteLine("Goodbye");
    }

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


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


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

当我实例化 DerivedClass 并调用 SayHello 或 SayGoodbye 时，我得到“Hi There”和“See you later”。 如果我拨打 HelloGoodbye，我会收到“Hello”和“See you later”。 这是因为 SayGoodbye 是虚拟的，可以用派生类替换。 SayHello 只是隐藏的，所以当我从基类调用它时，我得到了原始方法。

抽象方法是隐式虚拟的。 它们定义了必须存在的行为，更像是界面。

Answer 8

抽象方法始终是虚拟的。 他们无法实施。

这是主要的区别。

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

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

Answer 9

我通过对以下类进行一些改进（来自其他答案）使这变得更简单：

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

Answer 10

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

后期绑定意味着我们使用名称，但推迟映射。 换句话说，我们首先创建/提及名称，然后让某些后续进程处理代码到该名称的映射。

现在考虑一下：

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

所以，简短的答案是： virtual 是机器的后期绑定指令（运行时）而 abstract 是人类（程序员）的后期绑定指令。

换句话说，virtual 的意思是：

“亲爱的运行时，绑定通过做你最擅长的事情来将适当的代码绑定到这个名字：搜索”

而abstract的意思是：

“亲爱的程序员，请将适当的代码绑定到这个通过做你最擅长的事情来命名：发明”

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

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

Answer 11

当您希望继承者根据需要扩展功能时，您基本上可以使用虚拟方法。

当您希望继承者实现功能时，您可以使用抽象方法（在这种情况下他们别无选择）

Answer 12

虚拟方法：

• 虚拟意味着我们可以覆盖它。

• 虚拟函数有一个实现。 当我们继承该类时
  可以重写虚函数并提供我们自己的逻辑。

• 我们可以在实现时更改虚函数的返回类型
  子类中的函数（可以说是一个概念
  阴影）。

抽象方法

• 抽象意味着我们必须重写它。

• 抽象函数没有实现，必须位于抽象类中。

• 只能声明。 这迫使派生类提供它的实现。

• 抽象成员是隐式虚拟的。 抽象在某些语言中可以称为纯虚拟。

  公共抽象类BaseClass 
    {  
        受保护的抽象无效 xAbstractMethod(); 
  
        公共虚拟无效xVirtualMethod（） 
        { 
            var x = 3 + 4; 
        } 
    }  
    

Answer 13

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

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

**
我感觉就像是。

抽象方法不一定要在子类中实现，如果子类也是抽象的 ..

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

我想说..如果我们要实现一个抽象类，您必须重写抽象基类中的抽象方法。
因为.. 实现抽象方法是用override关键字。类似于Virtual方法。

没有必要在继承类中实现虚方法。

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

Answer 14

上面的大多数示例都使用代码 - 而且它们非常非常好。 我不需要补充他们所说的内容，但以下是使用类比而不是代码/技术术语的简单解释。

简单解释 - 使用类比进行解释

抽象方法

想想乔治·W·布什。 他对他的士兵说：“去伊拉克战斗吧”。 就是这样。 他所指定的只是必须进行战斗。 他没有具体说明这将如何发生。 但我的意思是，你不能只是出去“战斗”：这到底意味着什么？ 我该用 B-52 作战还是用我的德林格战机作战？ 这些具体细节留给其他人。 这是一个抽象方法。

虚拟方法

大卫·彼得雷乌斯 (David Petraeus) 在军队中身居高位。 他定义了战斗的含义：

1. 找到敌人
2. 并压制他。
3. 之后喝杯啤酒

问题是这是一个非常通用的方法。 这是一个有效的好方法，但有时不够具体。 对彼得雷乌斯来说，好处是他的命令有回旋余地和范围——他允许其他人根据他们的具体要求改变他对“战斗”的定义。

私人工作博客阅读了彼得雷乌斯的命令，并被允许根据他的特殊要求实施他自己的战斗版本：

1. 找到敌人。
2. 朝他的头开枪。
3. 回家
4. 喝啤酒吧

努里·马利基也收到了彼得雷乌斯的同样命令。 他也要战斗。 但他是一名政治家，而不是一名步兵。 显然，他不能四处射击他的政敌。 因为彼得雷乌斯给了他一个虚拟方法，那么马利基就可以根据他的具体情况实现他自己版本的战斗方法：

1. 找到敌人。
2. 用一些胡言乱语捏造的罪名逮捕他。
3. 回家
4. 喝啤酒吧

换句话说，虚拟方法提供了样板指令 - 但这些是一般指令，可以由军队等级制度下的人们根据他们的具体情况制定更具体的指令。

两者的区别

• 乔治·布什没有证明任何实现细节。 这必须由其他人提供。 这是一个抽象方法。

• 另一方面，彼得雷乌斯确实提供了实施细节，但他允许他的下属用他们自己的版本覆盖他的命令，如果他们能想出更好的东西的话。

希望有帮助。

Answer 15

抽象函数（方法）：

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

● 没有本体。

● 应由派生类实现。

● 如果方法是抽象的，则该类也应该是抽象的。

虚函数（方法）：

● 虚方法是用关键字virtual 声明的方法，并且可以通过使用override 关键字被派生类方法覆盖。

● 是否覆盖它取决于派生类。

Answer 16

答案已经提供了多次，但何时使用每个答案的问题是设计时的决定。 我认为尝试将通用方法定义捆绑到不同的接口中并将它们拉入适当抽象级别的类中是一种很好的做法。 当最好定义一个实现一组简洁接口的非抽象类时，将一组通用的抽象和虚拟方法定义转储到一个类中会使该类变得不可实例化。 与往常一样，这取决于最适合您应用程序特定需求的方式。

Answer 17

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

虚拟函数将有主体，并且可能会也可能不会被子类重写

Answer 18

从一般面向对象的角度来看：

关于抽象方法：当你在父类中放置一个抽象方法时，你实际上是在对子类说：嘿，请注意，你有一个像这样的方法签名。 如果你想使用它，你应该实现你自己的！

关于虚函数：当您将虚方法放入父类中时，您就是在对派生类说：嘿，这里有一个功能可以为您做一些事情。 如果这对您有用，请使用它。 如果没有，请覆盖它并实现您的代码，甚至您可以在您的代码中使用我的实现！

这是关于通用 OO 中这两个概念之间差异的一些哲学

Answer 19

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

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

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

Answer 20

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

Answer 21

如果一个类派生自该抽象类，则它必须重写该抽象成员。 这与 virtual 修饰符不同，virtual 修饰符指定可以选择覆盖该成员。

Answer 22

C# 中没有所谓的虚拟类。

对于

1. 只有签名的抽象函数，驱动类应该用功能重写。
2. 虚拟功能将保留驱动器类可能会或可能不会根据要求覆盖它的部分功能，

您可以根据您的要求决定。

Answer 23

抽象方法没有实现。它在父类中声明。 子类负责实现该方法。

虚方法应该在父类中有一个实现，它方便子类选择是使用父类的该实现还是在子类中为该方法自己拥有一个新的实现。

Answer 24

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

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

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

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

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

我们可以结合使用抽象方法和虚函数来支持良好的继承模型。

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

Answer 25

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

Answer 26

图——传统的三重命题分类。

在道义逻辑（对义务和许可的研究）中，每个命题都是强制（“必须”运算符）、可选（“可能和可能不”运算符）或不允许（“不得”运算符），并且没有一个命题属于这三个类别中的一个以上。

此外，允许（“可以”运算符）命题是那些强制性或可选的命题，可忽略（“可能不”运算符）命题是那些不允许或可选的命题，以及非可选（“必须或不能”运算符）命题是那些强制或不允许的命题。

特别是，强制性命题是允许的，而不允许的命题是可省略的。

将这些运算符应用于命题“该方法被重写”会产生以下命题：

• 抽象（纯）/具体方法：该方法必须被重写/可能不会被重写；
• 虚拟/真实（最终）方法：该方法可以被覆盖/不得被覆盖。

具体来说，抽象方法是虚拟的，而真实方法是具体的。

Answer 27

据我的理解：

抽象方法：

只有抽象类才能保存抽象方法。 派生类也需要实现该方法，并且类中没有提供实现。

虚拟方法：

类可以声明这些方法并提供它们的实现。 派生类还需要实现该方法来重写它。