C#虛方法、重寫方法和抽象方法

若一個實例方法的聲明中含有 virtual 修飾符，則稱該方法為虛方法 (virtual method)。若其中沒有 virtual 修飾符，則稱該方法為非虛方法 (non-virtual method)。

在調用一個虛方法時，該調用所涉及的那個實例的運行時類型 (runtime type) 確定了要被調用的究竟是該方法的哪一個實現。在非虛方法調用中，實例的編譯時類型 (compile-time type) 是決定性因素。

虛方法可以在派生類中重寫 (override)。當某個實例方法聲明包括 override 修飾符時，該方法將重寫所繼承的具有相同簽名的虛方法。虛方法聲明用於引入新方法，而重寫方法聲明則用於使現有的繼承虛方法專用化（通過提供該方法的新實現）。

抽象 (abstract) 方法是沒有實現的虛方法。抽象方法使用 abstract 修飾符進行聲明，並且只有在同樣被聲明為 abstract 的類中才允許出現。抽象方法必須在每個非抽象派生類中重寫。

下面的示例聲明一個抽象類 Expression，它表示一個表達式樹節點；它有三個派生類 Constant、VariableReference 和 Operation，它們分別實現了常量、變量引用和算術運算的表達式樹節點。

Expression 實例的 Evaluate 方法將被調用，以計算給定的表達式的值，從而產生一個 double 值。該方法接受一個包含變量名稱（作為哈希表項的鍵）和值（作為項的值）的 Hashtable 作為參數。Evaluate 方法是一個虛抽象方法，意味着非抽象派生類必須重寫該方法以提供具體的實現。

Constant 的 Evaluate 實現只是返回所存儲的常量。VariableReference 的實現在哈希表中查找變量名稱，並返回產生的值。Operation 的實現先對左操作數和右操作數求值（通過遞歸調用它們的 Evaluate 方法），然后執行給定的算術運算。

下面的程序使用 Expression 類，對於不同的 x 和 y 值，計算表達式 x * (y + 2) 的值。

using System;
using System.Collections;
namespace Virtual_override_abstract_method
{
    class Program
    {
        static void Main(string[] args)
        {
            Expression e = new Operation(
            new VariableReference("x"),
            '*',
            new Operation(
                new VariableReference("y"),
                '+',
                new Constant(2)
                ));
            Hashtable vars = new Hashtable();
            vars["x"] = 3;
            vars["y"] = 5;
            Console.WriteLine(e.Evaluate(vars));        // Outputs "21" 
            Console.Read();

        }
    }
    public abstract class Expression
    {
        public abstract double Evaluate(Hashtable vars);
    }
    public class Constant : Expression
    {
        double value;
        public Constant(double value)
        {
            this.value = value;
        }
        public override double Evaluate(Hashtable vars)
        {
            return value;
        }
    }
    public class VariableReference : Expression
    {
        string name;
        public VariableReference(string name)
        {
            this.name = name;
        }
        public override double Evaluate(Hashtable vars)
        {
            object value = vars[name];
            if (value == null)
            {
                throw new Exception("Unknown variable: " + name);
            }
            return Convert.ToDouble(value);
        }
    }
    public class Operation : Expression
    {
        Expression left;
        char op;
        Expression right;
        public Operation(Expression left, char op, Expression right)
        {
            this.left = left;
            this.op = op;
            this.right = right;
        }
        public override double Evaluate(Hashtable vars)
        {
            double x = left.Evaluate(vars);
            double y = right.Evaluate(vars);
            switch (op)
            {
                case '+': return x + y;
                case '-': return x - y;
                case '*': return x * y;
                case '/': return x / y;
            }
            throw new Exception("Unknown operator");
        }
    }
}