第二节：重写（new）、覆写（overwrite）、和重载（overload）

一. 重写

　　1. 关键字：new

　   2. 含义：子类继承父类中的普通方法，如果在子类中重写了一个和父类中完全相同的方法，子类中会报警告(问是否显式的隐藏父类的中的方法)，如果在子类中的方法前加上new关键字，则警告消失。

　　注意：

　　　　* 虽然可以不使用 new 修饰符来隐藏成员，但将收到编译器警告。 如果使用 new 来显式隐藏成员，将禁止此警告。

　　　　* 这里需要特别注意，隐藏父类方法是指声明的完全是子类实例,eg child类继承parent类, 并在child类中重新声明了一个和parent中相同的方法show。

　　那么分两种情况：

　　* a. child c=new child(); c.show()进行调用，无论child类中的show方法前加没加new关键字，调用的都是child类中的方法,只是加上new关键字后，不出警告。

　　* b. parent p=new child(); p.show()进行调用，无论child类中的show方法前加没加new关键字，调用的都是parent类中的方法，这是里氏替换原则的用法，不满足上述声明的new关键字替换父类中的方法的描述。

　　3. 声明一个parentClass父类，里面有三个方法。

  public abstract class parentClass
    {
        //下面两个普通方法实现自身的重载
        public void CommonMethord1()
        {
            Console.WriteLine("parentClass CommonMethord1");
        }
        public void CommonMethord1(string msg)
        {
            Console.WriteLine("parentClass CommonMethord1");
        }
        public void CommonMethord2()
        {
            Console.WriteLine("parentClass CommonMethord2");
        }
    }

　　4. 声明一个childClass类，里面重写了两个方法。

 public class childClass : parentClass
    {
        /// <summary>
        /// 单独声明子类实例的时候(无里氏替换原则),将替换父类中的方法，里氏替换原则不适用
        /// </summary>
        public void CommonMethord1()
        {
            Console.WriteLine("childClass CommonMethord1");
        }
        /// <summary>
        /// new 关键字去除上述警告，单独声明子类实例的时候(无里氏替换原则),将替换父类中的方法，里氏替换原则不适用
        /// </summary>
        /// <param name="msg"></param>
        public new void CommonMethord1(string msg)
        {
            Console.WriteLine("childClass CommonMethord1");
        }
    }

　　5. 调用

 {
                parentClass p1 = new childClass();
                childClass p2 = new childClass();
                Console.WriteLine("-----------------------------1.子类的直接调用--------------------------------------");
                p2.CommonMethord1();          //结果：子类方法    (非显式隐藏，但也隐藏了，会报警告)
                p2.CommonMethord1("ddd");     //结果：子类方法    (含有new关键字，显式的隐藏了父类中的方法，没有警告)
                p2.CommonMethord2();          //结果：父类方法

                Console.WriteLine("-----------------------------2.抽象类(也符合里氏替换原则)的形式调用--------------------------------------");
                p1.CommonMethord1();         //结果：父类方法    
                p1.CommonMethord1("ddd");    //结果：父类方法  
                p1.CommonMethord2();         //结果：父类方法
}

二. 覆写

　　1. 关键字：override

　　2. 含义：在子类中，继承的父类中的抽象方法(abstract)和虚方法(virtual),子类可以对其进行覆写,其中父类中的抽象方法,子类中必须被覆写

　　　　抽象方法：没有方法体，子类必须覆写

　　　　虚方法：必须有方法体，子类可以对其进行覆写，也可以不进行覆写

     3. 新建一个名叫parentClass的抽象类，里面有一个抽象方法和两个虚方法。

   public abstract class parentClass
    {
        //下面为抽象方法
        public abstract void abstractMethord();
        //下面两个方法为虚方法
        public virtual void virtualMethord1()
        {
            Console.WriteLine("parentClass virtualMethord1");
        }
        public virtual void virtualMethord2()
        {
            Console.WriteLine("parentClass virtualMethord2");
        }
    }

　　4. 新建一个childClass子类，继承parentClass类，并且对virtualMethord2虚方法进行覆写

  public class childClass : parentClass
    {

        public override void abstractMethord()
        {
            Console.WriteLine("childClass abstractMethord");
        }
        //加上sealed关键字，子类将不能对其继续进行覆写
        public sealed override void virtualMethord2()
        {
            Console.WriteLine("childClass virtualMethord2");
        }
    }

　　5. 调用

 　　　　　　　　 parentClass p1 = new childClass();
                childClass p2 = new childClass();
                Console.WriteLine("-----------------------------1.子类的直接调用--------------------------------------");
                p2.abstractMethord();           //结果：子类方法
                p2.virtualMethord1();           //结果：父类方法
                p2.virtualMethord2();           //结果：子类方法
                Console.WriteLine("-----------------------------2.抽象类(也符合里氏替换原则)的形式调用--------------------------------------");
                p1.abstractMethord();           //结果：子类方法
                p1.virtualMethord1();           //结果：父类方法
                p1.virtualMethord2();           //结果：子类方法

三. 重载（overload）

　　1. 关键字：无关键字
　　2. 含义：在同一个类中，同一个名称的方法参数的个数不同、参数类型不同、参数个数和参数类型都不同
　　eg: parentClass中的CommonMethord1的两个方法就是重载