C# 重写和重载

重写和重载，他们其实是实现类型多态（同一种方法，不同的对象会产生不同的结果）特性的基本技术之一，两种技术貌似而实质截然不同。 

重载的条件：

1.必须在同一个类中

2.方法名必须相同

3.参数列表不能相同。

重写的条件：

          1. 在不同的类中

          2. 发生方法重写的两个方法返回值，方法名，参数列表必须完全一致

          3. 子类抛出的异常不能超过父类相应的方法抛出的异常

          4. 子类方法的访问级别不能低于父类相应方法的访问级别（public，package，protected， private）

          5.方法体不同

super()调用父类构造，super.只能调用父类的实例方法

this()调用该类的其他构造方法,this.调用类的属性，方法

如果父类有有参构造函数，子类必须定义构造方法

重载：

重载发生在同一个类中，重载主要是针对同一个类中方法名相同但参数（必须的）不同或返回类型（不是必须的）不同的情况。但是往往我们以为只要是方法的签名不一样，就能构成重载，而事实并未如此，例如下面两个方法

public void getBase(string name)

   {

      Console.Write("my name is "+name);

   }

private string getBase(string name)

  {

     return name;

  }

public void aa(string age)

{

    getBase(age);

}
      getBase方法因为返回值的类型不一样，所以我们可以说他们是两个具有不同签名的函数，事实证明他们并不能构成重载，而会出现错误“ 类型override.BaseClass已定义了一个名为“getBase”的具有相同参数类型的成员” ，这在C# 中是不允许的。所以重载一定是几个具有相同方法名但参数（必须的）不同的函数。

如下代码：

class OverLoadTest

    {

        public void Hello()

        {

        }

        public void Hello(string str)

        {

        }

        public string Hello()

        {

        }

    }

在这段代码中有三个具有相同名称的方法Hello，他们彼此之间是重载的关系，注意两点：他们共同存在于一个类中，虽有同样的名字但是执行不同的操作；第一个方法和第三个方法只有返回类型不同，这在C# 中是不允许的，编译器会报出“已定义一个名为"Hello"的方法”的错误。

重载其实是一种编译时多态技术，就是说在编译时就知道调用的是哪个方法，这其实很好理解，所谓重载就是在同一个类中的多个同名方法，但这些方法的参数类表不同（参数个数，或者是相同位置的参数类型不同），而返回值可以相同，也可以不相同，这些方法具有不同的方法签名，也就是说是不同的方法．从编译器的角度，不同的方法，就是不同的方法地址，在编译时就已经确定，是一种静态绑定．

特征：

１：存在于同一个类中

２：具有相同的函数名，但参数列表不同，函数返回值类型可以相同也可以不同．

三：抽象方法与虚方法的区别

1．虚方法有一个实现部分可以被子类继承，从而使子类获得和基类相同的方法，另外也为派生类提供了覆盖该方法的选项。相反，抽象方法没有提供实现部分，是一种强制派生类覆盖的方法（否则派生类不能成具体类）

2.（abstract）抽象方法只能在抽象类中声明,（virtual）虚方法不是。

3.（abstract）抽象方法必须在派生类中重写而（virtual）虚方法不必。

4.（abstract）抽象方法不能声明方法实体，虚方法可以。

5.虚方法不能是静态的，密封的．

   可以理解为抽象方法是没有方法实现的虚方法．包含抽象方法（只有抽象类才可以包含抽象方法）的类不能实例化（也就是说只可以使用predected和private修饰符），虚方法可以。四：其实由于泛型的出现，具有相同参数列表和相同返回值类型的方法也能构成重载。

重写：

也叫做覆写，它存在与有继承关系的子类中，是在子类中重新定义父类具有相同方法签名的函数，使之有不同的实现．要理解重写和重载的本质区别，实现要理解什么叫做具有相同签名的方法．其实很简单，就是指相同的方法名，相同的参数列表（参数个数以及相同位置的参数类型相同）以及相同的函数返回值．重写的一个重要特征就是必须要求方法的签名相同．下面说说重写的基本特征：

１．是一种运行时多态，又称为动态联编，只有在运行时才知道调用的是哪个方法．

２．存在于有继承关系的子类中，只有被virtual和abstract标记的虚方法和抽象方法才能被直接重写．

３．用关键字override来标记．

４．重写这个方法的类的父类中有一个与这个方法签名相同的方法．

讲到这里，很多人可能会想到Ｃ＃中的new关键字也能实现子类对父类中签名相同的方法的重写啊，在此详细讲下其中的区别．其实New关键字主要用来区别派生类和基类同名方法的选择问题，通过隐藏基类方法，达到使编译器调用正确的方法的目的。Override主要用来对基类的虚方法进行重写．

using System;

using System.Collections.Generic;

using System.Text;

namespace Toverride

{

    class Program

    {

        static void Main(string[] args)

        {

            BaseClass mybase = new BaseClass();

            //BaseClass mybase = new ChildClass();

            mybase.getBase("leening");

            Console.Read();

        }

    }

    public class BaseClass

    {

        public virtual void getBase(string name)

        {

            Console.Write("base:my name is " + name);

        }

    }

    public class ChildClass : BaseClass

    {

        public new void getBase(string name)

        {

            Console.Write("child:my name is " + name);

        }

    }

}

输出：base:my name is leening

再看以下这段程序

using System;

using System.Collections.Generic;

using System.Text;

namespace @override

{

    class Program

    {

        static void Main(string[] args)

        {

            //BaseClass mybase = new BaseClass();

            BaseClass myChild = new ChildClass();

            BaseClass myOverride = new OverrideClass();

            myChild.getBase("leening");

            myOverride.getBase("leening");

            Console.Read();

        }

    }

    public class BaseClass

    {

        public virtual void getBase(string name)

        {

            Console.WriteLine("base:my name is " + name);

        }

    }

    public class ChildClass : BaseClass

    {

        public new void getBase(string name)

        {

            Console.WriteLine("child:my name is " + name);

        }

    }

    public class OverrideClass : BaseClass

    {

        public override void getBase(string name)

        {

            Console.WriteLine("override:my name is " + name);

        }

    }

}

输出：base:my name is leening

　　　override:my name is leening

  重写发生在有继承关系的类之间，重写发生在派生类上，通过override关键字来改写从其父类继承过来的具有相同返回值，方法名称和参数列表的方法。

    class Program

    {

        static void Main(string[] args)

        {

            OverWriteTestTT owTT = new OverWriteTestTT();

            owTT.Hello();

            overWriteTestTTT owTTT = new overWriteTestTTT();

            owTTT.Hello();

        }

    }

    class OverWriteTest

    {

        //Over write the method ToString();

        public override string ToString()

        {

            return "hello world";

        }

        //Define a virtual method Hello() to be over written

        public virtual void Hello()

        {

            Console.WriteLine("hello");

        }

    }

    class OverWriteTestTT : OverWriteTest

    {

        public override void Hello()

        {

            Console.WriteLine("No hello world");

        }

    }

    class overWriteTestTTT : OverWriteTestTT

    {

        //Over write the method Hello() of class OverWriteTestTT

        public override void Hello()

        {

            base.Hello();

            Console.WriteLine("NNo hello world");

        }

    }

上面这段代码演示了如何对父类的方法进行重写，需要注意的地方有两点：可以在子类中被重写的方法一定要被标记成virtual(虚拟), abstract（抽象), override(重写）标记为virtual 和abstract 的函数就是为了重写而创建的，标记为override的函数本身是由前两种函数重写而来的，所以它可以被重写也是顺理成章的了；重写的函数必须在子类中出现，而且任何一个父类的函数在其一个子类中只能被重写一次。（这一点很好理解，当你要重写两次时，该子类中将定义两个返回类型，方法名称 和参数列表都相同的函数，这肯定是不可能的）。