虚拟和抽象方法之间的区别

Question

以下是MSDN的一些代码:

// compile with: /target:library 
public class D
{
    public virtual void DoWork(int i)
    {
        // Original implementation.
    }
}

public abstract class E : D
{
    public abstract override void DoWork(int i);
}

public class F : E
{
    public override void DoWork(int i)
    {
        // New implementation.
    }
}

任何人都可以解释上面的代码关于抽象和虚方法之间的差异？

Answer 1

虚方法有一个实现,并为派生类提供了覆盖它的选项.抽象方法不提供实现,并强制派生类重写该方法.

因此,抽象方法中没有实际代码,子类HAVE TO覆盖该方法.虚方法可以有代码,通常是某些东西的默认实现,任何子类CAN都可以使用override修饰符覆盖方法并提供自定义实现.

public abstract class E
{
    public abstract void AbstractMethod(int i);

    public virtual void VirtualMethod(int i)
    {
        // Default implementation which can be overridden by subclasses.
    }
}

public class D : E
{
    public override void AbstractMethod(int i)
    {
        // You HAVE to override this method
    }
    public override void VirtualMethod(int i)
    {
        // You are allowed to override this method.
    }
}

Answer 2

首先,您应该了解虚拟方法和抽象方法之间的区别.

抽象方法

• 抽象方法驻留在抽象类中,它没有主体.
• 必须在非抽象子类中重写Abstract方法.

虚方法

• 虚方法可以驻留在抽象类和非抽象类中.
• 没有必要在派生中覆盖虚方法,但它可以.
• 虚方法必须有body ....可以被"override keyword"覆盖.....

Answer 3

抽象方法：

• 如果在类中定义了抽象方法，则该类应声明为抽象类。

• 抽象方法应仅包含方法定义，而不应包含方法主体/实现。

• 抽象方法必须超越派生类。

虚方法：

• 虚方法可以在派生类中超越，但不是强制性的。
• 虚拟方法必须具有方法主体/实现以及定义。

例：

public abstract class baseclass
        {
            public abstract decimal getarea(decimal Radius);

            public virtual decimal interestpermonth(decimal amount)

            {
                return amount*12/100;
            }
            public virtual decimal totalamount(decimal Amount,decimal principleAmount)
            {
                return Amount + principleAmount;
            }
        }

        public class derivedclass:baseclass
        {
            public override decimal getarea(decimal Radius)
            {
                return 2 * (22 / 7) * Radius;
            }
            public override decimal interestpermonth(decimal amount)
            {
                return amount * 14 / 100;
            }

        }

Answer 4

抽象方法必须在派生类中调用 override 否则它会给出编译时错误，并且在虚拟中你可能会或可能不会覆盖它取决于它是否足够好使用它

例子：

abstract class twodshape
{
    public abstract void area(); // no body in base class
}

class twodshape2 : twodshape
{
    public virtual double area()
    {
        Console.WriteLine("AREA() may be or may not be override");
    }
}