C#中重载(overload)和重写(override)的区别

快来打我* 2023-02-19 10:22 34阅读 0赞

**前言：前面我们详细讲解过C\#中的重载和重写,那它们到底有什么区别呢?我们往下看:**

**直通车：** **[C\#重载(overload)][C_overload]**、**[C\#重写(override)][C_override]**

### 目录： ###

*   *  一、两者的区别
     *  二、通过实例看看区别

## 一、两者的区别 ##

<table> 
 <thead> 
  <tr> 
   <th>区别类型</th> 
   <th>重载(overload)</th> 
   <th>重写(override)</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>定义</td> 
   <td>在一个类中的方法与另一个方法同名，但是参数列表不同，这种方法称为重载方法</td> 
   <td>当一个子类继承一个父类，子类中的方法名称、参数列表和父类完全相同时，则子类中这个方法重写了父类中的这个方法</td> 
  </tr> 
  <tr> 
   <td>实现</td> 
   <td>在一个类中使用相同的名称，不同的参数列表创建一个以上的方法、实例构造函数或属性</td> 
   <td>子类继承父类，在子类中修改父类的实现或者说在子类中重新编写。</td> 
  </tr> 
  <tr> 
   <td>函数限制</td> 
   <td>构造函数和一般函数都可以实现重载</td> 
   <td>父类中有抽象方法或者虚方法的时候，在子类中才能重写</td> 
  </tr> 
  <tr> 
   <td>修饰符</td> 
   <td>与修饰符无关</td> 
   <td>重写父类的方法时,不能修改这个方法的访问修饰符</td> 
  </tr> 
  <tr> 
   <td>返回类型</td> 
   <td>可以不同</td> 
   <td>必须相同</td> 
  </tr> 
  <tr> 
   <td>与面向对象</td> 
   <td>多态(同一个类中)</td> 
   <td>继承(必须继承父类)</td> 
  </tr> 
  <tr> 
   <td>作用</td> 
   <td>减少了函数名的数量,避免了名字空间的污染,可应对不同的需求</td> 
   <td>重写是为了增强类的重用性、复用性，扩展性;重写是对父类中方法的扩展,子类继承了父类,重写后,子类不但得到了父类的东西，而且还可以有自己的东西。</td> 
  </tr> 
 </tbody> 
</table>

**补充**：对C\#中构造函数和继承还不太了解的可以访问 **[C\#构造函数超详解][C]**、**[C\#继承超详解][C 1]**

--------------------

## 二、通过实例看看区别 ##

//重载
        class Student
        {
        
            public Student()
            {
        
                Console.WriteLine("无参构造函数");
            }
            public Student(string name, int code)
            {
        
                Console.WriteLine("具有两个参数的构造函数");
            }
            public Student(int code,string name)
            {
        
                Console.WriteLine("也具有两个参数的构造函数,但是和上面的参数顺序不一样");
            }
            public Student(int code, string name, string sex, int num)
            {
        
                Console.WriteLine("具有四个参数的构造函数");
            }
            public void run()
            {
        
                Console.WriteLine("无参run方法");
            }
            public void run(int code, int num)
            {
        
                Console.WriteLine("具有两个整型参数的run方法");
            }
            public void run(int code, string name)
            {
        
                Console.WriteLine("具有两个参数(先整型后字符串)的run方法");
            }
            public void run( string name, int code)
            {
        
                Console.WriteLine("具有两个参数(先字符串后整型)的run方法");
            }
            public void run(int num, string name, int code)
            {
        
                Console.WriteLine("具有三个参数的run方法");
            }
            public void run(string name, int code, string sex, int num)
            {
        
                Console.WriteLine("具有四个参数的run方法");
            }
        }
    
        //重写
        class Peopole
        {
        
            //使用虚方法需要使用virtual关键字
            public virtual void run()
            {
        
                Console.WriteLine("人类会跑步");
            }
            public virtual void say()
            {
        
                Console.WriteLine("人类会说话");
            }
        }
    
        class Man : Peopole
        {
        
            //重写方法
            public override void run()
            {
        
                base.run();//调用基类run方法
                Console.WriteLine("男人会跑步");
            }
            public override void say()
            {
        
                base.say();//调用基类say方法
                Console.WriteLine("男人会说话");
            }
        }
        abstract class Person
        {
        
            //使用抽象方法时,方法对应的类必须是抽象类,并且抽象方法不能有主体(具体表现)
            public abstract void study();
            public abstract void song();
        }
        class Children : Person
        {
        
            //继承一个抽象类,子类中一定全部重写父类中的所有抽象方法
            public override void study()
            {
        
                Console.WriteLine("小孩学习");
            }
            public override void song()
            {
        
                Console.WriteLine("小孩唱歌");
            }
        }
        class Program
        {
        
            static void Main(string[] args)
            {
        
                Console.WriteLine("===========重载=============");
                Student stu1 = new Student();
                Student stu2 = new Student("小明", 85);
                Student stu3 = new Student(85,"小明");
                Student stu4 = new Student(99, "张三", "男", 2019);
                stu1.run();
                stu1.run(88, 2020);
                stu1.run(92,"李四");
                stu1.run("李四",92);
                stu2.run(2018, "李四", 76);
                stu3.run("王麻子", 60, "男", 2017);
    
                Console.WriteLine("===========重写=============");           
                Console.WriteLine("===虚方法重写===");
                Man man = new Man();
                man.run();
                man.say();
    
                Console.WriteLine("===抽象方法重写===");
                Children children = new Children();
                children.study();
                children.song();
    
    
                Console.ReadLine();
            }
        }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdTk5MTAyOQ_size_16_color_FFFFFF_t_70]

--------------------

# 若有不足之处提出来,快来评论区抢沙发啦!!! #

[C_overload]: https://blog.csdn.net/liu991029/article/details/106810361
[C_override]: https://blog.csdn.net/liu991029/article/details/106816370
[C]: https://blog.csdn.net/liu991029/article/details/106550226
[C 1]: https://blog.csdn.net/liu991029/article/details/106605207
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdTk5MTAyOQ_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200621215103569.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdTk5MTAyOQ==,size_16,color_FFFFFF,t_70