【超详细】C#基础-面向对象三大特性：多态

yi碗汤园

已于 2024-12-24 21:10:11 修改

阅读量1.6k

点赞数 11

分类专栏： C# 文章标签： c# 开发语言前端

于 2024-11-26 19:00:00 首次发布

本文链接：https://blog.youkuaiyun.com/grapefruit_lyy/article/details/144057742

版权

C# 专栏收录该内容

25 篇文章

订阅专栏

今天来详细学习一下C#面向对象的三大特性：多态。

多态

多态（Polymorphism）是面向对象编程（OOP）中的一个核心概念，它允许对象以不同的方式表现出不同的行为。通过多态，子类可以在继承父类的方法时，修改或扩展父类的行为，甚至在运行时决定调用哪个类的方法，这使得程序更加灵活和可扩展。

1. 多态的概念

多态字面意思是“多种形态”，在面向对象编程中，多态指的是同一个方法或操作可以作用于不同的对象，并表现出不同的行为。

多态有两种主要形式

1）编译时多态（静态多态）：主要通过方法重载和方法隐藏来实现。

2）运行时多态（动态多态）：主要通过方法重写和接口实现来实现。

2. 多态的实现方式

1) 方法重载（编译时多态）

方法重载是指在同一个类中，可以定义多个相同名字但参数不同的方法。编译器会根据传入的参数类型和数量来决定调用哪个方法。

如，让Print方法根据不同的参数类型表现出不同的行为。

public class Printer
{
    //方法重载：不同的参数类型
    public void Print(string text)
    {
        Console.WriteLine("Printing text: " + text);
    }

    public void Print(int number)
    {
        Console.WriteLine("Printing number: " + number);
    }

    public void Print(double number)
    {
        Console.WriteLine("Printing double: " + number);
    }
}

public class Program
{
    public static void Main()
    {
        Printer printer = new Printer();
        printer.Print("Hello World!"); //调用 Print(string)
        printer.Print(123);            //调用 Print(int)
        printer.Print(45.67);          //调用 Print(double)
    }
}

2) 方法隐藏（编译时多态）

方法隐藏通常指的是在子类中定义一个与父类方法签名相同的方法，这会导致子类的方法隐藏父类的方法。与方法重写不同，方法隐藏在编译时就确定了哪个方法。使用new关键字来指示这是一个方法隐藏，而不是方法重写。

如，一个父类Animal和一个子类Dog，在子类中定义了一个与父类方法签名相同的方法

using System;

class Animal
{
    public void Sound()
    {
        Console.WriteLine("Animal makes a sound.");
    }
}

class Dog : Animal
{
    //隐藏父类的 Sound 方法
    public new void Sound()  
    {
        Console.WriteLine("Dog WangWang.");
    }
}

class Program
{
    static void Main()
    {
        Animal animal = new Dog();
        animal.Sound();//输出: Animal makes a sound.
        
        Dog dog = new Dog();
        dog.Sound();//输出: Dog WangWang.
    }
}

3) 方法重写（运行时多态）

方法重写是指子类重写父类的虚方法或抽象方法，从而改变父类方法的实现。运行时多态基于方法重写机制，允许通过父类引用调用子类的实现，实际调用的会是子类的重写版本，而不是父类的原始方法。

①虚方法(virtual)重写

虚方法重写是指在子类中重写父类的虚方法。

如，Animal类中的MakeSound方法使用virtual关键字声明，这意味着Dog类可以重写该方法。animal.MakeSound()在运行时会调用Dog类中的重写方法，而不是Animal类中的原始方法，这是因为方法重写发生在运行时，是基于对象的实际类型（Dog）进行动态绑定的

using System;

class Animal
{
    //虚方法，允许派生类重写
    public virtual void MakeSound()
    {
        Console.WriteLine("Animal makes a sound.");
    }
}

class Dog : Animal
{
    //重写基类的虚方法
    public override void MakeSound()
    {
        Console.WriteLine("Dog WangWang.");
    }
}

class Program
{
    static void Main()
    {
        Animal animal = new Dog();//父类引用指向子类对象
        animal.MakeSound();//输出: Dog WangWang.
    }
}

②抽象方法(abstract)重写

抽象方法重写是指子类实现父类抽象方法。父类抽象方法没有实现，子类必须提供具体实现。

如，Animal类中有一个抽象方法MakeSound()，并且Dog类必须实现这个方法。与虚方法重写类似，animal.MakeSound()在运行时会根据animal实际的类型（Dog）来调用Dog类中的重写方法。

using System;

abstract class Animal
{
    //抽象方法，没有实现
    public abstract void MakeSound();
}

class Dog : Animal
{
    //重写抽象方法，必须实现具体的功能
    public override void MakeSound()
    {
        Console.WriteLine("Dog WangWang.");
    }
}

class Program
{
    static void Main()
    {
        Animal animal = new Dog();//父类引用指向子类对象
        animal.MakeSound();//输出: Dog WangWang.
    }
}

4) 接口实现（运行时多态）

接口是一个定义一组方法签名的合同，类可以通过实现接口来提供这些方法的具体实现。接口的实现也支持多态，可以通过接口类型引用来调用不同类的实现。

如，IDrawable 接口定义了Draw方法，Circle和Rectangle类实现了该接口。通过接口类型IDrawable引用，可以实现对不同形状对象的多态调用。

public interface IDrawable
{
    void Draw();
}

public class Circle : IDrawable
{
    public void Draw()
    {
        Console.WriteLine("Drawing a circle.");
    }
}

public class Rectangle : IDrawable
{
    public void Draw()
    {
        Console.WriteLine("Drawing a rectangle.");
    }
}

public class Program
{
    public static void Main()
    {
        IDrawable shape1 = new Circle();
        IDrawable shape2 = new Rectangle();

        shape1.Draw();//输出：Drawing a circle.
        shape2.Draw();//输出：Drawing a rectangle.
    }
}