C# 多态性的实现： 继承和接口

在C#中，多态是面向对象编程的一个重要概念。它允许我们使用同一个方法名来调用不同对象的方法，而具体执行的方法实现是根据对象的类型来确定的。

C#中实现多态的方式主要有两种：继承和接口。

1.继承多态：
继承多态是通过创建一个父类，然后在子类中重写父类的方法来实现的。当使用父类的引用指向子类的对象时，可以根据实际对象的类型来调用相应的方法。这样可以提高代码的复用性和可扩展性。

第一个示例是父类引用子类的实现，Animal类是父类，Dog和Cat是其子类。通过将子类的实例赋值给父类的引用，然后调用相同的方法名，实现了多态。在 C# 中，通过父类引用子类的实现可以实现多态性（声明父类，指向子类），这样可以提高代码的灵活性和可维护性。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 多态
{
    // 父类引用子类的实现示例
    class Animal
    {
        public virtual void MakeSound()
        {
            Console.WriteLine("Some sound");
        }
    }

    class Dog : Animal
    {
        public override void MakeSound()
        {
            Console.WriteLine("Woof! Woof!");
        }
    }

    class Cat : Animal
    {
        public override void MakeSound()
        {
            Console.WriteLine("Meow! Meow!");
        }
    }

    class Program
    {
        internal static void Main()
        {
            Animal dog = new Dog();
            Animal cat = new Cat();

            dog.MakeSound(); // 输出: Woof! Woof!
            cat.MakeSound(); // 输出: Meow! Meow!

            MakeAnimalSound(dog); // 输出: Woof! Woof!
            MakeAnimalSound(cat); // 输出: Meow! Meow!
        }

        static void MakeAnimalSound(Animal animal)
        {
            animal.MakeSound();
        }
    }
   
}

2.接口多态：
接口多态是通过定义接口并在类中实现接口的方法来实现的。一个类可以实现多个接口，然后根据需要将对象赋值给相应的接口引用，从而调用不同的方法。

第二个示例是接口引用实现接口的类。IShape是一个接口，Circle和Rectangle类都实现了该接口。通过将实现了接口的对象赋值给接口引用，然后调用接口定义的方法，实现了多态。使用接口引用实现接口的类可以实现接口的多重继承（声明接口，指向实现接口的类），从而使得类具备多个接口的功能和行为。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 多态
{// 接口引用实现接口的类示例
    interface IShape
    {
        double GetArea();
    }

    class Circle : IShape
    {
        private double radius;

        public Circle(double r)
        {
            radius = r;
        }

        public double GetArea()
        {
            return Math.PI * radius * radius;
        }
    }

    class Rectangle : IShape
    {
        private double width;
        private double height;

        public Rectangle(double w, double h)
        {
            width = w;
            height = h;
        }

        public double GetArea()
        {
            return width * height;
        }
    }

    class Program
    {
        static void Main()
        {
            IShape circle = new Circle(5.0);
            IShape rectangle = new Rectangle(4.0, 6.0);

            Console.WriteLine("Circle Area: " + circle.GetArea());       // 输出: Circle Area: 78.53981633974483
            Console.WriteLine("Rectangle Area: " + rectangle.GetArea()); // 输出: Rectangle Area: 24

            PrintShapeArea(circle);    // 输出: Shape Area: 78.53981633974483
            PrintShapeArea(rectangle); // 输出: Shape Area: 24
        }

        static void PrintShapeArea(IShape shape)
        {
            Console.WriteLine("Shape Area: " + shape.GetArea());
        }
    }
}

无论是继承多态还是接口多态，多态的核心思想都是通过父类或接口引用指向子类的对象，然后根据实际对象的类型来调用相应的方法。这种灵活性使得代码更加可扩展和易于维护。

1. 父类引用子类的实现：

   • 允许我们使用父类的引用来指向一个子类的对象。这样做的好处是可以统一处理不同子类的对象，从而减少重复的代码。
   • 当我们使用父类的引用调用方法时，实际上会调用子类重写的方法，这就是多态性的体现。这样的设计可以提高代码的灵活性和可扩展性。

2. 接口引用实现接口的类：

   • 接口引用是一种更抽象的方式，它允许我们统一处理不同实现了同一接口的类的对象。
   • 通过接口引用实现类的对象，我们可以隐藏对象的具体类型，而只关心对象提供的接口。这样可以降低代码耦合度，提高代码的可维护性和可测试性。

总的来说，这两种方式都能够帮助我们实现代码的重用、增强代码的灵活性，以及更好地支持面向对象编程的原则。