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

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

直通车： C#重载(overload)、C#重写(override)

目录：

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

一、两者的区别

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

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

二、通过实例看看区别

//重载
    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();
        }
    }
           

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