在面向对象编程中，多态性（Polymorphism）是实现代码灵活性和可扩展性的关键。本篇文章将详细介绍两种实现多态性的技术：方法重载（Method Overloading）和方法重写（Method Overriding），并展示 C# 13 中的一些新特性，如增强的模式匹配，如何与这些技术结合使用。

---

方法重载

介绍与定义

方法重载允许我们在同一个类中定义多个名称相同但参数列表不同的方法。编译器会根据调用时传入参数的数量和类型决定调用那一个方法，因此重载属于编译时多态（compile-time polymorphism）。需要注意的是，仅仅返回类型不同不足以区分两个重载方法。

代码示例

下面的示例展示了一个简单的计算器类，它提供了多个名为 Add 的方法，用于实现不同参数类型和数量的加法操作：

C#
namespace AppC13
{
    public class Calculator
    {
        // 重载示例 1: 两个整数相加
        public int Add(int a, int b)
        {
            return a + b;
        }

        // 重载示例 2: 三个整数相加
        public int Add(int a, int b, int c)
        {
            return a + b + c;
        }

        // 重载示例 3: 两个双精度浮点数相加
        public double Add(double a, double b)
        {
            return a + b;
        }

        // 重载示例 4: 使用对象实现不同类型的“加法” —— 此处采用字符串拼接示例
        public string Add(object a, object b)
        {
            // 为演示不同的参数类型，使用 ToString() 方法进行拼接
            return a.ToString() + b.ToString();
        }

        // 示例：利用 C# 13 的增强模式匹配（Pattern Matching）进行更复杂的参数处理
        // 这个我在实际项目中就没用过
        public string ProcessValue(object value)
        {
            // 使用 switch 表达式和模式匹配，根据传入的数值类型返回不同的描述
            return value switch
            {
                int number when number > 100 => "大整数",
                int _ => "整数",
                string text => $"字符串: {text}",
                _ => "未知类型"
            };
        }
    }

    // 测试重载功能
    class Program
    {
        static void Main(string[] args)
        {
            var calc = new Calculator();
            Console.WriteLine("Add(int, int): " + calc.Add(10, 20));    
            Console.WriteLine("Add(int, int, int): " + calc.Add(10, 20, 30)); 
            Console.WriteLine("Add(double, double): " + calc.Add(10.5, 20.3));   
            Console.WriteLine("Add(object, object): " + calc.Add("Hello", "World")); 

            // 测试增强模式匹配
            Console.WriteLine("ProcessValue(150): " + calc.ProcessValue(150));  
            Console.WriteLine("ProcessValue(50): " + calc.ProcessValue(50));      
            Console.WriteLine("ProcessValue(\"Test\"): " + calc.ProcessValue("Test")); 
        }
    }
}

---

方法重写

介绍与定义

方法重写允许派生类重新定义从基类继承来的方法，以提供特定于派生类的实现。方法重写属于运行时多态（runtime polymorphism）。实现重写有两个基本要求：

• 基类方法必须使用 virtual 关键字标记，表明此方法可以被重写。
• 派生类重写方法时必须使用 override 关键字，同时方法签名必须完全一致。

代码示例

以下示例展示了一个简单的动物类层次结构，其中基类 Animal 定义了一个虚方法 Speak，而派生类 Dog 和 Cat 分别重写了该方法以实现不同的行为：

C#
namespace AppC13
{
    // 基类 Animal
    public class Animal
    {
        // 定义虚方法，用 virtual 标记，允许派生类重写
        public virtual void Speak()
        {
            Console.WriteLine("Animal speaks...");
        }
    }

    // 派生类 Dog 重写 Animal 的 Speak 方法
    public class Dog : Animal
    {
        public override void Speak()
        {
            Console.WriteLine("Dog barks: Woof Woof!");
        }
    }

    // 派生类 Cat 重写 Animal 的 Speak 方法
    public class Cat : Animal
    {
        public override void Speak()
        {
            Console.WriteLine("Cat meows: Meow!");
        }
    }

    // 测试方法重写功能
    class Program
    {
        static void Main(string[] args)
        {
            Animal animal = new Animal();
            Animal dog = new Dog();
            Animal cat = new Cat();

            // 调用各自的 Speak() 方法，运行时会根据对象类型选择相应实现
            Console.Write("Animal: ");
            animal.Speak(); 
            Console.Write("Dog: ");
            dog.Speak(); 
            Console.Write("Cat: ");
            cat.Speak(); 
        }
    }
}

---

方法重载与方法重写的对比

特性	方法重载	方法重写
多态性	编译时多态（Compile-time polymorphism）	运行时多态（Runtime polymorphism）
方法名称	相同，但参数列表需不同	方法名称与参数列表相同
关键字	无须特殊关键字（仅依赖方法签名区分）	基类使用 virtual，派生类使用 override
作用范围	同一类中	基类与派生类间
绑定时机	编译期绑定	运行时动态绑定

---

C# 13 的新特性与应用

C# 13 在传统语言特性基础上进一步增强了模式匹配和方法签名，使代码更加表达式化和可维护。例如，通过在重载方法中结合模式匹配，可以编写出对各种输入进行自动分发的代码，让方法接口更灵活。

在上面的重载示例中，ProcessValue 方法就是利用增强的模式匹配实现；它不仅判断数据类型，还可以依据数值范围和条件返回不同结果，从而大大提升了代码优势和实用性。

此外，C# 13 对于方法签名的增强也使得开发者在定义重载或重写方法时能更好地表达意图和行为，从而减少出错的可能并提高代码可读性。

---

总结

• 方法重载使得我们能在同一类中使用相同方法名称但不同参数列表来实现多种功能，属于编译时多态。
• 方法重写允许派生类重新定义基类中已有的方法，提供运行时多态，实现灵活的动态行为。
• C# 13 的增强模式匹配和方法签名特性进一步提高了代码表达能力和可维护性，适用于更复杂的业务需求。

通过合理地使用方法重载与方法重写，我们可以让代码更简洁、灵活并易于扩展，使面向对象开发更加高效和直观。