C#中的重载和重写

 前面在C#虚函数的文章里提到了重写(override), 虚函数和重写实现了面向对象语言在运行阶段的多态性, 而重载实现了在编译阶段的多态性.

重写(override)

  重写指的是当父类中有抽象函数虚函数时, 在子类中实现或重新实现了这些函数, 就完成了对父类函数的重写, 当对象的实例类为子类时, 调用的函数是子类中重写的函数. 重写使用关键字override, 要求重写函数的函数名, 返回值, 参数列表与被重写的函数完全相同.

代码来了!

	public class GoodClass
    {
        public virtual void GoodFunc()
        {
            Console.WriteLine("This is a good function!!!");
        }
    }

    public class NiceClass : GoodClass
    {
        public override void GoodFunc()
        {
            Console.WriteLine("This is a nice function");
        }
    }

    public abstract class GreatClass
    {
        public abstract void GreatFunc();
    }

    public class FineClass : GreatClass
    {
        public override void GreatFunc()
        {
            Console.WriteLine("Have a good day");
        }
    }

重载

 重载指的是在一个类中, 有一系列相同函数名, 不同参数列表, 不同返回类型(非强制要求)的函数, 在编译时, 根据传参情况来选择最佳的的函数. 当两个函数函数名相同, 参数列表相同, 只有返回值不同时会有报错, 此时不构成重载. 参数列表顺序不同也不构成重载.

代码来了!

public class GoodClass
    {
        private void GoodFunc(int a){}
        
        private void GoodFunc(int a,int b){}
        
        private void GoodFunc(double c){}

        private int GoodFunc(int a,double b)
        {
            return a;
        }
    }
<think>我们被要求解释C#重载(Overload)与重写(Override)的区别。这是一个面向对象编程中的基础概念,我们需要清晰地解释两者的定义、使用场景区别,并给出代码示例。 ###重载(Overload)的定义重载发生在同一个类中,方法名相同但参数列表不同(参数类型、个数或顺序不同)。重载与返回值类型无关,主要目的是提供多种方式来处理不同的输入。###重写(Override)的定义重写发生在继承关系中,子类重新定义父类中已经声明为virtual或abstract的方法。重写要求方法签名(方法名参数列表)必须与父类方法完全一致,主要目的是实现多态性。###主要区别1. **发生位置**:重载在同一个类中,重写在子类中。2.**参数要求**:重载要求参数列表不同,重写要求参数列表相同。 3. **返回类型**:重载可以有不同的返回类型(但仅返回类型不同不能构成重载),重写要求返回类型相同(C#9开始支持协变返回类型)。4.**访问修饰符**:重载可以有不同的访问修饰符,重写不能改变父类方法的访问级别。5.**多态性**:重载是编译时多态(静态多态),重写是运行时多态(动态多态)。 ###代码示例####重载示例```csharppublic classCalculator{//第一个Add方法,接受两个整数publicint Add(int a, intb){returna +b;}//重载Add方法,接受三个整数publicint Add(int a, intb,int c){return a+ b+ c;}//重载Add方法,接受两个双精度浮点数publicdouble Add(double a, doubleb){returna +b;}//注意:以下代码不能与上面的intAdd(inta,int b)同时存在,因为仅返回类型不同不能重载//public doubleAdd(inta,int b) {returna +b;} }//使用varcalc =new Calculator(); Console.WriteLine(calc.Add(1,2));//调用第一个Add,输出3Console.WriteLine(calc.Add(1,2,3));//调用第二个Add,输出6Console.WriteLine(calc.Add(1.5,2.5));//调用第三个Add,输出4.0``` ####重写示例```csharppublicclass Animal{publicvirtual voidMakeSound(){Console.WriteLine("Animalmakes asound");}} publicclass Dog: Animal{publicoverride voidMakeSound(){Console.WriteLine("Dogbarks: Woof!");}} publicclass Cat: Animal{publicoverride voidMakeSound(){Console.WriteLine("Catmeows: Meow!");}} //使用Animal myDog= newDog();AnimalmyCat= newCat();myDog.MakeSound();//输出:Dog barks:Woof! myCat.MakeSound(); //输出: Catmeows: Meow!//如果没有重写,则调用基类方法Animal animal= newAnimal();animal.MakeSound(); //输出: Animalmakes asound``` ###对比表格|特性|重载(Overload)|重写(Override)||--------------|----------------------------------------|----------------------------------------| |**发生位置**|同一个类中|子类中| |**方法签名**|必须不同(参数类型、个数或顺序)|必须相同| |**返回类型**|可以不同(但仅返回类型不同不能重载)|必须相同(C#9+支持协变返回)| |**访问修饰**|可以不同|不能比基类方法更严格| |**多态性**|编译时多态(静态)|运行时多态(动态)| |**关键字**|不需要关键字|需要`virtual``override`| |**继承要求** |不需要继承关系|必须有继承关系|###注意事项1.**重载解析**:编译器根据参数类型数量在编译时决定调用哪个重载方法。2.**重写条件**:只有标记为`virtual`、`abstract`或`override`(基类中)的方法才能被重写。 3. **隐藏(new)与重写**:如果子类中声明了与基类同名的方法但没有使用`override`,则使用`new`关键字(可显式或隐式)表示隐藏,这不同于重写。隐藏不会实现多态。###隐藏(new)与重写(override)的简单对比```csharppublicclass Base{publicvirtual voidMethod() =>Console.WriteLine("Base"); }public classDerivedOverride: Base{publicoverride voidMethod()=> Console.WriteLine("DerivedOverride");} publicclass DerivedNew :Base{public newvoid Method() =>Console.WriteLine("DerivedNew"); }//使用Base b1 =new DerivedOverride();b1.Method(); //输出: DerivedOverride (多态) Baseb2= newDerivedNew(); b2.Method(); //输出: Base(因为隐藏,所以调用基类方法)DerivedNew d= newDerivedNew(); d.Method();//输出:DerivedNew``` ###总结-重载:同一类中,同名方法不同参数,编译时决定调用。-重写:子类重写父类方法,实现多态,运行时根据对象类型决定调用。---§§相关问题§§:1. C#中`new`关键字在方法隐藏中的具体行为是什么?2.什么是协变返回类型?C#中如何实现?3.在方法重载中,如果参数类型存在继承关系,编译器如何解析?4.抽象方法(abstract)虚方法(virtual)在重写时有何异同?</think>### C#重载(Overload)与重写(Override)的区别详解 重载(Overload)重写(Override)是C#中两个核心但完全不同的面向对象概念,它们在目的、实现方式应用场景上有本质区别: #### 核心区别对比表 | 特性 | 重载(Overload) | 重写(Override) | |--------------|------------------------------------|---------------------------------| | **发生位置** | 同一个类中 | 继承关系的派生类中 | | **目的** | 提供同一操作的多种实现方式 | 修改或扩展基类行为 | | **方法签名** | 必须不同(参数类型/数量/顺序) | 必须完全相同 | | **多态性** | 编译时多态(静态绑定) | 运行时多态(动态绑定) | | **关键字** | 不需要特殊关键字 | 需要`virtual``override` | | **返回类型** | 可以不同 | 必须相同(C#9+支持协变返回) | | **继承要求** | 不需要继承关系 | 必须有继承关系 | --- ### 代码示例与详细解释 #### 1. 重载(Overload)示例 ```csharp public class Calculator { // 重载1: 两个整数相加 public int Add(int a, int b) { Console.WriteLine($"Adding integers: {a} + {b}"); return a + b; } // 重载2: 三个整数相加(参数数量不同) public int Add(int a, int b, int c) { Console.WriteLine($"Adding three integers: {a} + {b} + {c}"); return a + b + c; } // 重载3: 两个双精度数相加(参数类型不同) public double Add(double a, double b) { Console.WriteLine($"Adding doubles: {a} + {b}"); return a + b; } // 重载4: 整数字符串相加(参数顺序不同) public string Add(string a, int b) { Console.WriteLine($"Concatenating: {a} + {b}"); return a + b.ToString(); } // 错误示例:仅返回类型不同不能构成重载 // public double Add(int a, int b) { return (double)(a + b); } } // 使用 var calc = new Calculator(); calc.Add(2, 3); // 调用第一个Add calc.Add(1.5, 2.5); // 调用第三个Add calc.Add("Result: ", 5); // 调用第四个Add ``` #### 2. 重写(Override)示例 ```csharp public class Shape { // 虚方法 - 可被重写 public virtual void Draw() { Console.WriteLine("Drawing a generic shape"); } // 非虚方法 - 不能被重写 public void DisplayInfo() { Console.WriteLine("Shape information"); } } public class Circle : Shape { // 重写基类虚方法 public override void Draw() { Console.WriteLine("Drawing a circle"); base.Draw(); // 可选调用基类实现 } // 错误示例:不能重写非虚方法 // public override void DisplayInfo() { } } public class Square : Shape { // 重写基类虚方法 public override void Draw() { Console.WriteLine("Drawing a square"); } } // 使用多态 Shape circle = new Circle(); Shape square = new Square(); circle.Draw(); // 输出: Drawing a circle \n Drawing a generic shape square.Draw(); // 输出: Drawing a square ``` #### 3. 重载重写结合使用 ```csharp public class DatabaseLogger { // 基类方法 - 可被重写 public virtual void Log(string message) { Console.WriteLine($"LOG: {message}"); } // 重载方法1 public void Log(string message, int severity) { Console.WriteLine($"[{severity}] {message}"); } } public class EncryptedLogger : DatabaseLogger { // 重写基类方法 public override void Log(string message) { string encrypted = Encrypt(message); base.Log(encrypted); } // 重载方法2(在派生类中) public void Log(string message, string category) { Console.WriteLine($"[{category}] {message}"); } private string Encrypt(string input) => new string(input.Reverse().ToArray()); } // 使用 DatabaseLogger logger = new EncryptedLogger(); logger.Log("Sensitive data"); // 调用重写方法,输出加密内容 var encLogger = new EncryptedLogger(); encLogger.Log("Info message", "SECURITY"); // 调用派生类重载 ``` --- ### 关键区别详解 1. **绑定时机不同** - 重载:编译时决定调用哪个方法(早期绑定) ```csharp var calc = new Calculator(); calc.Add(1, 2); // 编译时确定调用int Add(int, int) ``` - 重写:运行时根据实际对象类型决定(晚期绑定) ```csharp Shape shape = new Circle(); shape.Draw(); // 运行时确定调用Circle.Draw() ``` 2. **方法签名要求** - 重载要求参数列表必须不同: ```csharp // 有效重载 void Method(int a) {} void Method(string a) {} void Method(int a, int b) {} ``` - 重写要求签名完全相同: ```csharp public class Base { public virtual void Test(int x) {} } public class Derived : Base { // 有效重写 public override void Test(int y) {} // 参数名可不同 // 无效:参数类型不同 // public override void Test(string x) {} } ``` 3. **继承关系中的行为** - 重载方法在派生类中**不会**自动继承重载关系 - 重写方法在派生类中形成多态链 4. **异常处理差异** - 重载方法可以抛出不同的异常类型 - 重写方法不能抛出比基类方法更宽泛的异常: ```csharp public class Base { public virtual void Process() throws IOException { } } public class Derived : Base { // 有效 public override void Process() { } // 无效:不能抛出更宽泛异常 // public override void Process() throws Exception { } } ``` --- ### 实际应用场景 1. **重载的典型应用** ```csharp // 数学计算类 public class MathOperations { public int Max(int a, int b) => (a > b) ? a : b; public double Max(double a, double b) => (a > b) ? a : b; public int Max(int a, int b, int c) => Max(Max(a, b), c); } ``` 2. **重写的典型应用** ```csharp // 游戏实体系统 public abstract class GameEntity { public virtual void Update() { /* 基础更新逻辑 */ } } public class Player : GameEntity { public override void Update() { base.Update(); // 保留基础行为 // 玩家特有更新逻辑 } } public class Enemy : GameEntity { public override void Update() { // 完全重写的敌人行为 } } ``` ---
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值