C#中的多态

本文深入解析了C#中的多态性概念,通过实例展示了如何通过派生类覆写基类中的虚函数来实现多态性,并详细说明了其核心原理与应用场景。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

        

        一、首先理解一下什么叫多态:

        同一种操作作用于不同的对象,可以有不同的解释,产生不同的执行结果,这就是多态性。举一个形象的例子,在我们听音乐会的时候,当指挥发出开始的信号,不同的乐器收到相同的信号,但是他们产生不同的行为:钢琴发出的是钢琴的声音,小号发出的是小号的声响。或者,如果把每个动物当成一个对象,那么他们都有一个方法叫做吃,但是他们却产生不同的行为。

        如图:

       

        二、多态的实现。

        在C#中,多态性通过派生类覆写基类中的虚函数型方法来实现。那么怎样编写虚函数呢?

        基类的方法要加上关键字virtual后变成虚方法,才可以被重写,从而实现面向对象最重要的特征——多态性,即基类可以使用派生类的方法。

       

        public class Animal
        {
            public virtual void Eat()
            {
                Console.WriteLine("Eat something");
            }
        }

 

        public class Cat : Animal
        {
            public override void Eat()
            {  //完全取代基类方法
                Console.WriteLine("Eat small fishes!");
            }
        }
        public class Dog : Animal
        {
            public override void Eat()
            {  //完全取代基类方法
                Console.WriteLine("Eat small bones!");
            }
        }

 

        static void Main(string[] args) 
        {
            Animal mycat = new Cat();
            Animal mydog = new Dog();
            mycat.Eat();
            mydog.Eat();
        }

         运行结果如下:

       


 

               

       

       

<think>多态是面向对象编程的三大特性之一(封装、继承、多态)。在C#中,多态允许不同类的对象对同一消息做出响应,即同一个方法在不同对象中有不同的实现多态主要通过继承和接口实现,分为两种形式:编译时多态(静态多态)和运行时多态(动态多态)。 ### 1. 编译时多态(静态多态) 通过方法重载(overloading)实现。在同一个类中,多个方法具有相同的名称但不同的参数列表(类型、个数或顺序不同)。编译器在编译时根据传递的参数决定调用哪个方法。 示例代码: ```csharp public class Calculator { // 方法重载:两个整数相加 public int Add(int a, int b) { return a + b; } // 方法重载:三个整数相加 public int Add(int a, int b, int c) { return a + b + c; } // 方法重载:两个双精度浮点数相加 public double Add(double a, double b) { return a + b; } } ``` ### 2. 运行时多态(动态多态) 通过虚方法(virtual)和重写(override)实现,或者通过接口实现。在基类中声明虚方法,在派生类中重写该方法。程序在运行时根据对象的实际类型调用相应的方法。 示例代码: ```csharp public class Shape { public virtual void Draw() { Console.WriteLine("绘制一个形状"); } } public class Circle : Shape { public override void Draw() { Console.WriteLine("绘制一个圆形"); } } public class Rectangle : Shape { public override void Draw() { Console.WriteLine("绘制一个矩形"); } } public class Program { static void Main() { Shape[] shapes = new Shape[3]; shapes[0] = new Shape(); shapes[1] = new Circle(); shapes[2] = new Rectangle(); foreach (Shape shape in shapes) { shape.Draw(); // 运行时多态:根据实际对象类型调用相应的方法 } } } ``` 输出: ``` 绘制一个形状 绘制一个圆形 绘制一个矩形 ``` ### 3. 多态的作用 - **代码复用和扩展**:通过继承,子类可以复用父类的代码,并可以通过重写父类的方法来扩展或修改行为。 - **接口统一**:不同对象可以通过相同的接口(基类或接口)被操作,降低耦合度。 - **灵活性**:程序可以在运行时根据对象类型动态调用方法,使代码更灵活,易于维护和扩展。 - **可替换性**:子类对象可以替换父类对象,符合里氏替换原则(LSP)。 ### 4. 抽象类和接口实现多态 除了虚方法,还可以使用抽象类和接口实现多态。 #### 抽象类示例: ```csharp public abstract class Animal { public abstract void Speak(); // 抽象方法,必须被重写 } public class Dog : Animal { public override void Speak() { Console.WriteLine("汪汪!"); } } public class Cat : Animal { public override void Speak() { Console.WriteLine("喵喵!"); } } ``` #### 接口示例: ```csharp public interface ISpeak { void Speak(); } public class Dog : ISpeak { public void Speak() { Console.WriteLine("汪汪!"); } } public class Robot : ISpeak { public void Speak() { Console.WriteLine("你好!"); } } ``` ### 总结 C#中的多态使得代码更加模块化、可扩展和易于维护。通过方法重载实现编译时多态,通过虚方法、抽象类和接口实现运行时多态。 §§相关问题§§: 1. 什么是里氏替换原则(LSP)?它在多态中如何体现? 2. 在C#中,抽象类和接口在实现多态时有什么区别? 3. 如何通过委托(delegate)实现多态? 4. 请举例说明C#中方法隐藏(new关键字)与重写(override)的区别?</think>### C#多态的作用详解 多态(Polymorphism)是面向对象编程的四大基本原则之一(封装、抽象、继承、多态),在C#中主要通过继承、虚方法(`virtual`)、抽象方法(`abstract`)和方法重写(`override`)来实现多态的核心作用是**允许不同类的对象对同一消息做出不同响应**。 #### 多态的主要作用: 1. **代码复用性**:通过基类定义通用接口,派生类实现具体行为 2. **系统扩展性**:新增功能时只需添加新类,无需修改现有代码 3. **接口统一**:不同对象可通过相同接口进行操作 4. **运行时绑定**:程序运行时根据对象类型决定调用哪个方法 #### 实现多态的关键技术: ```csharp // 基类定义 public abstract class Shape { // 虚方法 - 可被子类重写 public virtual void Draw() { Console.WriteLine("绘制基本图形"); } // 抽象方法 - 必须被子类实现 public abstract double CalculateArea(); // 普通方法 public void DisplayType() { Console.WriteLine("我是图形类"); } } // 派生类1 public class Circle : Shape { public double Radius { get; set; } // 重写虚方法 public override void Draw() { Console.WriteLine("绘制圆形,半径:" + Radius); } // 实现抽象方法 public override double CalculateArea() { return Math.PI * Radius * Radius; } } // 派生类2 public class Rectangle : Shape { public double Width { get; set; } public double Height { get; set; } public override void Draw() { Console.WriteLine($"绘制矩形:{Width}x{Height}"); } public override double CalculateArea() { return Width * Height; } // 方法隐藏(使用new关键字) public new void DisplayType() { Console.WriteLine("我是矩形类"); } } // 使用多态 public class Program { public static void Main() { // 创建不同形状的集合 List<Shape> shapes = new List<Shape> { new Circle { Radius = 5 }, new Rectangle { Width = 10, Height = 20 } }; foreach (var shape in shapes) { shape.Draw(); // 多态调用 Console.WriteLine("面积: " + shape.CalculateArea()); // 多态调用 // 调用隐藏方法(非多态) shape.DisplayType(); // 调用基类方法 ((Rectangle)shape).DisplayType(); // 调用子类方法(需要显式转换) } } } ``` #### 代码解释: 1. **虚方法(`virtual`)**: - 基类中使用`virtual`声明的方法 - 派生类可选择使用`override`重写或保持默认实现 - 示例中`Draw()`方法展示了运行时多态 2. **抽象方法(`abstract`)**: - 在抽象类中声明,没有实现 - 派生类必须使用`override`实现 - 示例中`CalculateArea()`强制子类提供具体实现 3. **方法隐藏(`new`)**: - 当派生类需要定义与基类同名但行为不同的方法时使用 - 不是真正的多态,只是隐藏基类方法 - 示例中`DisplayType()`展示了方法隐藏的效果 4. **多态调用**: - 通过基类引用调用派生类实现(如`shape.Draw()`) - 实际执行哪个方法由对象类型决定(运行时类型) #### 多态的实际应用场景: 1. **插件系统**:通过统一接口扩展功能 2. **GUI框架**:不同控件响应相同事件 3. **游戏开发**:不同实体实现相同行为接口 4. **数据处理**:统一处理不同数据源
评论 31
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值