C# 中的多态

多态是面向对象编程语言中的重要特性之一。它允许不同的对象在相同的方法调用下表现出不同的行为。在 C# 中，我们可以使用继承、接口、抽象类等方式来实现多态。

继承与多态

继承是多态的一种方式。子类可以重写父类的方法并实现自己的逻辑。当我们在父类中调用此方法时，实际执行的是子类中重写的方法。

以下是一个简单的例子：

class Animal
{
    public virtual void Speak()
    {
        Console.WriteLine("Animal speaks.");
    }
}

class Dog : Animal
{
    public override void Speak()
    {
        Console.WriteLine("Dog barks.");
    }
}

class Cat : Animal
{
    public override void Speak()
    {
        Console.WriteLine("Cat meows.");
    }
}

class Program
{
    static void Main(string[] args)
    {
        Animal dog = new Dog();
        Animal cat = new Cat();

        dog.Speak(); // Output: Dog barks.
        cat.Speak(); // Output: Cat meows.

        Console.ReadKey();
    }
}

在这个例子中，我们定义了一个抽象类 Animal，并在其中定义了一个虚方法 Speak()。我们又定义了两个具体类 Dog 和 Cat，它们都继承于 Animal 并重写了 Speak() 方法。在 Main() 函数中，我们通过实例化子类并将它们赋值给父类变量来实现多态。

接口与多态

接口也是实现多态的一种方式。接口定义了一些方法、属性或事件的规范，让实现接口的类保持一致的行为。这种行为一致也让我们能够在不关心对象实现的情况下对其进行操作。

以下是一个使用接口实现多态的例子：

interface IShape
{
    void Draw();
}

class Circle : IShape
{
    public void Draw()
    {
        Console.WriteLine("Circle is drawn.");
    }
}

class Rect : IShape
{
    public void Draw()
    {
        Console.WriteLine("Rectangle is drawn.");
    }
}

class Program
{
    static void Main(string[] args)
    {
        IShape circle = new Circle();
        IShape rect = new Rect();

        circle.Draw(); // Output: Circle is drawn.
        rect.Draw(); // Output: Rectangle is drawn.

        Console.ReadKey();
    }
}

在这个例子中，我们定义了一个接口 IShape 并在其中定义了方法 Draw()。我们又定义了两个具体类 Circle 和 Rect，它们都实现了 IShape 接口并实现了 Draw() 方法。在 Main() 函数中，我们通过实例化实现接口的类并将它们赋值给接口类型变量来实现多态。

抽象类与多态

抽象类同样是多态的一种方式。抽象类本身不能被实例化，但是可以被继承。在子类中重写抽象类的抽象方法，从而实现多态。

以下是一个使用抽象类实现多态的例子：

abstract class Shape
{
    public abstract double Area();
}

class Triangle : Shape
{
    public double Base { get; set; }
    public double Height { get; set; }

    public override double Area()
    {
        return 0.5 * Base * Height;
    }
}

class Rectangle : Shape
{
    public double Width { get; set; }
    public double Height { get; set; }

    public override double Area()
    {
        return Width * Height;
    }
}

class Program
{
    static void Main(string[] args)
    {
        Shape triangle = new Triangle() { Base = 4, Height = 3 };
        Shape rectangle = new Rectangle() { Width = 5, Height = 2 };

        Console.WriteLine($"Triangle area: {triangle.Area()}"); // Output: Triangle area: 6
        Console.WriteLine($"Rectangle area: {rectangle.Area()}"); // Output: Rectangle area: 10

        Console.ReadKey();
    }
}

在这个例子中，我们定义了一个抽象类 Shape 并在其中定义了抽象方法 Area()。我们又定义了两个具体类 Triangle 和 Rectangle，它们都继承于 Shape 并重写了 Area() 方法。在 Main() 函数中，我们通过实例化子类并将它们赋值给父类变量来实现多态。

总结

C# 中的多态是实现面向对象编程的关键之一。使用继承、接口、抽象类等方式可以实现多态。多态让我们能够以一种统一的方式处理不同的对象，从而使程序变得更加灵活和可扩展。