逍遥龙 发表于 2015-7-23 12:42:00

关于重写与虚方法的区别的研究

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{

        #region 重写父类同名方法
        class MyClass
        {
                public void ShowMessage()
                { Console.WriteLine("我是父类"); }
        }

        class MyClass1 : MyClass
        {
                new public void ShowMessage() // 这里就发生了重写,也可以说是隐藏了父类的方法. 这样做了之后就不能再使用父类的同名方法了.
                {
                        Console.WriteLine("我是子类");
                }
        }
        #endregion

        #region 覆盖父类的同名方法.
        class My
        {
                public virtual void SHowMessage()//使用virtual关键字表示这个方法会被覆盖.
                { Console.WriteLine("我是父类,我将要被覆盖."); }
        }

        class My1 : My
        {
                public override void SHowMessage()// 使用override 关键字来表示覆盖父类的同名方法.覆盖和重写不同的是覆盖可以再调用父类的同名方法, 加一个base关键字就可以了.
                {
                        Console.WriteLine("我是子类,我覆盖了父类的同名方法");
                        base.SHowMessage();// 这里就调用了父类的SHowMessage方法.
                }
        }
        #endregion

        class Program
        {
                static void Main(string[] args)
                {
                /*                     MyClass myClass = new MyClass();        //父类类型 父类对象
              MyClass1 myClass1= new MyClass1(); //子类类型子类对象
            MyClass tmp = myClass1;//父类类型子类对象
         //   MyClass1 tmp2 =(MyClass1)myClass;//子类类型 父类对象       无法强转
                 MyClass1 tmp2 =(MyClass1)tmp;//子类类型 原父类类型的子类对象 强转回子类对象
            myClass1.ShowMessage(); // 子类类型子类对象,调用子类方法
            myClass.ShowMessage(); // //父类类型 父类对象 调用父类方法
            tmp.ShowMessage(); // 父类类型子类对象 调用父类方法 (强转为父类对象,可以将父类对象的方法显示出来)
            tmp2.ShowMessage(); // 子类类型 原父类类型的子类对象 强转回子类对象调用子类方法*/
            //总结:new发生了隐藏,存在两个方法的内存空间,相互不影响,通过转换类型可以访问各自的方法
//***************************************************************************************************************************//
                        My myClass = new My();        //父类类型 父类对象
                        My1 myClass1= new My1(); //子类类型子类对象
                        My tmp = myClass1;//父类类型子类对象
                  //My1 tmp2 =(My1)myClass;//子类类型 父类对象       无法强转
                        My1 tmp2 =(My1)tmp;//子类类型 原父类类型的子类对象 强转回子类对象
                        myClass.SHowMessage(); // //父类类型 父类对象 调用父类方法
                        Console.WriteLine(1);
                        myClass1.SHowMessage(); // 子类类型子类对象,调用子类方法
                        Console.WriteLine(2);
                        tmp.SHowMessage(); // 父类类型子类对象 调用子类方法
                        Console.WriteLine(3);
                        tmp2.SHowMessage(); // 子类类型 原父类类型的子类对象 强转回子类对象调用子类方法
                        Console.WriteLine(4);
                        //总结:override发生了覆盖,创建子类对象的同时,子类的方法覆盖了父类的方法,使得调用(貌似子类的方法,其实是调用的是父类方法
                        //                        但是父类方法被子类方法覆盖,所以无论以何种方式调用虚方法,都是根据对象类型来判断的)
                        Console.ReadKey();
                }
        }
}

ibcadmin 发表于 2015-7-23 16:01:59

{:2_27:}

卖烤地瓜的 发表于 2015-8-4 16:40:51

override才是重写的意思,父类的虚方法才能被重写,直接在子类定义父类方法那才是覆盖
页: [1]
查看完整版本: 关于重写与虚方法的区别的研究