C# 多态性

多态性 ：分为静态多态和动态多态

1.静态多态

相同一个方法名  参数的数量或者类型不一样，这就是静态多态。

 public int Getvlue(int x, int y)
 { 
 return x + y;
 }
 public string Getvlue(string x, string y)
 {
     return x + y;
 }

 

2.动态多态

有抽象类 ：不同的子类去继承抽象类的方法，实现不同的功能，这也是多态

下面表示的就是在调用用的时候实例化谁，就代表调用谁

using System;

// 抽象基类：定义图形的核心行为（必须实现的抽象方法 + 可重写的虚方法）
public abstract class Shape
{
    // 抽象属性：图形名称（必须在派生类中实现）
    public abstract string Name { get; }
    
    // 抽象方法：计算面积（必须在派生类中重写，无默认实现）
    public abstract double CalculateArea();
    
    // 虚方法：获取图形信息（可在派生类中重写，有默认实现）
    public virtual string GetInfo()
    {
        return $"图形：{Name}，面积：{CalculateArea():F2}";
    }
}

// 派生类：圆（实现抽象类的所有抽象成员）
public class Circle : Shape
{
    private double _radius; // 半径
    
    public Circle(double radius)
    {
        _radius = radius;
    }
    
    // 实现抽象属性
    public override string Name => "圆";
    
    // 实现抽象方法：计算圆面积（πr²）
    public override double CalculateArea()
    {
        return Math.PI * _radius * _radius;
    }
    
    // 可选：重写虚方法（扩展信息）
    public override string GetInfo()
    {
        return base.GetInfo() + $"，半径：{_radius}";
    }
}

// 派生类：矩形（实现抽象类的所有抽象成员）
public class Rectangle : Shape
{
    private double _length; // 长
    private double _width;  // 宽
    
    public Rectangle(double length, double width)
    {
        _length = length;
        _width = width;
    }
    
    // 实现抽象属性
    public override string Name => "矩形";
    
    // 实现抽象方法：计算矩形面积（长×宽）
    public override double CalculateArea()
    {
        return _length * _width;
    }
    
    // 可选：重写虚方法（扩展信息）
    public override string GetInfo()
    {
        return base.GetInfo() + $"，长：{_length}，宽：{_width}";
    }
}

public class Program
{
    public static void Main()
    {
        // 多态体现：抽象基类变量引用不同派生类对象
        Shape[] shapes = new Shape[2];
        shapes[0] = new Circle(5);       // 圆（半径5）
        shapes[1] = new Rectangle(4, 6); // 矩形（长4，宽6）
        
        // 遍历图形数组，调用相同方法，执行不同实现
        foreach (var shape in shapes)
        {
            Console.WriteLine(shape.GetInfo());
            // 输出结果：
            // 图形：圆，面积：78.54，半径：5
            // 图形：矩形，面积：24.00，长：4，宽：6
        }
    }
}

 

有虚方法：子类集成父类的虚方法，来实现

 这里就是子类继承了父类，在实例化的时候，实例谁就代表是调用谁

using System;

// 1. 基类：定义虚方法
public class Animal
{
    // 虚方法：允许派生类重写
    public virtual void MakeSound()
    {
        Console.WriteLine("动物发出声音");
    }
}

// 2. 派生类：重写基类虚方法
public class Dog : Animal
{
    // 重写基类的虚方法
    public override void MakeSound()
    {
        Console.WriteLine("狗汪汪叫");
    }
}

public class Cat : Animal
{
    public override void MakeSound()
    {
        Console.WriteLine("猫喵喵叫");
    }
}

public class Program
{
    public static void Main()
    {
        // 3. 向上转型：基类变量引用派生类对象
        Animal animal1 = new Dog();  // 实际类型是 Dog
        Animal animal2 = new Cat();  // 实际类型是 Cat
        Animal animal3 = new Animal(); // 实际类型是 Animal

        // 运行时自动调用对象实际类型的方法
        animal1.MakeSound();  // 输出：狗汪汪叫（调用 Dog 的实现）
        animal2.MakeSound();  // 输出：猫喵喵叫（调用 Cat 的实现）
        animal3.MakeSound();  // 输出：动物发出声音（调用 Animal 的实现）
    }
}