C# 多态完全指南：静态多态与动态多态（重载、重写、虚方法）

多态意为"多种形态"。面向对象编程中常表达为"一个接口，多种功能"。多态分为静态和动态：

• 静态多态：编译时确定函数响应（早绑定）
• 动态多态：运行时决定函数响应（晚绑定）

静态多态

C# 通过两种技术实现静态多态：

• 函数重载
• 运算符重载（下章详解）

函数重载

同一作用域内可有多个同名函数定义，参数类型/数量不同即可。仅返回类型不同不能重载。

示例

using System;
namespace PolymorphismApplication {
    class Printdata {
        void print(int i) { Console.WriteLine("Printing int: {0}", i); }
        void print(double f) { Console.WriteLine("Printing float: {0}", f); }
        void print(string s) { Console.WriteLine("Printing string: {0}", s); }
        
        static void Main(string[] args) {
            Printdata p = new Printdata();
            p.print(5);          // Printing int: 5
            p.print(500.263);    // Printing float: 500.263
            p.print("Hello C#"); // Printing string: Hello C#
            Console.ReadKey();
        }
    }
}

动态多态

C# 允许创建抽象类提供接口的部分实现，派生类完成实现。抽象类包含抽象方法（无实现），由派生类实现。

抽象类规则

• 不能创建抽象类实例
• 抽象方法只能声明在抽象类中
• sealed 类不能继承，抽象类不能声明为 sealed

抽象类示例

using System;
namespace PolymorphismApplication {
    abstract class Shape {
        public abstract int area();
    }
    
    class Rectangle : Shape {
        private int length, width;
        public Rectangle(int a = 0, int b = 0) { length = a; width = b; }
        public override int area() {
            Console.WriteLine("Rectangle class area :");
            return width * length;
        }
    }
    
    class RectangleTester {
        static void Main(string[] args) {
            Rectangle r = new Rectangle(10, 7);
            double a = r.area();
            Console.WriteLine("Area: {0}", a);  // 70
            Console.ReadKey();
        }
    }
}

虚方法与动态分派

当基类方法需由派生类不同实现时，使用 virtual 关键字。调用在运行时根据实际对象类型决定。

虚方法示例

using System;
namespace PolymorphismApplication {
    class Shape {
        protected int width, height;
        public Shape(int a = 0, int b = 0) { width = a; height = b; }
        public virtual int area() {
            Console.WriteLine("Parent class area :");
            return 0;
        }
    }
    
    class Rectangle : Shape {
        public Rectangle(int a = 0, int b = 0) : base(a, b) { }
        public override int area() {
            Console.WriteLine("Rectangle class area :");
            return width * height;
        }
    }
    
    class Triangle : Shape {
        public Triangle(int a = 0, int b = 0) : base(a, b) { }
        public override int area() {
            Console.WriteLine("Triangle class area :");
            return width * height / 2;
        }
    }
    
    class Caller {
        public void CallArea(Shape sh) {
            int a = sh.area();
            Console.WriteLine("Area: {0}", a);
        }
    }
    
    class Tester {
        static void Main(string[] args) {
            Caller c = new Caller();
            Rectangle r = new Rectangle(10, 7);
            Triangle t = new Triangle(10, 5);
            c.CallArea(r);  // Rectangle class area: 70
            c.CallArea(t);  // Triangle class area: 25
            Console.ReadKey();
        }
    }
}

静态 vs 动态多态对比

核心原则：优先使用重载解决同一语义不同参数场景；需要运行时行为差异时使用虚方法/抽象方法。